Add KeyedDecodingContainer convenience methods for optional Date (#16)

Author: atdrendel

Sources/SQLite/PreciseDateFormatter.swift

@@ -30,10 +30,27 @@ extension KeyedDecodingContainer {
         }
         return date
     }
+
+    public func decodePreciseDateIfPresent(forKey key: K) throws -> Date? {
+        guard let asString = try self.decodeIfPresent(String.self, forKey: key) else { return nil }
+        guard let date = PreciseDateFormatter.date(from: asString) else {
+            let context = DecodingError.Context(
+                codingPath: self.codingPath,
+                debugDescription: "Could not parse '\(asString)' into Date."
+            )
+            throw Swift.DecodingError.typeMismatch(Date.self, context)
+        }
+        return date
+    }
 }
 
 extension KeyedEncodingContainer {
     public mutating func encode(preciseDate: Date, forKey key: K) throws {
         try self.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)
+    }
 }

Tests/SQLiteTests/PreciseDateFormatterTests.swift

@@ -28,11 +28,17 @@ class PreciseDateFormatterTests: XCTestCase {
 
     func testEncodingAndDecodingPreciseDate() throws {
         let date = Date(timeIntervalSince1970: 1534500993.44331)
-        let model = Model(date)
+        let optionalSome = Date(timeIntervalSince1970: 1)
+        let optionalNone: Date? = nil
 
-        let encoded = try JSONEncoder().encode(model)
-        let decoded = try JSONDecoder().decode(Model.self, from: encoded)
-        XCTAssertEqual(model, decoded)
+        let one = Model(date, optionalSome)
+        let two = Model(date, optionalNone)
+
+        for model in [one, two] {
+            let encoded = try JSONEncoder().encode(model)
+            let decoded = try JSONDecoder().decode(Model.self, from: encoded)
+            XCTAssertEqual(model, decoded)
+        }
     }
 
     static var allTests = [
@@ -45,23 +51,28 @@ class PreciseDateFormatterTests: XCTestCase {
 
 private struct Model: Codable, Equatable {
     let date: Date
+    let optionalDate: Date?
 
-    init(_ date: Date) {
+    init(_ date: Date, _ optionalDate: Date?) {
         self.date = date
+        self.optionalDate = optionalDate
     }
 
     enum CodingKeys: String, CodingKey {
         case date
+        case optionalDate
     }
 
     init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         self.date = try container.decodePreciseDate(forKey: .date)
+        self.optionalDate = try container.decodePreciseDateIfPresent(forKey: .optionalDate)
     }
 
     func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(preciseDate: self.date, forKey: .date)
+        try container.encodeIfPresent(preciseDate: self.optionalDate, forKey: .optionalDate)
     }
 }