Remove DateCalculator

2025-12-06 09:08:52 -06:00 · 2019-03-30 20:36:14 -05:00
parent 70a79856f2
commit aa6b13f3a6
23 changed files with 278 additions and 235 deletions
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -26,7 +26,7 @@ buildscript {

    dependencies {
        classpath "com.android.tools.build:gradle:3.2.1"
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.21"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.3.11"
    }
 }

@@ -42,17 +42,11 @@ apply plugin:"kotlin-multiplatform"

 kotlin {
    targets {
+        def iosPreset = System.getenv('SDK_NAME')?.startsWith("iphoneos") ? presets.iosArm64 : presets.iosX64
        fromPreset(presets.jvm, 'jvm')
-
-        fromPreset(presets.iosX64, 'iOS') {
+        fromPreset(iosPreset, 'iOS') {
            compilations.main.outputKinds('FRAMEWORK')
        }
-
-        // Replace the target above by the following one to produce a framework
-        // which can be installed on a real iPhone:
-        // fromPreset(presets.iosArm64, 'iOS') {
-        //     compilations.main.outputKinds('FRAMEWORK')
-        // }
    }

    sourceSets {
--- a/core/src/commonMain/kotlin/org/isoron/platform/time/Dates.kt
+++ b/core/src/commonMain/kotlin/org/isoron/platform/time/Dates.kt
@@ -31,48 +31,143 @@ enum class DayOfWeek(val index: Int) {
    SATURDAY(6),
 }

-data class Timestamp(val unixTimeInMillis: Long)
+data class Timestamp(val millisSince1970: Long) {
+    val localDate: LocalDate
+        get() {
+            val millisSince2000 = millisSince1970 - 946684800000
+            val daysSince2000 = millisSince2000 / 86400000
+            return LocalDate(daysSince2000.toInt())
+        }
+}

-data class LocalDate(val year: Int,
-                     val month: Int,
-                     val day: Int) {
+data class LocalDate(val daysSince2000: Int) {
+
+    var yearCache = -1
+    var monthCache = -1
+    var dayCache = -1
+
+    init {
+        if (daysSince2000 < 0)
+            throw IllegalArgumentException("$daysSince2000 < 0")
+    }
+
+    constructor(year: Int, month: Int, day: Int) :
+            this(daysSince2000(year, month, day))
+
+    val dayOfWeek: DayOfWeek
+        get() {
+            return when (daysSince2000 % 7) {
+                0 -> DayOfWeek.SATURDAY
+                1 -> DayOfWeek.SUNDAY
+                2 -> DayOfWeek.MONDAY
+                3 -> DayOfWeek.TUESDAY
+                4 -> DayOfWeek.WEDNESDAY
+                5 -> DayOfWeek.THURSDAY
+                else -> DayOfWeek.FRIDAY
+            }
+        }
+
+    val timestamp: Timestamp
+        get() {
+            return Timestamp(946684800000 + daysSince2000.toLong() * 86400000)
+        }
+
+    val year: Int
+        get() {
+            if (yearCache < 0) updateYearMonthDayCache()
+            return yearCache
+        }
+
+    val month: Int
+        get() {
+            if (monthCache < 0) updateYearMonthDayCache()
+            return monthCache
+        }
+
+    val day: Int
+        get() {
+            if (dayCache < 0) updateYearMonthDayCache()
+            return dayCache
+        }
+
+    private fun updateYearMonthDayCache() {
+        var currYear = 2000
+        var currDay = 0
+
+        while (true) {
+            val currYearLength = if (isLeapYear(currYear)) 366 else 365
+            if (daysSince2000 < currDay + currYearLength) {
+                yearCache = currYear
+                break
+            } else {
+                currYear++
+                currDay += currYearLength
+            }
+        }
+
+        var currMonth = 1
+        val monthOffset = if (isLeapYear(currYear)) leapOffset else nonLeapOffset
+
+        while (true) {
+            if (daysSince2000 < currDay + monthOffset[currMonth]) {
+                monthCache = currMonth
+                break
+            } else {
+                currMonth++
+            }
+        }
+
+        currDay += monthOffset[currMonth - 1]
+        dayCache = daysSince2000 - currDay + 1
+
+    }

    fun isOlderThan(other: LocalDate): Boolean {
-        if (other.year != year) return other.year > year
-        if (other.month != month) return other.month > month
-        return other.day > day
+        return daysSince2000 < other.daysSince2000
    }

    fun isNewerThan(other: LocalDate): Boolean {
-        if (this == other) return false
-        return other.isOlderThan(this)
+        return daysSince2000 > other.daysSince2000
    }

-    init {
-        if ((month <= 0) or (month >= 13)) throw(IllegalArgumentException())
-        if ((day <= 0) or (day >= 32)) throw(IllegalArgumentException())
+    fun plus(days: Int): LocalDate {
+        return LocalDate(daysSince2000 + days)
    }
-}

-interface LocalDateCalculator {
-    fun plusDays(date: LocalDate, days: Int): LocalDate
-    fun dayOfWeek(date: LocalDate): DayOfWeek
-    fun toTimestamp(date: LocalDate): Timestamp
-    fun fromTimestamp(timestamp: Timestamp): LocalDate
-}
+    fun minus(days: Int): LocalDate {
+        return LocalDate(daysSince2000 - days)
+    }

-fun LocalDateCalculator.distanceInDays(d1: LocalDate, d2: LocalDate): Int {
-    val t1 = toTimestamp(d1)
-    val t2 = toTimestamp(d2)
-    val dayLength = 24 * 60 * 60 * 1000
-    return abs((t2.unixTimeInMillis - t1.unixTimeInMillis) / dayLength).toInt()
-}
-
-fun LocalDateCalculator.minusDays(date: LocalDate, days: Int): LocalDate {
-    return plusDays(date, -days)
+    fun distanceTo(other: LocalDate): Int {
+        return abs(daysSince2000 - other.daysSince2000)
+    }
 }

 interface LocalDateFormatter {
    fun shortWeekdayName(date: LocalDate): String
    fun shortMonthName(date: LocalDate): String
+}
+
+private fun isLeapYear(year: Int): Boolean {
+    return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
+}
+
+val leapOffset = arrayOf(0, 31, 60, 91, 121, 152, 182,
+                         213, 244, 274, 305, 335, 366)
+val nonLeapOffset = arrayOf(0, 31, 59, 90, 120, 151, 181,
+                            212, 243, 273, 304, 334, 365)
+
+private fun daysSince2000(year: Int, month: Int, day: Int): Int {
+
+    var result = 365 * (year - 2000)
+    result += ceil((year - 2000) / 4.0).toInt()
+    result -= ceil((year - 2000) / 100.0).toInt()
+    result += ceil((year - 2000) / 400.0).toInt()
+    if (isLeapYear(year)) {
+        result += leapOffset[month - 1]
+    } else {
+        result += nonLeapOffset[month - 1]
+    }
+    result += (day - 1)
+    return result
 }
--- a/core/src/commonMain/kotlin/org/isoron/uhabits/backend/Backend.kt
+++ b/core/src/commonMain/kotlin/org/isoron/uhabits/backend/Backend.kt
@@ -30,7 +30,6 @@ class Backend(databaseName: String,
              databaseOpener: DatabaseOpener,
              fileOpener: FileOpener,
              val log: Log,
-              val dateCalculator: LocalDateCalculator,
              val taskRunner: TaskRunner) {

    val database: Database
@@ -56,13 +55,12 @@ class Backend(databaseName: String,
        database = databaseOpener.open(dbFile)
        database.migrateTo(LOOP_DATABASE_VERSION, fileOpener, log)
        habitsRepository = HabitRepository(database)
-        checkmarkRepository = CheckmarkRepository(database, dateCalculator)
+        checkmarkRepository = CheckmarkRepository(database)
        taskRunner.runInBackground {
            habits.putAll(habitsRepository.findAll())
            for ((key, habit) in habits) {
                val checks = checkmarkRepository.findAll(key)
-                checkmarks[habit] = CheckmarkList(habit.frequency,
-                                                  dateCalculator)
+                checkmarks[habit] = CheckmarkList(habit.frequency)
                checkmarks[habit]?.setManualCheckmarks(checks)
            }
        }
@@ -76,7 +74,7 @@ class Backend(databaseName: String,
        habit.id = id
        habit.position = habits.size
        habits[id] = habit
-        checkmarks[habit] = CheckmarkList(habit.frequency, dateCalculator)
+        checkmarks[habit] = CheckmarkList(habit.frequency)
        habitsRepository.insert(habit)
        mainScreenDataSource.requestData()
    }
--- a/core/src/commonMain/kotlin/org/isoron/uhabits/components/CalendarChart.kt
+++ b/core/src/commonMain/kotlin/org/isoron/uhabits/components/CalendarChart.kt
@@ -26,7 +26,6 @@ import kotlin.math.*
 class CalendarChart(var today: LocalDate,
                    var color: Color,
                    var theme: Theme,
-                    var dateCalculator: LocalDateCalculator,
                    var dateFormatter: LocalDateFormatter) : Component {

    var padding = 5.0
@@ -47,19 +46,19 @@ class CalendarChart(var today: LocalDate,
        canvas.setFontSize(height * 0.06)

        val nColumns = floor((width - 2 * padding) / squareSize).toInt() - 2
-        val todayWeekday = dateCalculator.dayOfWeek(today)
+        val todayWeekday = today.dayOfWeek
        val topLeftOffset = (nColumns - 1 + scrollPosition) * 7 + todayWeekday.index
-        val topLeftDate = dateCalculator.minusDays(today, topLeftOffset)
+        val topLeftDate = today.minus(topLeftOffset)

        repeat(nColumns) { column ->
            val topOffset = topLeftOffset - 7 * column
-            val topDate = dateCalculator.plusDays(topLeftDate, 7 * column)
+            val topDate = topLeftDate.plus(7 * column)
            drawColumn(canvas, column, topDate, topOffset)
        }

        canvas.setColor(theme.mediumContrastTextColor)
        repeat(7) { row ->
-            val date = dateCalculator.plusDays(topLeftDate, row)
+            val date = topLeftDate.plus(row)
            canvas.setTextAlign(TextAlign.LEFT)
            canvas.drawText(dateFormatter.shortWeekdayName(date),
                            padding + nColumns * squareSize + padding,
@@ -74,7 +73,7 @@ class CalendarChart(var today: LocalDate,
        drawHeader(canvas, column, topDate)
        repeat(7) { row ->
            val offset = topOffset - row
-            val date = dateCalculator.plusDays(topDate, row)
+            val date = topDate.plus(row)
            if (offset < 0) return
            drawSquare(canvas,
                       padding + column * squareSize,
--- a/core/src/commonMain/kotlin/org/isoron/uhabits/components/HabitListHeader.kt
+++ b/core/src/commonMain/kotlin/org/isoron/uhabits/components/HabitListHeader.kt
@@ -25,8 +25,7 @@ import org.isoron.platform.time.*
 class HabitListHeader(private val today: LocalDate,
                      private val nButtons: Int,
                      private val theme: Theme,
-                      private val fmt: LocalDateFormatter,
-                      private val calc: LocalDateCalculator) : Component {
+                      private val fmt: LocalDateFormatter) : Component {

    override fun draw(canvas: Canvas) {
        val width = canvas.getWidth()
@@ -44,7 +43,7 @@ class HabitListHeader(private val today: LocalDate,
        canvas.setFontSize(theme.smallTextSize)

        repeat(nButtons) { index ->
-            val date = calc.minusDays(today, nButtons - index - 1)
+            val date = today.minus(nButtons - index - 1)
            val name = fmt.shortWeekdayName(date).toUpperCase()
            val number = date.day.toString()

--- a/core/src/commonMain/kotlin/org/isoron/uhabits/models/CheckmarkList.kt
+++ b/core/src/commonMain/kotlin/org/isoron/uhabits/models/CheckmarkList.kt
@@ -24,8 +24,7 @@ import org.isoron.uhabits.models.Checkmark.Companion.CHECKED_AUTOMATIC
 import org.isoron.uhabits.models.Checkmark.Companion.CHECKED_MANUAL
 import org.isoron.uhabits.models.Checkmark.Companion.UNCHECKED

-class CheckmarkList(private val frequency: Frequency,
-                    private val dateCalculator: LocalDateCalculator) {
+class CheckmarkList(private val frequency: Frequency) {

    private val manualCheckmarks = mutableListOf<Checkmark>()
    private val automaticCheckmarks = mutableListOf<Checkmark>()
@@ -39,8 +38,7 @@ class CheckmarkList(private val frequency: Frequency,
        automaticCheckmarks.clear()
        manualCheckmarks.addAll(checks)
        automaticCheckmarks.addAll(computeAutomaticCheckmarks(checks,
-                                                              frequency,
-                                                              dateCalculator))
+                                                              frequency))
    }

    /**
@@ -56,7 +54,7 @@ class CheckmarkList(private val frequency: Frequency,

        val result = mutableListOf<Int>()
        val newest = automaticCheckmarks.first().date
-        val distToNewest = dateCalculator.distanceInDays(newest, date)
+        val distToNewest = newest.distanceTo(date)

        var fromIndex = 0
        val toIndex = automaticCheckmarks.size
@@ -75,13 +73,12 @@ class CheckmarkList(private val frequency: Frequency,
         * Computes the list of automatic checkmarks a list of manual ones.
         */
        fun computeAutomaticCheckmarks(checks: List<Checkmark>,
-                                       frequency: Frequency,
-                                       calc: LocalDateCalculator
+                                       frequency: Frequency
                                      ): MutableList<Checkmark> {

-            val intervals = buildIntervals(checks, frequency, calc)
-            snapIntervalsTogether(intervals, calc)
-            return buildCheckmarksFromIntervals(checks, intervals, calc)
+            val intervals = buildIntervals(checks, frequency)
+            snapIntervalsTogether(intervals)
+            return buildCheckmarksFromIntervals(checks, intervals)
        }

        /**
@@ -92,19 +89,17 @@ class CheckmarkList(private val frequency: Frequency,
         * the interval, however, still falls within the interval. The length of
         * the intervals are also not modified.
         */
-        fun snapIntervalsTogether(intervals: MutableList<Interval>,
-                                  calc: LocalDateCalculator) {
+        fun snapIntervalsTogether(intervals: MutableList<Interval>) {

            for (i in 1 until intervals.size) {
                val (begin, center, end) = intervals[i]
                val (_, _, prevEnd) = intervals[i - 1]

-                val gap = calc.distanceInDays(prevEnd, begin) - 1
-                val endMinusGap = calc.minusDays(end, gap)
-                if (gap <= 0 || endMinusGap.isOlderThan(center)) continue
-                intervals[i] = Interval(calc.minusDays(begin, gap),
+                val gap = prevEnd.distanceTo(begin) - 1
+                if (gap <= 0 || end.minus(gap).isOlderThan(center)) continue
+                intervals[i] = Interval(begin.minus(gap),
                                        center,
-                                        calc.minusDays(end, gap))
+                                        end.minus(gap))
            }
        }

@@ -119,8 +114,7 @@ class CheckmarkList(private val frequency: Frequency,
         * receive unchecked checkmarks.
         */
        fun buildCheckmarksFromIntervals(checks: List<Checkmark>,
-                                         intervals: List<Interval>,
-                                         calc: LocalDateCalculator
+                                         intervals: List<Interval>
                                        ): MutableList<Checkmark> {

            if (checks.isEmpty()) throw IllegalArgumentException()
@@ -137,25 +131,25 @@ class CheckmarkList(private val frequency: Frequency,
                if (check.date.isNewerThan(newest)) newest = check.date
            }

-            val distance = calc.distanceInDays(oldest, newest)
+            val distance = oldest.distanceTo(newest)
            val checkmarks = mutableListOf<Checkmark>()
            for (offset in 0..distance)
-                checkmarks.add(Checkmark(calc.minusDays(newest, offset),
+                checkmarks.add(Checkmark(newest.minus(offset),
                                         UNCHECKED))

            for (interval in intervals) {
-                val beginOffset = calc.distanceInDays(newest, interval.begin)
-                val endOffset = calc.distanceInDays(newest, interval.end)
+                val beginOffset = newest.distanceTo(interval.begin)
+                val endOffset = newest.distanceTo(interval.end)

                for (offset in endOffset..beginOffset) {
                    checkmarks.set(offset,
-                                   Checkmark(calc.minusDays(newest, offset),
+                                   Checkmark(newest.minus(offset),
                                             CHECKED_AUTOMATIC))
                }
            }

            for (check in checks) {
-                val offset = calc.distanceInDays(newest, check.date)
+                val offset = newest.distanceTo(check.date)
                checkmarks.set(offset, Checkmark(check.date, CHECKED_MANUAL))
            }

@@ -167,8 +161,7 @@ class CheckmarkList(private val frequency: Frequency,
         * checkmarks.
         */
        fun buildIntervals(checks: List<Checkmark>,
-                           frequency: Frequency,
-                           calc: LocalDateCalculator): MutableList<Interval> {
+                           frequency: Frequency): MutableList<Interval> {

            val num = frequency.numerator
            val den = frequency.denominator
@@ -178,10 +171,9 @@ class CheckmarkList(private val frequency: Frequency,
                val first = checks[i]
                val last = checks[i + num - 1]

-                val distance = calc.distanceInDays(first.date, last.date)
-                if (distance >= den) continue
+                if (first.date.distanceTo(last.date) >= den) continue

-                val end = calc.plusDays(first.date, den - 1)
+                val end = first.date.plus(den - 1)
                intervals.add(Interval(first.date, last.date, end))
            }

--- a/core/src/commonMain/kotlin/org/isoron/uhabits/models/CheckmarkRepository.kt
+++ b/core/src/commonMain/kotlin/org/isoron/uhabits/models/CheckmarkRepository.kt
@@ -22,8 +22,7 @@ package org.isoron.uhabits.models
 import org.isoron.platform.io.*
 import org.isoron.platform.time.*

-class CheckmarkRepository(db: Database,
-                          val dateCalculator: LocalDateCalculator) {
+class CheckmarkRepository(db: Database) {

    private val findStatement = db.prepareStatement("select timestamp, value from Repetitions where habit = ? order by timestamp desc")
    private val insertStatement = db.prepareStatement("insert into Repetitions(habit, timestamp, value) values (?, ?, ?)")
@@ -33,9 +32,8 @@ class CheckmarkRepository(db: Database,
        findStatement.bindInt(0, habitId)
        val result = mutableListOf<Checkmark>()
        while (findStatement.step() == StepResult.ROW) {
-            val timestamp = Timestamp(findStatement.getLong(0))
+            val date = Timestamp(findStatement.getLong(0)).localDate
            val value = findStatement.getInt(1)
-            val date = dateCalculator.fromTimestamp(timestamp)
            result.add(Checkmark(date, value))
        }
        findStatement.reset()
@@ -43,18 +41,18 @@ class CheckmarkRepository(db: Database,
    }

    fun insert(habitId: Int, checkmark: Checkmark) {
-        val timestamp = dateCalculator.toTimestamp(checkmark.date)
+        val timestamp = checkmark.date.timestamp
        insertStatement.bindInt(0, habitId)
-        insertStatement.bindLong(1, timestamp.unixTimeInMillis)
+        insertStatement.bindLong(1, timestamp.millisSince1970)
        insertStatement.bindInt(2, checkmark.value)
        insertStatement.step()
        insertStatement.reset()
    }

    fun delete(habitId: Int, date: LocalDate) {
-        val timestamp = dateCalculator.toTimestamp(date)
+        val timestamp = date.timestamp
        deleteStatement.bindInt(0, habitId)
-        deleteStatement.bindLong(1, timestamp.unixTimeInMillis)
+        deleteStatement.bindLong(1, timestamp.millisSince1970)
        deleteStatement.step()
        deleteStatement.reset()
    }
--- a/core/src/jvmMain/kotlin/org/isoron/platform/time/JavaDates.kt
+++ b/core/src/jvmMain/kotlin/org/isoron/platform/time/JavaDates.kt
@@ -19,19 +19,20 @@

 package org.isoron.platform.time

-import java.lang.Math.*
 import java.util.*
 import java.util.Calendar.*

+
 fun LocalDate.toGregorianCalendar(): GregorianCalendar {
-    val cal = GregorianCalendar(TimeZone.getTimeZone("GMT"))
-    cal.set(Calendar.HOUR_OF_DAY, 0)
-    cal.set(Calendar.MINUTE, 0)
-    cal.set(Calendar.SECOND, 0)
-    cal.set(Calendar.MILLISECOND, 0)
-    cal.set(Calendar.YEAR, this.year)
-    cal.set(Calendar.MONTH, this.month - 1)
-    cal.set(Calendar.DAY_OF_MONTH, this.day)
+    val cal = GregorianCalendar()
+    cal.timeZone = TimeZone.getTimeZone("GMT")
+    cal.set(MILLISECOND, 0)
+    cal.set(SECOND, 0)
+    cal.set(MINUTE, 0)
+    cal.set(HOUR_OF_DAY, 0)
+    cal.set(YEAR, this.year)
+    cal.set(MONTH, this.month - 1)
+    cal.set(DAY_OF_MONTH, this.day)
    return cal
 }

@@ -56,35 +57,3 @@ class JavaLocalDateFormatter(private val locale: Locale) : LocalDateFormatter {
        return cal.getDisplayName(DAY_OF_WEEK, SHORT, locale);
    }
 }
-
-class JavaLocalDateCalculator : LocalDateCalculator {
-    override fun toTimestamp(date: LocalDate): Timestamp {
-        val cal = date.toGregorianCalendar()
-        return Timestamp(cal.timeInMillis)
-    }
-
-    override fun fromTimestamp(timestamp: Timestamp): LocalDate {
-        val cal = GregorianCalendar(TimeZone.getTimeZone("GMT"))
-        cal.timeInMillis = timestamp.unixTimeInMillis
-        return cal.toLocalDate()
-    }
-
-    override fun dayOfWeek(date: LocalDate): DayOfWeek {
-        val cal = date.toGregorianCalendar()
-        return when (cal.get(DAY_OF_WEEK)) {
-            Calendar.SATURDAY -> DayOfWeek.SATURDAY
-            Calendar.SUNDAY -> DayOfWeek.SUNDAY
-            Calendar.MONDAY -> DayOfWeek.MONDAY
-            Calendar.TUESDAY -> DayOfWeek.TUESDAY
-            Calendar.WEDNESDAY -> DayOfWeek.WEDNESDAY
-            Calendar.THURSDAY -> DayOfWeek.THURSDAY
-            else -> DayOfWeek.FRIDAY
-        }
-    }
-
-    override fun plusDays(date: LocalDate, days: Int): LocalDate {
-        val cal = date.toGregorianCalendar()
-        cal.add(Calendar.DAY_OF_MONTH, days)
-        return cal.toLocalDate()
-    }
-}
--- a/core/src/jvmTest/kotlin/org/isoron/platform/JavaDatesTest.kt
+++ b/core/src/jvmTest/kotlin/org/isoron/platform/JavaDatesTest.kt
@@ -23,10 +23,10 @@ import junit.framework.TestCase.*
 import org.isoron.platform.time.*
 import org.junit.*
 import java.util.*
+import java.util.Calendar.*


 class JavaDatesTest {
-    private val calc = JavaLocalDateCalculator()
    private val d1 = LocalDate(2019, 3, 25)
    private val d2 = LocalDate(2019, 4, 4)
    private val d3 = LocalDate(2019, 5, 12)
@@ -34,46 +34,46 @@ class JavaDatesTest {
    @Test
    fun plusMinusDays() {
        val today = LocalDate(2019, 3, 25)
-        assertEquals(calc.minusDays(today, 28), LocalDate(2019, 2, 25))
-        assertEquals(calc.plusDays(today, 7), LocalDate(2019, 4, 1))
-        assertEquals(calc.plusDays(today, 42), LocalDate(2019, 5, 6))
+        assertEquals(today.minus(28), LocalDate(2019, 2, 25))
+        assertEquals(today.plus(7), LocalDate(2019, 4, 1))
+        assertEquals(today.plus(42), LocalDate(2019, 5, 6))
    }

    @Test
    fun shortMonthName() {
        var fmt = JavaLocalDateFormatter(Locale.US)
-        assertEquals(fmt.shortWeekdayName(d1), "Mon")
-        assertEquals(fmt.shortWeekdayName(d2), "Thu")
-        assertEquals(fmt.shortWeekdayName(d3), "Sun")
-        assertEquals(fmt.shortMonthName(d1), "Mar")
-        assertEquals(fmt.shortMonthName(d2), "Apr")
-        assertEquals(fmt.shortMonthName(d3), "May")
+        assertEquals("Mon", fmt.shortWeekdayName(d1))
+        assertEquals("Thu", fmt.shortWeekdayName(d2))
+        assertEquals("Sun", fmt.shortWeekdayName(d3))
+        assertEquals("Mar", fmt.shortMonthName(d1))
+        assertEquals("Apr", fmt.shortMonthName(d2))
+        assertEquals("May", fmt.shortMonthName(d3))

        fmt = JavaLocalDateFormatter(Locale.JAPAN)
-        assertEquals(fmt.shortWeekdayName(d1), "月")
-        assertEquals(fmt.shortWeekdayName(d2), "木")
-        assertEquals(fmt.shortWeekdayName(d3), "日")
-        assertEquals(fmt.shortMonthName(d1), "3月")
-        assertEquals(fmt.shortMonthName(d2), "4月")
-        assertEquals(fmt.shortMonthName(d3), "5月")
+        assertEquals("月", fmt.shortWeekdayName(d1))
+        assertEquals("木", fmt.shortWeekdayName(d2))
+        assertEquals("日", fmt.shortWeekdayName(d3))
+        assertEquals("3月", fmt.shortMonthName(d1))
+        assertEquals("4月", fmt.shortMonthName(d2))
+        assertEquals("5月", fmt.shortMonthName(d3))
    }

    @Test
    fun weekDay() {
-        assertEquals(DayOfWeek.SUNDAY, calc.dayOfWeek(LocalDate(2015, 1, 25)))
-        assertEquals(DayOfWeek.MONDAY, calc.dayOfWeek(LocalDate(2017, 7, 3)))
+        assertEquals(DayOfWeek.SUNDAY, LocalDate(2015, 1, 25).dayOfWeek)
+        assertEquals(DayOfWeek.MONDAY, LocalDate(2017, 7, 3).dayOfWeek)
    }

    @Test
    fun timestamps() {
        val timestamps = listOf(Timestamp(1555977600000),
                                Timestamp(968716800000),
-                                Timestamp(0))
+                                Timestamp(946684800000))
        val dates = listOf(LocalDate(2019, 4, 23),
                           LocalDate(2000, 9, 12),
-                           LocalDate(1970, 1, 1))
-        assertEquals(timestamps, dates.map { d -> calc.toTimestamp(d) })
-        assertEquals(dates, timestamps.map { t -> calc.fromTimestamp(t) })
+                           LocalDate(2000, 1, 1))
+        assertEquals(timestamps, dates.map { d -> d.timestamp })
+        assertEquals(dates, timestamps.map { t -> t.localDate })
    }

    @Test
@@ -96,10 +96,47 @@ class JavaDatesTest {
        val d2 = LocalDate(2019, 5, 30)
        val d3 = LocalDate(2019, 6, 5)

-        assertEquals(0, calc.distanceInDays(d1, d1))
-        assertEquals(20, calc.distanceInDays(d1, d2))
-        assertEquals(20, calc.distanceInDays(d2, d1))
-        assertEquals(26, calc.distanceInDays(d1, d3))
-        assertEquals(6, calc.distanceInDays(d2, d3))
+        assertEquals(0, d1.distanceTo(d1))
+        assertEquals(20, d1.distanceTo(d2))
+        assertEquals(20, d2.distanceTo(d1))
+        assertEquals(26, d1.distanceTo(d3))
+        assertEquals(6, d2.distanceTo(d3))
+    }
+
+    @Test
+    fun gregorianCalendarConversion() {
+        fun check(cal: GregorianCalendar, daysSince2000: Int) {
+            val year = cal.get(YEAR)
+            val month = cal.get(MONTH) + 1
+            val day = cal.get(DAY_OF_MONTH)
+            val weekday = cal.get(DAY_OF_WEEK)
+            val date = LocalDate(year, month, day)
+            val millisSince1970 = cal.timeInMillis
+            val msg = "date=$year-$month-$day offset=$daysSince2000"
+
+            assertEquals(msg, daysSince2000, date.daysSince2000)
+            assertEquals(msg, year, date.year)
+            assertEquals(msg, month, date.month)
+            assertEquals(msg, day, date.day)
+            assertEquals(msg, weekday, date.dayOfWeek.index + 1)
+            assertEquals(msg, millisSince1970, date.timestamp.millisSince1970)
+            assertEquals(msg, date, date.timestamp.localDate)
+        }
+
+        val cal = GregorianCalendar()
+        cal.timeZone = TimeZone.getTimeZone("GMT")
+        cal.set(MILLISECOND, 0)
+        cal.set(SECOND, 0)
+        cal.set(MINUTE, 0)
+        cal.set(HOUR_OF_DAY, 0)
+        cal.set(DAY_OF_MONTH, 1)
+        cal.set(MONTH, 0)
+        cal.set(YEAR, 2000)
+
+        // Check all dates from year 2000 until 2400
+        for(offset in 0..146097) {
+            check(cal, offset)
+            cal.add(DAY_OF_YEAR, 1)
+        }
    }
 }
--- a/core/src/jvmTest/kotlin/org/isoron/uhabits/Base.kt
+++ b/core/src/jvmTest/kotlin/org/isoron/uhabits/Base.kt
@@ -38,8 +38,6 @@ open class BaseTest {

    val databaseOpener = JavaDatabaseOpener(log)

-    val dateCalculator = JavaLocalDateCalculator()
-
    val taskRunner = SequentialTaskRunner()

    lateinit var db: Database
--- a/core/src/jvmTest/kotlin/org/isoron/uhabits/backend/BackendTest.kt
+++ b/core/src/jvmTest/kotlin/org/isoron/uhabits/backend/BackendTest.kt
@@ -40,7 +40,6 @@ class BackendTest : BaseTest() {
                          databaseOpener,
                          fileOpener,
                          log,
-                          dateCalculator,
                          taskRunner)
    }

--- a/core/src/jvmTest/kotlin/org/isoron/uhabits/components/CalendarChartTest.kt
+++ b/core/src/jvmTest/kotlin/org/isoron/uhabits/components/CalendarChartTest.kt
@@ -32,7 +32,6 @@ class CalendarChartTest : BaseViewTest() {
        val component = CalendarChart(LocalDate(2015, 1, 25),
                                      theme.color(4),
                                      theme,
-                                      JavaLocalDateCalculator(),
                                      JavaLocalDateFormatter(Locale.US))
        component.series = listOf(1.0, // today
                                  0.2, 0.5, 0.7, 0.0, 0.3, 0.4, 0.6,
--- a/core/src/jvmTest/kotlin/org/isoron/uhabits/components/HabitListHeaderTest.kt
+++ b/core/src/jvmTest/kotlin/org/isoron/uhabits/components/HabitListHeaderTest.kt
@@ -30,8 +30,7 @@ class HabitListHeaderTest : BaseViewTest() {
        val header = HabitListHeader(LocalDate(2019, 3, 25),
                                     5,
                                     theme,
-                                     JavaLocalDateFormatter(Locale.US),
-                                     JavaLocalDateCalculator())
+                                     JavaLocalDateFormatter(Locale.US))
        assertRenders(1200, 96,
                      "components/HabitListHeader/light.png",
                      header)
--- a/core/src/jvmTest/kotlin/org/isoron/uhabits/models/CheckmarkListTest.kt
+++ b/core/src/jvmTest/kotlin/org/isoron/uhabits/models/CheckmarkListTest.kt
@@ -32,7 +32,7 @@ class CheckmarkListTest : BaseTest() {
    private val today = LocalDate(2019, 1, 30)

    private fun day(offset: Int): LocalDate {
-        return dateCalculator.minusDays(today, offset)
+        return today.minus(offset)
    }

    @Test
@@ -45,8 +45,7 @@ class CheckmarkListTest : BaseTest() {
                CheckmarkList.Interval(day(18), day(18), day(12)),
                CheckmarkList.Interval(day(8), day(8), day(2)))
        val actual = CheckmarkList.buildIntervals(checks,
-                                                  Frequency.WEEKLY,
-                                                  dateCalculator)
+                                                  Frequency.WEEKLY)
        assertEquals(expected, actual)
    }

@@ -60,8 +59,7 @@ class CheckmarkListTest : BaseTest() {
                CheckmarkList.Interval(day(18), day(18), day(18)),
                CheckmarkList.Interval(day(8), day(8), day(8)))
        val actual = CheckmarkList.buildIntervals(checks,
-                                                  Frequency.DAILY,
-                                                  dateCalculator)
+                                                  Frequency.DAILY)
        assertEquals(expected, actual)
    }

@@ -77,8 +75,7 @@ class CheckmarkListTest : BaseTest() {
                CheckmarkList.Interval(day(22), day(18), day(16)),
                CheckmarkList.Interval(day(18), day(15), day(12)))
        val actual = CheckmarkList.buildIntervals(checks,
-                                                  Frequency.TWO_TIMES_PER_WEEK,
-                                                  dateCalculator)
+                                                  Frequency.TWO_TIMES_PER_WEEK)
        assertEquals(expected, actual)
    }

@@ -94,7 +91,7 @@ class CheckmarkListTest : BaseTest() {
                CheckmarkList.Interval(day(25), day(25), day(19)),
                CheckmarkList.Interval(day(18), day(16), day(12)),
                CheckmarkList.Interval(day(11), day(8), day(5)))
-        CheckmarkList.snapIntervalsTogether(original, dateCalculator)
+        CheckmarkList.snapIntervalsTogether(original)
        assertEquals(expected, original)
    }

@@ -118,8 +115,7 @@ class CheckmarkListTest : BaseTest() {
                              Checkmark(day(9), CHECKED_AUTOMATIC),
                              Checkmark(day(10), CHECKED_MANUAL))
        val actual = CheckmarkList.buildCheckmarksFromIntervals(checks,
-                                                                intervals,
-                                                                dateCalculator)
+                                                                intervals)
        assertEquals(expected, actual)
    }

@@ -134,8 +130,7 @@ class CheckmarkListTest : BaseTest() {
                              Checkmark(day(4), CHECKED_AUTOMATIC),
                              Checkmark(day(5), CHECKED_AUTOMATIC))
        val actual = CheckmarkList.buildCheckmarksFromIntervals(reps,
-                                                                intervals,
-                                                                dateCalculator)
+                                                                intervals)
        assertEquals(expected, actual)
    }

@@ -158,14 +153,13 @@ class CheckmarkListTest : BaseTest() {
                              Checkmark(day(9), CHECKED_AUTOMATIC),
                              Checkmark(day(10), CHECKED_MANUAL))
        val actual = CheckmarkList.computeAutomaticCheckmarks(checks,
-                                                              Frequency(1, 3),
-                                                              dateCalculator)
+                                                              Frequency(1, 3))
        assertEquals(expected, actual)
    }

    @Test
    fun testGetValuesUntil() {
-        val list = CheckmarkList(Frequency(1, 2), dateCalculator)
+        val list = CheckmarkList(Frequency(1, 2))
        list.setManualCheckmarks(listOf(Checkmark(day(4), CHECKED_MANUAL),
                                        Checkmark(day(7), CHECKED_MANUAL)))
        val expected = listOf(UNCHECKED,
@@ -188,7 +182,7 @@ class CheckmarkListTest : BaseTest() {

    @Test
    fun testGetValuesUntil2() {
-        val list = CheckmarkList(Frequency(1, 2), dateCalculator)
+        val list = CheckmarkList(Frequency(1, 2))
        val expected = listOf<Int>()
        assertEquals(expected, list.getValuesUntil(day(0)))
    }
--- a/core/src/jvmTest/kotlin/org/isoron/uhabits/models/CheckmarkRepositoryTest.kt
+++ b/core/src/jvmTest/kotlin/org/isoron/uhabits/models/CheckmarkRepositoryTest.kt
@@ -39,7 +39,7 @@ class CheckmarkRepositoryTest : BaseTest() {
                                 Checkmark(LocalDate(2019, 1, 25), 450),
                                 Checkmark(LocalDate(2019, 1, 20), 1000))

-        val repository = CheckmarkRepository(db, JavaLocalDateCalculator())
+        val repository = CheckmarkRepository(db)

        for (c in checkmarksA) repository.insert(habitA, c)
        for (c in checkmarksB) repository.insert(habitB, c)