Merge pull request #9 from mrackwitz/keyed-container-in-single-value-container

Decoding fails for keyed structs in a `singleValueContainer`

Author: christophhagen

Sources/BinaryCodable/Decoding/DecodingNode.swift

@@ -8,6 +8,13 @@ final class DecodingNode: AbstractDecodingNode, Decoder {
 
     private let isInUnkeyedContainer: Bool
 
+    init(storage: Storage, isOptional: Bool = false, path: [CodingKey], info: UserInfo, isInUnkeyedContainer: Bool = false) {
+        self.storage = storage
+        self.isOptional = isOptional
+        self.isInUnkeyedContainer = isInUnkeyedContainer
+        super.init(path: path, info: info)
+    }
+
     init(data: Data, isOptional: Bool = false, path: [CodingKey], info: UserInfo) {
         self.storage = .data(data)
         self.isOptional = isOptional
@@ -33,7 +40,7 @@ final class DecodingNode: AbstractDecodingNode, Decoder {
 
     func singleValueContainer() throws -> SingleValueDecodingContainer {
         return ValueDecoder(
-            data: storage.useAsDecoder(),
+            storage: storage,
             isOptional: isOptional, 
             isInUnkeyedContainer: isInUnkeyedContainer,
             path: codingPath,

Sources/BinaryCodable/Decoding/ValueDecoder.swift

@@ -2,22 +2,28 @@ import Foundation
 
 final class ValueDecoder: AbstractDecodingNode, SingleValueDecodingContainer {
 
-    let data: BinaryStreamProvider
+    private var storage: Storage
 
     private let isOptional: Bool
 
     private let isInUnkeyedContainer: Bool
 
-    init(data: BinaryStreamProvider, isOptional: Bool, isInUnkeyedContainer: Bool, path: [CodingKey], info: UserInfo) {
-        self.data = data
+    init(storage: Storage, isOptional: Bool, isInUnkeyedContainer: Bool, path: [CodingKey], info: UserInfo) {
+        self.storage = storage
         self.isOptional = isOptional
         self.isInUnkeyedContainer = isInUnkeyedContainer
         super.init(path: path, info: info)
     }
 
+    private func asDecoder() -> BinaryStreamProvider {
+        let decoder = self.storage.useAsDecoder()
+        self.storage = .decoder(decoder)
+        return decoder
+    }
+
     func decodeNil() -> Bool {
         do {
-            let byte = try data.getByte(path: codingPath)
+            let byte = try asDecoder().getByte(path: codingPath)
             return byte == 0
         } catch {
             return false
@@ -26,18 +32,28 @@ final class ValueDecoder: AbstractDecodingNode, SingleValueDecodingContainer {
 
     func decode<T>(_ type: T.Type) throws -> T where T : Decodable {
         if type is AnyOptional.Type {
-            let node = DecodingNode(decoder: data, isOptional: true, path: codingPath, info: userInfo)
+            let node = DecodingNode(storage: storage, isOptional: true, path: codingPath, info: userInfo)
             return try T.init(from: node)
         } else if let Primitive = type as? DecodablePrimitive.Type {
             let data: Data
-            if !isInUnkeyedContainer, Primitive.dataType == .variableLength, !isOptional, let d = self.data as? DataDecoder {
-                data = d.getAllData()
+            if !isInUnkeyedContainer, Primitive.dataType == .variableLength, !isOptional {
+                switch storage {
+                case .data(let d):
+                    data = d
+                case .decoder(let decoder):
+                    if let d = decoder as? DataDecoder {
+                        data = d.getAllData()
+                    } else {
+                        data = try decoder.getData(for: Primitive.dataType, path: codingPath)
+                    }
+                }
             } else {
-                data = try self.data.getData(for: Primitive.dataType, path: codingPath)
+                let decoder = asDecoder()
+                data = try decoder.getData(for: Primitive.dataType, path: codingPath)
             }
             return try Primitive.init(decodeFrom: data, path: codingPath) as! T
         } else {
-            let node = DecodingNode(decoder: data, path: codingPath, info: userInfo)
+            let node = DecodingNode(storage: storage, path: codingPath, info: userInfo)
             return try T.init(from: node)
         }
     }

Tests/BinaryCodableTests/CustomDecodingTests.swift

@@ -133,7 +133,7 @@ final class CustomDecodingTests: XCTestCase {
 
     func testEncodingAsDifferentType() throws {
         let version = Version(major: 1, minor: 2, patch: 3)
-        let time = Date.now
+        let time = Date()
         let sValue = Timestamped(value: version.rawValue, timestamp: time)
         let vValue = Timestamped(value: version, timestamp: time)
         let encoder = BinaryEncoder()

Tests/BinaryCodableTests/StructEncodingTests.swift

@@ -153,4 +153,49 @@ final class StructEncodingTests: XCTestCase {
         let decoded: [String: Int] = try BinaryDecoder.decode(from: encoded)
         XCTAssertEqual(decoded, ["a" : 123, "b": 0, "c": -123456])
     }
+
+    func testDecodeKeyedContainerInSingleValueContainer() throws {
+        struct Wrapper: Codable, Equatable {
+            let wrapped: Wrapped
+
+            init(wrapped: Wrapped) {
+                self.wrapped = wrapped
+            }
+
+            init(from decoder: Decoder) throws {
+                let container = try decoder.singleValueContainer()
+                self.wrapped = try container.decode(Wrapped.self)
+            }
+
+            func encode(to encoder: Encoder) throws {
+                var container = encoder.singleValueContainer()
+                try container.encode(wrapped)
+            }
+        }
+        struct Wrapped: Codable, Equatable {
+            let val: String
+        }
+
+        let expected: [UInt8] = [
+            0b00111010, 118, 97, 108, // String key 'val', varint
+            4, // Length 4
+            83, 111, 109, 101, // String "Some"
+        ]
+
+        let wrapped = Wrapped(val: "Some")
+        let encodedWrapped = try BinaryEncoder.encode(wrapped)
+
+        try compare(encodedWrapped, to: expected)
+
+        let decodedWrapped: Wrapped = try BinaryDecoder.decode(from: encodedWrapped)
+        XCTAssertEqual(decodedWrapped, wrapped)
+
+        let wrapper = Wrapper(wrapped: wrapped)
+        let encodedWrapper = try BinaryEncoder.encode(wrapper)
+
+        try compare(encodedWrapper, to: expected)
+
+        let decodedWrapper: Wrapper = try BinaryDecoder.decode(from: encodedWrapper)
+        XCTAssertEqual(decodedWrapper, wrapper)
+    }
 }