Native (Apple): Provide integrations with the native datetime (#10)

For now, these are provided as a separate artifact. This is cumbersome
for the end user, but currently, since there is no ability yet to specify
common native code, we would have to duplicate much between every
available platform just to provide some special behavior on
Darwin-based devices. There is a clear migration path once common
native code becomes possible, so the problem is not significant.

Author: dkhalanskyjb

build.gradle.kts

@@ -17,13 +17,18 @@ project(":kotlinx-datetime") {
 //    pluginManager.apply("maven-publish")
 }
 
+project(":kotlinx-datetime-darwin") {
+    pluginManager.apply("kotlin-multiplatform")
+}
+
 infra {
     teamcity {
         bintrayUser = "%env.BINTRAY_USER%"
         bintrayToken = "%env.BINTRAY_API_KEY%"
     }
     publishing {
         include(":kotlinx-datetime")
+        include(":kotlinx-datetime-darwin")
 
         bintray {
             organization = "kotlin"

core/build.gradle.kts

@@ -25,11 +25,6 @@ val JDK_8: String by project
 //    }
 //}
 
-tasks.withType<org.jetbrains.kotlin.gradle.tasks.CInteropProcess> {
-    // dependsOn(":date-cpp-c-wrapper:assembleRelease")
-    // dependsOn(":date-cpp-library:assembleRelease")
-}
-
 kotlin {
     infra {
         target("macosX64")
@@ -38,6 +33,11 @@ kotlin {
         target("iosArm32")
         target("linuxX64")
         target("mingwX64")
+        target("watchosArm32")
+        target("watchosArm64")
+        target("watchosX86")
+        target("tvosArm64")
+        target("tvosX64")
     }
 
     jvm {

darwin-integration/build.gradle.kts

@@ -0,0 +1,32 @@
+plugins {
+    id("kotlin-multiplatform")
+}
+
+kotlin {
+    infra {
+        target("macosX64")
+        target("iosX64")
+        target("iosArm64")
+        target("iosArm32")
+        target("watchosArm32")
+        target("watchosArm64")
+        target("watchosX86")
+        target("tvosArm64")
+        target("tvosX64")
+    }
+
+    sourceSets.all {
+        kotlin.setSrcDirs(listOf("$name/src"))
+    }
+
+    sourceSets {
+        val nativeMain by getting {
+            dependencies {
+                implementation(project(":kotlinx-datetime"))
+            }
+        }
+        val nativeTest by getting {
+        }
+    }
+
+}

darwin-integration/nativeMain/src/Converters.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2019-2020 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+
+package kotlinx.datetime
+import kotlinx.cinterop.*
+import platform.Foundation.*
+
+/**
+ * Converts the [Instant] to an instance of [NSDate].
+ *
+ * The conversion is lossy: Darwin uses millisecond precision to represent dates, and [Instant] allows for nanosecond
+ * resolution.
+ */
+public fun Instant.toNSDate(): NSDate {
+    val secs = epochSeconds * 1.0 + nanosecondsOfSecond / 1.0e9
+    if (secs < NSDate.distantPast.timeIntervalSince1970 || secs > NSDate.distantFuture.timeIntervalSince1970) {
+        throw DateTimeException("Boundaries of NSDate exceeded")
+    }
+    return NSDate.dateWithTimeIntervalSince1970(secs)
+}
+
+/**
+ * Converts the [NSDate] to the corresponding [Instant].
+ *
+ * Even though Darwin only uses millisecond precision, it is possible that [date] uses larger resolution, storing
+ * microseconds or even nanoseconds. In this case, the sub-millisecond parts of [date] are rounded to the nearest
+ * millisecond, given that they are likely to be conversion artifacts.
+ */
+public fun NSDate.toKotlinInstant(): Instant {
+    val secs = timeIntervalSince1970()
+    val millis = secs * 1000 + if (secs > 0) 0.5 else -0.5
+    return Instant.fromEpochMilliseconds(millis.toLong())
+}
+
+/**
+ * Converts the [TimeZone] to [NSTimeZone].
+ *
+ * If the time zone is represented as a fixed number of seconds from UTC+0 (for example, if it is the result of a call
+ * to [TimeZone.offset]) and the offset is not given in even minutes but also includes seconds, this method throws
+ * [DateTimeException] to denote that lossy conversion would happen, as Darwin internally rounds the offsets to the
+ * nearest minute.
+ */
+public fun TimeZone.toNSTimeZone(): NSTimeZone = if (this is ZoneOffset) {
+    if (totalSeconds % 60 == 0) {
+        NSTimeZone.timeZoneForSecondsFromGMT(totalSeconds.convert())
+    } else {
+        throw DateTimeException("Lossy conversion: Darwin uses minute precision for fixed-offset time zones")
+    }
+} else {
+    NSTimeZone.timeZoneWithName(id) ?: NSTimeZone.timeZoneWithAbbreviation(id)!!
+}
+
+/**
+ * Converts the [NSTimeZone] to the corresponding [TimeZone].
+ */
+public fun NSTimeZone.toKotlinTimeZone(): TimeZone = TimeZone.of(name)
+
+/**
+ * Converts the given [LocalDate] to [NSDateComponents].
+ *
+ * Of all the fields, only the bare minimum required for uniquely identifying the date are set.
+ */
+public fun LocalDate.toNSDateComponents(): NSDateComponents {
+    val components = NSDateComponents()
+    components.year = year.convert()
+    components.month = monthNumber.convert()
+    components.day = dayOfMonth.convert()
+    return components
+}
+
+/**
+ * Converts the given [LocalDate] to [NSDateComponents].
+ *
+ * Of all the fields, only the bare minimum required for uniquely identifying the date and time are set.
+ */
+public fun LocalDateTime.toNSDateComponents(): NSDateComponents {
+    val components = date.toNSDateComponents()
+    components.hour = hour.convert()
+    components.minute = minute.convert()
+    components.second = second.convert()
+    components.nanosecond = nanosecond.convert()
+    return components
+}

darwin-integration/nativeTest/src/ConvertersTest.kt

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2019-2020 JetBrains s.r.o.
+ * Use of this source code is governed by the Apache 2.0 License that can be found in the LICENSE.txt file.
+ */
+package kotlinx.datetime
+import kotlinx.cinterop.*
+import platform.Foundation.*
+import kotlin.math.*
+import kotlin.random.*
+import kotlin.test.*
+
+class ConvertersTest {
+
+    private val dateFormatter = NSDateFormatter()
+    private val locale = NSLocale.localeWithLocaleIdentifier("en_US_POSIX")
+    private val gregorian = NSCalendar.calendarWithIdentifier(NSCalendarIdentifierGregorian)!!
+    private val utc = NSTimeZone.timeZoneForSecondsFromGMT(0)
+
+    init {
+        dateFormatter.locale = locale
+        dateFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSZZZZZ"
+        dateFormatter.calendar = gregorian
+        dateFormatter.timeZone = utc
+    }
+
+    @Test
+    fun testToFromNSDate() {
+        // The first day on the Gregorian calendar. The day before it is 1582-10-04 in the Julian calendar.
+        val gregorianCalendarStart = Instant.parse("1582-10-15T00:00:00Z").toEpochMilliseconds()
+        val minBoundMillis = (NSDate.distantPast.timeIntervalSince1970 * 1000 + 0.5).toLong()
+        val maxBoundMillis = (NSDate.distantFuture.timeIntervalSince1970 * 1000 - 0.5).toLong()
+        repeat (1000) {
+            val millis = Random.nextLong(minBoundMillis, maxBoundMillis)
+            val instant = Instant.fromEpochMilliseconds(millis)
+            val date = instant.toNSDate()
+            // Darwin's date printer dynamically adjusts to switching between calendars, while our Instant does not.
+            if (millis >= gregorianCalendarStart) {
+                assertEquals(instant, Instant.parse(dateFormatter.stringFromDate(date)))
+            }
+            assertEquals(instant, date.toKotlinInstant())
+        }
+    }
+
+    @Test
+    fun availableZoneIdsToNSTimeZone() {
+        for (id in TimeZone.availableZoneIds) {
+            val normalizedId = (NSTimeZone.abbreviationDictionary[id] ?: id) as String
+            val timeZone = TimeZone.of(normalizedId)
+            if (timeZone is ZoneOffset) {
+                continue
+            }
+            val nsTimeZone = timeZone.toNSTimeZone()
+            assertEquals(normalizedId, nsTimeZone.name)
+            assertEquals(timeZone, nsTimeZone.toKotlinTimeZone())
+        }
+    }
+
+    // from threetenbp's tests for time zones
+    @Test
+    fun zoneOffsetToNSTimeZone() {
+        for (i in -18 * 60..18 * 60) {
+            val hours = i / 60
+            val minutes = i % 60
+            val str = (if (i < 0) "-" else "+") +
+                (abs(hours) + 100).toString().substring(1) + ":" +
+                (abs(minutes) + 100).toString().substring(1) + ":" +
+                "00"
+            val test = TimeZone.of(str)
+            zoneOffsetCheck(test, hours, minutes)
+        }
+    }
+
+    @Test
+    fun localDateToNSDateComponentsTest() {
+        val date = LocalDate.parse("2019-02-04")
+        val components = date.toNSDateComponents()
+        components.timeZone = utc
+        val nsDate = gregorian.dateFromComponents(components)!!
+        val formatter = NSDateFormatter()
+        formatter.dateFormat = "yyyy-MM-dd"
+        assertEquals("2019-02-04", formatter.stringFromDate(nsDate))
+    }
+
+    @Test
+    fun localDateTimeToNSDateComponentsTest() {
+        val str = "2019-02-04T23:59:30.543"
+        val dateTime = LocalDateTime.parse(str)
+        val components = dateTime.toNSDateComponents()
+        components.timeZone = utc
+        val nsDate = gregorian.dateFromComponents(components)!!
+        assertEquals(str + "Z", dateFormatter.stringFromDate(nsDate))
+    }
+
+    private fun zoneOffsetCheck(timeZone: TimeZone, hours: Int, minutes: Int) {
+        val nsTimeZone = timeZone.toNSTimeZone()
+        assertEquals(hours * 3600 + minutes * 60, nsTimeZone.secondsFromGMT.convert())
+        assertEquals(timeZone, nsTimeZone.toKotlinTimeZone())
+    }
+}

settings.gradle

@@ -13,3 +13,6 @@ rootProject.name = 'Kotlin-DateTime-library'
 
 include ':core'
 project(":core").name='kotlinx-datetime'
+
+include ':darwin-integration'
+project(":darwin-integration").name='kotlinx-datetime-darwin'