Add testing preliminaries for choice elements

Add benchmark baselines

Pull in tests (#11)

Add Decoding support for choice elements (#15)

Fix indentation (#16)

Replace usage of XCTUnrwap (#19)

Add nested choice tests (#18)

Add falsely passing double array roundtrip test (#17)

Author: bwetherfield

Sources/XMLCoder/Auxiliaries/Box/SingleElementBox.swift

@@ -0,0 +1,24 @@
+//
+//  SingleElementBox.swift
+//  XMLCoder
+//
+//  Created by James Bean on 7/15/19.
+//
+
+/// A `Box` which contains a single `key` and `element` pair. This is useful for disambiguating elements which could either represent
+/// an element nested in a keyed or unkeyed container, or an choice between multiple known-typed values (implemented in Swift using
+/// enums with associated values).
+struct SingleElementBox: SimpleBox {
+    let key: String
+    let element: Box
+}
+
+extension SingleElementBox: Box {
+    var isNull: Bool {
+        return false
+    }
+
+    func xmlString() -> String? {
+        return nil
+    }
+}

Sources/XMLCoder/Auxiliaries/XMLCoderElement.swift

@@ -51,7 +51,10 @@ struct XMLCoderElement: Equatable {
         elements.append(element)
     }
 
-    func transformToBoxTree() -> KeyedBox {
+    func transformToBoxTree() -> Box {
+        if let value = value, self.attributes.isEmpty, self.elements.isEmpty {
+            return SingleElementBox(key: key, element: StringBox(value))
+        }
         let attributes = KeyedStorage(self.attributes.map { attribute in
             (key: attribute.key, value: StringBox(attribute.value) as SimpleBox)
         })
@@ -63,9 +66,7 @@ struct XMLCoderElement: Equatable {
         if elements.isEmpty, let value = value {
             elements.append(StringBox(value), at: "value")
         }
-        let keyedBox = KeyedBox(elements: elements, attributes: attributes)
-
-        return keyedBox
+        return KeyedBox(elements: elements, attributes: attributes)
     }
 
     func toXMLString(with header: XMLHeader? = nil,
@@ -104,7 +105,7 @@ struct XMLCoderElement: Equatable {
     ) -> String {
         var string = ""
         string += element._toXMLString(
-            indented: level + 1, withCDATA: cdata, formatting: formatting
+            indented: level, withCDATA: cdata, formatting: formatting
         )
         string += prettyPrinted ? "\n" : ""
         return string

Sources/XMLCoder/Auxiliaries/XMLStackParser.swift

@@ -23,7 +23,7 @@ class XMLStackParser: NSObject {
         errorContextLength length: UInt,
         shouldProcessNamespaces: Bool,
         trimValueWhitespaces: Bool
-    ) throws -> KeyedBox {
+    ) throws -> Box {
         let parser = XMLStackParser(trimValueWhitespaces: trimValueWhitespaces)
 
         let node = try parser.parse(

Sources/XMLCoder/Decoder/XMLDecoderImplementation.swift

@@ -138,9 +138,10 @@ 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] }))
+            return XMLUnkeyedDecodingContainer(
+                referencing: self,
+                wrapping: SharedBox(keyed.withShared { $0.elements.map(SingleElementBox.init) })
+            )
         default:
             throw DecodingError.typeMismatch(
                 at: codingPath,
@@ -372,6 +373,20 @@ extension XMLDecoderImplementation {
         return urlBox.unboxed
     }
 
+    func unbox<T: Decodable>(_ box: SingleElementBox) throws -> T {
+        do {
+            return try unbox(box.element)
+        } catch {
+            // FIXME: Find a more economical way to unbox a `SingleElementBox` !
+            return try unbox(
+                KeyedBox(
+                    elements: KeyedStorage([(box.key, box.element)]),
+                    attributes: []
+                )
+            )
+        }
+    }
+
     func unbox<T: Decodable>(_ box: Box) throws -> T {
         let decoded: T?
         let type = T.self
@@ -392,6 +407,8 @@ extension XMLDecoderImplementation {
             type == String.self || type == NSString.self,
             let value = (try unbox(box) as String) as? T {
             decoded = value
+        } else if let singleElementBox = box as? SingleElementBox {
+            decoded = try unbox(singleElementBox)
         } else {
             storage.push(container: box)
             defer {

Tests/XMLCoderTests/CompositeChoiceTests.swift

@@ -0,0 +1,86 @@
+//
+//  CompositeChoiceTests.swift
+//  XMLCoderTests
+//
+//  Created by James Bean on 7/15/19.
+//
+
+import XCTest
+import XMLCoder
+
+private struct IntWrapper: Codable, Equatable {
+    let wrapped: Int
+}
+
+private struct StringWrapper: Codable, Equatable {
+    let wrapped: String
+}
+
+private enum IntOrStringWrapper: Equatable {
+    case int(IntWrapper)
+    case string(StringWrapper)
+}
+
+extension IntOrStringWrapper: Codable {
+    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))
+        }
+    }
+
+    func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case let .int(value):
+            try container.encode(value, forKey: .int)
+        case let .string(value):
+            try container.encode(value, forKey: .string)
+        }
+    }
+}
+
+class CompositeChoiceTests: 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/Minimal/BoxTreeTests.swift

@@ -9,7 +9,7 @@ import XCTest
 @testable import XMLCoder
 
 class BoxTreeTests: XCTestCase {
-    func testNestedValues() {
+    func testNestedValues() throws {
         let e1 = XMLCoderElement(
             key: "foo",
             value: "456",
@@ -29,18 +29,11 @@ class BoxTreeTests: XCTestCase {
             attributes: []
         )
 
-        let boxTree = root.transformToBoxTree()
-
-        guard let foo = boxTree.elements["foo"] as? UnkeyedBox else {
-            XCTAssert(
-                false,
-                """
-                flattened.elements["foo"] is not an UnkeyedBox
-                """
-            )
+        guard let boxTree = root.transformToBoxTree() as? KeyedBox else {
+            XCTFail("boxtTree is not a KeyedBox")
             return
         }
-
+        let foo = boxTree.elements["foo"]
         XCTAssertEqual(foo.count, 2)
     }
 }