Update date formatter (#40)

- Replace PreciseDateFormatter implementation with PreciseISO8601DateFormatter
- Increase minimum target versions
- Increase Swift version
- Format code

Author: atdrendel

.github/workflows/ci.yml

@@ -1,16 +1,14 @@
-name: Build
+name: CI
 
-on:
-  push:
+on: push
 
 jobs:
-  build:
-    name: Build and Test
-    runs-on: macos-latest
-
+  test:
+    runs-on: macos-12
+    
     steps:
-    - uses: actions/checkout@v2
-    - name: Build
-      run: swift build -v
-    - name: Run tests
-      run: swift test -v
+      - uses: actions/checkout@v3
+      - name: Select Xcode 14
+        run: sudo xcode-select -s /Applications/Xcode_14.1.app
+      - name: Test
+        run: swift test

.swift-version

@@ -0,0 +1,2 @@
+5.7.0
+

.swiftformat

@@ -0,0 +1,7 @@
+--funcattributes prev-line
+--minversion 0.47.2
+--maxwidth 96
+--typeattributes prev-line
+--wraparguments before-first
+--wrapparameters before-first
+--wrapcollections before-first

Package.resolved

@@ -1,38 +1,49 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.7
 import PackageDescription
 
 let package = Package(
     name: "SQLite",
     platforms: [
-        .macOS(.v10_15), .iOS(.v13), .tvOS(.v13), .watchOS(.v5),
+        .macOS(.v11), .iOS(.v14), .tvOS(.v14), .watchOS(.v7),
     ],
     products: [
         .library(
             name: "SQLite",
-            targets: ["SQLite"]),
+            targets: ["SQLite"]
+        ),
     ],
     dependencies: [
         .package(
-            name: "CombineExtensions",
             url: "https://github.com/shareup/combine-extensions.git",
-            from: "4.0.0"
+            from: "5.0.0"
+        ),
+        .package(
+            url: "https://github.com/shareup/precise-iso-8601-date-formatter.git",
+            from: "1.0.2"
         ),
         .package(
-            name: "Synchronized",
             url: "https://github.com/shareup/synchronized.git",
-            from: "3.0.0"
+            from: "4.0.0"
         ),
     ],
     targets: [
         .target(
             name: "SQLite",
-            dependencies: ["Synchronized"]),
+            dependencies: [
+                .product(
+                    name: "PreciseISO8601DateFormatter",
+                    package: "precise-iso-8601-date-formatter"
+                ),
+                .product(name: "Synchronized", package: "synchronized"),
+            ]
+        ),
         .testTarget(
             name: "SQLiteTests",
             dependencies: [
-                "CombineExtensions",
-                .product(name: "CombineTestExtensions", package: "CombineExtensions"),
+                .product(name: "CombineExtensions", package: "combine-extensions"),
+                .product(name: "CombineTestExtensions", package: "combine-extensions"),
                 "SQLite",
-            ]),
+            ]
+        ),
     ]
 )

Package.swift

@@ -17,7 +17,7 @@ To use SQLite with the Swift Package Manager, add a dependency to your Package.s
 ```swift
 let package = Package(
   dependencies: [
-    .package(url: "https://github.com/shareup/sqlite.git", .upToNextMajor(from: "16.0.0"))
+    .package(url: "https://github.com/shareup/sqlite.git", .upToNextMajor(from: "18.0.0"))
   ]
 )
 ```

README.md

@@ -16,21 +16,21 @@ func updateHookWrapper(
     databaseName: UnsafePointer<Int8>?,
     tableName: UnsafePointer<Int8>?,
     rowid: sqlite3_int64
-) -> Void {
-    guard let context = context else { return }
+) {
+    guard let context else { return }
     let hook = Unmanaged<Hook>.fromOpaque(context).takeUnretainedValue()
     hook.update?(context, operationType, databaseName, tableName, rowid)
 }
 
 func commitHookWrapper(context: UnsafeMutableRawPointer?) -> Int32 {
-    guard let context = context else { return 0 }
+    guard let context else { return 0 }
     let hook = Unmanaged<Hook>.fromOpaque(context).takeUnretainedValue()
     hook.commit?()
     return 0
 }
 
 func rollbackHookWrapper(context: UnsafeMutableRawPointer?) {
-    guard let context = context else { return }
+    guard let context else { return }
     let hook = Unmanaged<Hook>.fromOpaque(context).takeUnretainedValue()
     hook.rollback?()
 }

Sources/SQLite/Hook.swift

@@ -1,41 +1,37 @@
 import Foundation
+import PreciseISO8601DateFormatter
 
-// `ISO8601DateFormatter` does not maintain nanosecond precision, which makes it
+// `ISO8601DateFormatter` does not maintain microsecond precision, which makes it
 // nearly impossible to equate encodable objects that include `Date` properties.
-// `DateFormatter` maintains nanosecond precision by storing the exact
-// bit pattern of `Date.timeIntervalSinceReferenceDate`, which is the type's
-// underlying primitive. https://developer.apple.com/documentation/foundation/nsdate
-public struct PreciseDateFormatter {
+// `DateFormatter` maintains microsecond precision.
+public enum PreciseDateFormatter {
     public static func string(from date: Date) -> String {
-        let bitPattern = date.timeIntervalSinceReferenceDate.bitPattern
-        return String(bitPattern)
+        formatter.string(from: date)
     }
 
     public static func date(from string: String) -> Date? {
-        guard let bitPattern = UInt64(string) else { return nil }
-        let double = Double(bitPattern: bitPattern)
-        return Date(timeIntervalSinceReferenceDate: double)
+        formatter.date(from: string)
     }
 }
 
-extension KeyedDecodingContainer {
-    public func decodePreciseDate(forKey key: K) throws -> Date {
-        let asString = try self.decode(String.self, forKey: key)
+public extension KeyedDecodingContainer {
+    func decodePreciseDate(forKey key: K) throws -> Date {
+        let asString = try decode(String.self, forKey: key)
         guard let date = PreciseDateFormatter.date(from: asString) else {
             let context = DecodingError.Context(
-                codingPath: self.codingPath,
+                codingPath: codingPath,
                 debugDescription: "Could not parse '\(asString)' into Date."
             )
             throw Swift.DecodingError.typeMismatch(Date.self, context)
         }
         return date
     }
 
-    public func decodePreciseDateIfPresent(forKey key: K) throws -> Date? {
-        guard let asString = try self.decodeIfPresent(String.self, forKey: key) else { return nil }
+    func decodePreciseDateIfPresent(forKey key: K) throws -> Date? {
+        guard let asString = try decodeIfPresent(String.self, forKey: key) else { return nil }
         guard let date = PreciseDateFormatter.date(from: asString) else {
             let context = DecodingError.Context(
-                codingPath: self.codingPath,
+                codingPath: codingPath,
                 debugDescription: "Could not parse '\(asString)' into Date."
             )
             throw Swift.DecodingError.typeMismatch(Date.self, context)
@@ -44,13 +40,15 @@ extension KeyedDecodingContainer {
     }
 }
 
-extension KeyedEncodingContainer {
-    public mutating func encode(preciseDate: Date, forKey key: K) throws {
-        try self.encode(PreciseDateFormatter.string(from: preciseDate), forKey: key)
+public extension KeyedEncodingContainer {
+    mutating func encode(preciseDate: Date, forKey key: K) throws {
+        try encode(PreciseDateFormatter.string(from: preciseDate), forKey: key)
     }
 
-    public mutating func encodeIfPresent(preciseDate: Date?, forKey key: K) throws {
-        guard let preciseDate = preciseDate else { return }
-        try self.encodeIfPresent(PreciseDateFormatter.string(from: preciseDate), forKey: key)
+    mutating func encodeIfPresent(preciseDate: Date?, forKey key: K) throws {
+        guard let preciseDate else { return }
+        try encodeIfPresent(PreciseDateFormatter.string(from: preciseDate), forKey: key)
     }
 }
+
+private let formatter = PreciseISO8601DateFormatter()