Support for withKey / optionalWithKey for types that aren't Decodable (#2)

* Add test for nested encodable type
* Add support for non-decodable withKey
* Add support for non-decodable optionalWithKey

Author: subdigital

Sources/Coding/Decoding.swift

@@ -96,6 +96,23 @@ public extension Decoding where Value: Decodable {
     }
 }
 
+public extension Decoding {
+    func withKey<Key: CodingKey>(_ key: Key) -> Self {
+        .init { decoder in
+            let container = try decoder.container(keyedBy: Key.self)
+            return try self.decode(container.superDecoder(forKey: key))
+        }
+    }
+    
+    func optionalWithKey<Key: CodingKey>(_ key: Key) -> Decoding<Value?> {
+        .init { decoder in
+            let container = try decoder.container(keyedBy: Key.self)
+            guard container.contains(key) else { return nil }
+            return try self.decode(container.superDecoder(forKey: key))
+        }
+    }
+}
+
 // MARK: - Collections
 
 public extension Decoding {

Tests/CodingTests/DecodingTests.swift

@@ -161,6 +161,91 @@ final class DecodingTests: XCTestCase {
             ]
         )
     }
+    
+    func testDecodingNestedDecodings() throws {
+        struct Parent {
+            let name: String
+            let children: [Child]
+            enum CodingKeys: String, CodingKey {
+                case name
+                case children
+            }
+        }
+        
+        struct Child {
+            let name: String
+            enum CodingKeys: String, CodingKey {
+                case name
+            }
+        }
+        
+        let childDecoding = Decoding<String>.withKey(Child.CodingKeys.name)
+                .map(Child.init)
+        
+        let parentDecoding = zip(with: Parent.init)(
+            Decoding<String>.withKey(Parent.CodingKeys.name),
+            Decoding<Child>.arrayOf(childDecoding).withKey(Parent.CodingKeys.children)
+            )
+        
+        let json = """
+            {
+              "name" : "Anakin",
+              "children" : [
+                {
+                  "name" : "Luke"
+                },
+                {
+                  "name" : "Leia"
+                }
+              ]
+            }
+            """
+        
+        let parent = try decoder.decode(json.data(using: .utf8)!, as: parentDecoding)
+        XCTAssertEqual(parent.name, "Anakin")
+        XCTAssertEqual(parent.children.count, 2)
+        
+        XCTAssertTrue(parent.children.contains(where: { $0.name == "Luke" }))
+        XCTAssertTrue(parent.children.contains(where: { $0.name == "Leia" }))
+    }
+    
+    func testDecodingNestedDecodingOptionalWithKey() throws {
+        struct Parent {
+            let name: String
+            let children: [Child]?
+            enum CodingKeys: String, CodingKey {
+                case name
+                case children
+            }
+        }
+        
+        struct Child {
+            let name: String
+            enum CodingKeys: String, CodingKey {
+                case name
+            }
+        }
+        
+        let childDecoding = Decoding<String>.withKey(Child.CodingKeys.name)
+                .map(Child.init)
+        
+        let parentDecoding = zip(with: Parent.init)(
+            Decoding<String>.withKey(Parent.CodingKeys.name),
+            Decoding<Child>
+                .arrayOf(childDecoding)
+                .optionalWithKey(Parent.CodingKeys.children)
+            )
+        
+        let json = """
+            {
+              "name" : "Yoda"
+            }
+            """
+        
+        let parent = try decoder.decode(json.data(using: .utf8)!, as: parentDecoding)
+        XCTAssertEqual(parent.name, "Yoda")
+        XCTAssertNil(parent.children)
+    }
 
     // MARK: - Built-in decodings
 

Tests/CodingTests/EncodingTests.swift

@@ -417,6 +417,60 @@ final class EncodingTests: XCTestCase {
             stringValue(try encoder.encode(car, as: .default))
         )
     }
+    
+    func testNestedCollectionOfEncoding() throws {
+        struct Parent {
+            let name: String
+            let children: [Child]
+            enum CodingKeys: String, CodingKey {
+                case name
+                case children
+            }
+        }
+        
+        struct Child {
+            let name: String
+            enum CodingKeys: String, CodingKey {
+                case name
+            }
+        }
+        
+        let childEncoding: Encoding<Child> =
+            Encoding<String>.withKey(Child.CodingKeys.name)
+                .pullback(\.name)
+        
+        let parentEncoding = Encoding<Parent>.combine(
+            Encoding<String>
+                .withKey(Parent.CodingKeys.name)
+                .pullback(\.name),
+            
+            Encoding<[Child]>.arrayOf(childEncoding)
+                .withKey(Parent.CodingKeys.children)
+                .pullback(\.children)
+        )
+        
+        encoder.outputFormatting = .prettyPrinted
+        
+        let parent = Parent(name: "Anakin", children: [
+            .init(name: "Luke"),
+            .init(name: "Leia"),
+        ])
+        let out = stringValue(try encoder.encode(parent, as: parentEncoding))
+
+        XCTAssertEqual("""
+            {
+              "name" : "Anakin",
+              "children" : [
+                {
+                  "name" : "Luke"
+                },
+                {
+                  "name" : "Leia"
+                }
+              ]
+            }
+            """, out)
+    }
 
     func testCollectionOfComplexTypes() {
         encoder.outputFormatting = .prettyPrinted