Experiment with extensible ChronoUnit instead of fixed enum of CalendarUnits

Author: ilya-g

core/commonMain/src/CalendarPeriod.kt

@@ -89,3 +89,38 @@ enum class CalendarUnit {
     SECOND,
     NANOSECOND
 }
+
+
+enum class TimeComponent {
+    MONTH,
+    DAY,
+    NANOSECOND
+}
+
+class ChronoUnit(val scale: Long, val component: TimeComponent) {
+    init {
+        require(scale > 0) { "Unit scale must be positive, but was $scale" }
+    }
+    constructor(number: Long, unit: ChronoUnit) : this(number * unit.scale, unit.component)
+    // it seems possible to provide 'times' operation
+    companion object {
+        val NANOSECOND = ChronoUnit(1, TimeComponent.NANOSECOND)
+        val MICROSECOND = ChronoUnit(1000, NANOSECOND)
+        val MILLISECOND = ChronoUnit(1000, MICROSECOND)
+        val SECOND = ChronoUnit(1000, MILLISECOND)
+        val MINUTE = ChronoUnit(60, SECOND)
+        val HOUR = ChronoUnit(60, MINUTE)
+        val DAY = ChronoUnit(1, TimeComponent.DAY)
+        val WEEK = ChronoUnit(7, TimeComponent.DAY)
+        val MONTH = ChronoUnit(1, TimeComponent.MONTH)
+        val QUARTER = ChronoUnit(3, MONTH)
+        val YEAR = ChronoUnit(12, MONTH)
+        val CENTURY = ChronoUnit(100, YEAR)
+    }
+}
+
+internal fun TimeComponent.toCalendarUnit(): CalendarUnit = when(this) {
+    TimeComponent.MONTH -> CalendarUnit.MONTH
+    TimeComponent.DAY -> CalendarUnit.DAY
+    TimeComponent.NANOSECOND -> CalendarUnit.NANOSECOND
+}

core/commonMain/src/Instant.kt

@@ -46,3 +46,15 @@ public expect fun Instant.yearsUntil(other: Instant, zone: TimeZone): Int
 
 public fun Instant.minus(other: Instant, zone: TimeZone): CalendarPeriod = other.periodUntil(this, zone)
 public fun Instant.minus(other: Instant, unit: CalendarUnit, zone: TimeZone): Long = other.until(this, unit, zone)
+
+
+
+public fun Instant.plus(unit: ChronoUnit, zone: TimeZone): Instant =
+        plus(unit.scale, unit.component.toCalendarUnit(), zone)
+public fun Instant.plus(value: Int, unit: ChronoUnit, zone: TimeZone): Instant =
+        plus(value * unit.scale, unit.component.toCalendarUnit(), zone)
+public fun Instant.plus(value: Long, unit: ChronoUnit, zone: TimeZone): Instant =
+        plus(value * unit.scale, unit.component.toCalendarUnit(), zone)
+
+public fun Instant.until(other: Instant, unit: ChronoUnit, zone: TimeZone): Long =
+        until(other, unit.component.toCalendarUnit(), zone) / unit.scale

core/commonMain/src/LocalDate.kt

@@ -41,4 +41,18 @@ public fun LocalDate.until(other: LocalDate, unit: CalendarUnit): Int = when(uni
     CalendarUnit.DAY -> daysUntil(other)
     CalendarUnit.HOUR, CalendarUnit.MINUTE, CalendarUnit.SECOND, CalendarUnit.NANOSECOND ->
         throw UnsupportedOperationException("Only date based units can be used to express difference between LocalDate values.")
-}
+}
+
+public fun LocalDate.plus(unit: ChronoUnit): LocalDate =
+        plus(unit.scale, unit.component.toCalendarUnit())
+public fun LocalDate.plus(value: Int, unit: ChronoUnit): LocalDate =
+        plus(value * unit.scale, unit.component.toCalendarUnit())
+public fun LocalDate.plus(value: Long, unit: ChronoUnit): LocalDate =
+        plus(value * unit.scale, unit.component.toCalendarUnit())
+
+public fun LocalDate.until(other: LocalDate, unit: ChronoUnit): Int = when(unit.component) {
+    TimeComponent.MONTH -> (monthsUntil(other) / unit.scale).toInt()
+    TimeComponent.DAY -> (daysUntil(other) / unit.scale).toInt()
+    TimeComponent.NANOSECOND ->
+        throw UnsupportedOperationException("Only date based units can be used to express difference between LocalDate values.")
+}

core/commonTest/src/InstantTest.kt

@@ -93,19 +93,28 @@ class InstantTest {
         assertEquals(24, instant1.until(instant2, CalendarUnit.HOUR, zone))
         assertEquals(24, instant2.minus(instant1, CalendarUnit.HOUR, zone))
 
-        val instant3 = instant1.plus(1, CalendarUnit.DAY, zone)
+        val instant3 = instant1.plus(ChronoUnit.DAY, zone)
         checkComponents(instant3.toLocalDateTime(zone), 2019, 10, 28, 2, 59)
         assertEquals(25.hours, instant3 - instant1)
         assertEquals(1, instant1.until(instant3, CalendarUnit.DAY, zone))
         assertEquals(1, instant1.daysUntil(instant3, zone))
         assertEquals(1, instant3.minus(instant1, CalendarUnit.DAY, zone))
 
+        val instant4 = instant1.plus(14, ChronoUnit.MONTH, zone)
+        checkComponents(instant4.toLocalDateTime(zone), 2020, 12, 27, 2, 59)
+        assertEquals(1, instant1.until(instant4, ChronoUnit.YEAR, zone))
+        assertEquals(4, instant1.until(instant4, ChronoUnit.QUARTER, zone))
+        assertEquals(14, instant1.until(instant4, ChronoUnit.MONTH, zone))
+        assertEquals(61, instant1.until(instant4, ChronoUnit.WEEK, zone))
+        assertEquals(366 + 31 + 30, instant1.until(instant4, ChronoUnit.DAY, zone))
+        assertEquals((366 + 31 + 30) * 24 + 1, instant1.until(instant4, ChronoUnit.HOUR, zone))
+
         val period = CalendarPeriod(days = 1, hours = 1)
-        val instant4 = instant1.plus(period, zone)
-        checkComponents(instant4.toLocalDateTime(zone), 2019, 10, 28, 3, 59)
-        assertEquals(period, instant1.periodUntil(instant4, zone))
-        assertEquals(period, instant4.minus(instant1, zone))
-        assertEquals(26.hours, instant4.minus(instant1))
+        val instant5 = instant1.plus(period, zone)
+        checkComponents(instant5.toLocalDateTime(zone), 2019, 10, 28, 3, 59)
+        assertEquals(period, instant1.periodUntil(instant5, zone))
+        assertEquals(period, instant5.minus(instant1, zone))
+        assertEquals(26.hours, instant5.minus(instant1))
     }
 
     @OptIn(ExperimentalTime::class)
@@ -218,7 +227,7 @@ class InstantTest {
     /* Based on the ThreeTenBp project.
      * Copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
      */
-    @ExperimentalTime
+//    @ExperimentalTime
     @Test
     fun strings() {
         assertEquals("0000-01-02T00:00:00Z", LocalDateTime(0, 1, 2, 0, 0, 0, 0).toInstant(TimeZone.UTC).toString())

core/commonTest/src/LocalDateTest.kt

@@ -54,14 +54,15 @@ class LocalDateTest {
     @Test
     fun addComponents() {
         val startDate = LocalDate(2016, 2, 29)
-        checkComponents(startDate.plus(1, CalendarUnit.DAY), 2016, 3, 1)
-        checkComponents(startDate.plus(1, CalendarUnit.YEAR), 2017, 2, 28)
+        checkComponents(startDate.plus(1, ChronoUnit.DAY), 2016, 3, 1)
+        checkComponents(startDate.plus(ChronoUnit.YEAR), 2017, 2, 28)
         checkComponents(startDate + CalendarPeriod(years = 4), 2020, 2, 29)
 
         checkComponents(LocalDate.parse("2016-01-31") + CalendarPeriod(months = 1), 2016, 2, 29)
 
         assertFailsWith<UnsupportedOperationException> { startDate + CalendarPeriod(hours = 7) }
         assertFailsWith<UnsupportedOperationException> { startDate.plus(7, CalendarUnit.HOUR) }
+        assertFailsWith<UnsupportedOperationException> { startDate.plus(7, ChronoUnit.MINUTE) }
     }
 
     @Test