[WIP / Proof of concept] Add Decoding support for enums with associated values

Sources/XMLCoder/Auxiliaries/XMLCoderElement.swift

@@ -58,6 +58,11 @@ struct XMLCoderElement: Equatable {
         let storage = KeyedStorage<String, Box>()
         var elements = self.elements.reduce(storage) { $0.merge(element: $1) }
 
+        // Handle enum with associated value case, in which there are no attributes _or_ elements.
+        if let value = value, elements.isEmpty, attributes.isEmpty {
+            elements.append(StringBox(value), at: key)
+        }
+
         // Handle attributed unkeyed value <foo attr="bar">zap</foo>
         // Value should be zap. Detect only when no other elements exist
         if elements.isEmpty, let value = value {

Sources/XMLCoder/Decoder/XMLDecoderImplementation.swift

@@ -138,9 +138,17 @@ class XMLDecoderImplementation: Decoder {
         case let unkeyed as SharedBox<UnkeyedBox>:
             return XMLUnkeyedDecodingContainer(referencing: self, wrapping: unkeyed)
         case let keyed as SharedBox<KeyedBox>:
-            guard let firstKey = keyed.withShared({ $0.elements.keys.first }) else { fallthrough }
-
-            return XMLUnkeyedDecodingContainer(referencing: self, wrapping: SharedBox(keyed.withShared { $0.elements[firstKey] }))
+            // In order to support decoding enums with associated values, transform the `keyed` box
+            // into an unkeyed box composed of a single key-valued `KeyedBox` element for each
+            // key-value pair found in the original.
+            //
+            // NB: This currently breaks `testDecodeUnkeyedWithinUnkeyed()`.
+            return XMLUnkeyedDecodingContainer(
+                referencing: self,
+                wrapping: keyed.withShared {
+                    SharedBox($0.elements.map { KeyedBox(elements: KeyedStorage([$0])) })
+                }
+            )
         default:
             throw DecodingError.typeMismatch(
                 at: codingPath,

Sources/XMLCoder/Decoder/XMLUnkeyedDecodingContainer.swift

@@ -101,9 +101,18 @@ struct XMLUnkeyedDecodingContainer: UnkeyedDecodingContainer {
         let box = container.withShared { unkeyedBox in
             unkeyedBox[self.currentIndex]
         }
-
-        let value = try decode(decoder, box)
-
+        var value = try decode(decoder,box)
+
+        // In order to support decoding enums with associated values, check to see if we have
+        // performed an injection of single key-valued `KeyedBox` elements in
+        // XMLDecoderImplementation.unkeyedContainer(), and attempt to decode the single element
+        // contained therein.
+        if value == nil {
+            if let keyed = box as? KeyedBox, keyed.elements.count == 1 {
+                value = try decode(decoder, keyed.elements[keyed.elements.keys[0]])
+            }
+        }
+
         defer { currentIndex += 1 }
 
         if value == nil, let type = type as? AnyOptional.Type,

Tests/XMLCoderTests/EnumAssociatedValueTestComposite.swift

@@ -0,0 +1,79 @@
+//
+//  EnumAssociatedValueTestComposite.swift
+//  XMLCoderTests
+//
+//  Created by James Bean on 7/12/19.
+//
+
+import XCTest
+import XMLCoder
+
+private struct IntWrapper: Decodable, Equatable {
+    let wrapped: Int
+}
+
+private struct StringWrapper: Decodable, Equatable {
+    let wrapped: String
+}
+
+private enum IntOrStringWrapper: Equatable {
+    case int(IntWrapper)
+    case string(StringWrapper)
+}
+
+extension IntOrStringWrapper: Decodable {
+
+    enum CodingKeys: String, CodingKey {
+        case int
+        case string
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        do {
+            self = .int(try container.decode(IntWrapper.self, forKey: .int))
+        } catch {
+            self = .string(try container.decode(StringWrapper.self, forKey: .string))
+        }
+    }
+}
+
+
+class EnumAssociatedValueTestComposite: XCTestCase {
+
+    func testIntOrStringWrapper() throws {
+        let xml = """
+        <container>
+            <string>
+                <wrapped>A Word About Woke Times</wrapped>
+            </string>
+        </container>
+        """
+        let result = try XMLDecoder().decode(IntOrStringWrapper.self, from: xml.data(using: .utf8)!)
+        let expected = IntOrStringWrapper.string(StringWrapper(wrapped: "A Word About Woke Times"))
+        XCTAssertEqual(result, expected)
+    }
+
+    func testArrayOfIntOrStringWrappers() throws {
+        let xml = """
+        <container>
+            <string>
+                <wrapped>A Word About Woke Times</wrapped>
+            </string>
+            <int>
+                <wrapped>9000</wrapped>
+            </int>
+            <string>
+                <wrapped>A Word About Woke Tomes</wrapped>
+            </string>
+        </container>
+        """
+        let result = try XMLDecoder().decode([IntOrStringWrapper].self, from: xml.data(using: .utf8)!)
+        let expected: [IntOrStringWrapper] = [
+            .string(StringWrapper(wrapped: "A Word About Woke Times")),
+            .int(IntWrapper(wrapped: 9000)),
+            .string(StringWrapper(wrapped: "A Word About Woke Tomes")),
+        ]
+        XCTAssertEqual(result, expected)
+    }
+}

Tests/XMLCoderTests/EnumAssociatedValueTestSimple.swift

@@ -0,0 +1,71 @@
+//
+//  EnumAssociatedValueTestSimple.swift
+//  XMLCoderTests
+//
+//  Created by James Bean on 7/9/19.
+//
+
+import XCTest
+import XMLCoder
+
+private enum IntOrString {
+    case int(Int)
+    case string(String)
+}
+
+extension IntOrString: Decodable {
+
+    enum CodingKeys: String, CodingKey {
+        case int
+        case string
+    }
+
+    init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        do {
+            self = .int(try container.decode(Int.self, forKey: .int))
+        } catch {
+            self = .string(try container.decode(String.self, forKey: .string))
+        }
+    }
+}
+
+extension IntOrString: Equatable { }
+
+class EnumAssociatedValuesTest: XCTestCase {
+
+    func testIntOrStringIntDecoding() throws {
+        let xml = "<int>42</int>"
+        let result = try XMLDecoder().decode(IntOrString.self, from: xml.data(using: .utf8)!)
+        let expected = IntOrString.int(42)
+        XCTAssertEqual(result, expected)
+    }
+
+    func testIntOrStringStringDecoding() throws {
+        let xml = "<string>forty-two</string>"
+        let result = try XMLDecoder().decode(IntOrString.self, from: xml.data(using: .utf8)!)
+        let expected = IntOrString.string("forty-two")
+        XCTAssertEqual(result, expected)
+    }
+
+    func testIntOrStringArrayDecoding() throws {
+        let xml = """
+        <container>
+            <int>1</int>
+            <string>two</string>
+            <string>three</string>
+            <int>4</int>
+            <int>5</int>
+        </container>
+        """
+        let result = try XMLDecoder().decode([IntOrString].self, from: xml.data(using: .utf8)!)
+        let expected: [IntOrString] = [
+            .int(1),
+            .string("two"),
+            .string("three"),
+            .int(4),
+            .int(5),
+        ]
+        XCTAssertEqual(result, expected)
+    }
+}