Implement choice element decoding

Create interface for branching off XMLChoiceKeys

Add XMLSingleElementDecodingContainer copy pasta

Add XMLDecoderImplementation.singleElementContainer(keyedBy:) copy pasta

Push XMLChoiceKeys through singleElementContainer

Add XMLUnkeyedDecodingContainer.nestedSingleElementContainer copy pasta

Add XMLKeyedDecodingContainer.nestedSingleElementContainer copy pasta

Add XMLSingleElementDecodingContainer.nestedSingleElementContainer copy pasta

Remove print statement from test

Make IntOrStringWrapper.CodingKeys: XMLChoiceKey

Make Entry.CodingKeys: XMLChoiceKey

Only allow KeyedBoxes pass through to SingleElementDecodingContainer

Actually use XMLSingleElementDecodingContainer

Make tests pass

Rename XMLSingleElementDecodingContainer -> XMLChoiceDecodingContainer

Use ChoiceBox

Get rid of some prints

Unimplement singleElementContainer

Unimplement singleElementContainer

Tidy xcscheme

Unimplement nestedSingleElementContainer

Remove dump

Replace fatalError with thrown error

Omit type label

Omit type label

Fix formatting

Sources/XMLCoder/Auxiliaries/Box/ChoiceBox.swift

@@ -0,0 +1,32 @@
+//
+//  ChoiceBox.swift
+//  XMLCoder
+//
+//  Created by James Bean on 7/18/19.
+//
+
+/// A `Box` which represents an element which is known to contain an XML choice element.
+struct ChoiceBox {
+    var key: String = ""
+    var element: Box = NullBox()
+}
+
+extension ChoiceBox: Box {
+    var isNull: Bool {
+        return false
+    }
+
+    func xmlString() -> String? {
+        return nil
+    }
+}
+
+extension ChoiceBox: SimpleBox {}
+
+extension ChoiceBox {
+    init?(_ keyedBox: KeyedBox) {
+        guard let firstKey = keyedBox.elements.keys.first else { return nil }
+        let firstElement = keyedBox.elements[firstKey]
+        self.init(key: firstKey, element: firstElement)
+    }
+}

Sources/XMLCoder/Auxiliaries/Box/SingleElementBox.swift

@@ -27,3 +27,11 @@ extension SingleElementBox: Box {
         return nil
     }
 }
+
+extension SingleElementBox {
+    init?(_ keyedBox: KeyedBox) {
+        guard let firstKey = keyedBox.elements.keys.first else { return nil }
+        let firstElement = keyedBox.elements[firstKey]
+        self.init(attributes: keyedBox.attributes, key: firstKey, element: firstElement)
+    }
+}

Sources/XMLCoder/Decoder/XMLChoiceDecodingContainer.swift

@@ -0,0 +1,254 @@
+//
+//  XMLChoiceDecodingContainer.swift
+//  XMLCoder
+//
+//  Created by James Bean on 7/18/19.
+//
+
+import Foundation
+
+struct XMLChoiceDecodingContainer<K: CodingKey>: KeyedDecodingContainerProtocol {
+    typealias Key = K
+
+    // MARK: Properties
+
+    /// A reference to the decoder we're reading from.
+    private let decoder: XMLDecoderImplementation
+
+    /// A reference to the container we're reading from.
+    private let container: SharedBox<ChoiceBox>
+
+    /// The path of coding keys taken to get to this point in decoding.
+    public private(set) var codingPath: [CodingKey]
+
+    // MARK: - Initialization
+
+    /// Initializes `self` by referencing the given decoder and container.
+    init(referencing decoder: XMLDecoderImplementation, wrapping container: SharedBox<ChoiceBox>) {
+        self.decoder = decoder
+
+        func mapKeys(
+            _ container: SharedBox<ChoiceBox>, closure: (String) -> String
+        ) -> SharedBox<ChoiceBox> {
+            return SharedBox(
+                ChoiceBox(
+                    key: closure(container.withShared { $0.key }),
+                    element: container.withShared { $0.element }
+                )
+            )
+        }
+        // FIXME: Keep DRY from XMLKeyedDecodingContainer.init
+        switch decoder.options.keyDecodingStrategy {
+        case .useDefaultKeys:
+            self.container = container
+        case .convertFromSnakeCase:
+            // Convert the snake case keys in the container to camel case.
+            // If we hit a duplicate key after conversion, then we'll use the
+            // first one we saw. Effectively an undefined behavior with dictionaries.
+            self.container = mapKeys(container) { key in
+                XMLDecoder.KeyDecodingStrategy._convertFromSnakeCase(key)
+            }
+        case .convertFromKebabCase:
+            self.container = mapKeys(container) { key in
+                XMLDecoder.KeyDecodingStrategy._convertFromKebabCase(key)
+            }
+        case .convertFromCapitalized:
+            self.container = mapKeys(container) { key in
+                XMLDecoder.KeyDecodingStrategy._convertFromCapitalized(key)
+            }
+        case let .custom(converter):
+            self.container = mapKeys(container) { key in
+                let codingPath = decoder.codingPath + [
+                    XMLKey(stringValue: key, intValue: nil),
+                ]
+                return converter(codingPath).stringValue
+            }
+        }
+        codingPath = decoder.codingPath
+    }
+
+    // MARK: - KeyedDecodingContainerProtocol Methods
+
+    public var allKeys: [Key] {
+        return container.withShared { Key(stringValue: $0.key) }.map { [$0] } ?? []
+    }
+
+    public func contains(_ key: Key) -> Bool {
+        return container.withShared { $0.key == key.stringValue }
+    }
+
+    public func decodeNil(forKey key: Key) throws -> Bool {
+        return container.withShared { $0.element.isNull }
+    }
+
+    public func decode<T: Decodable>(_ type: T.Type, forKey key: Key) throws -> T {
+        guard container.withShared({ $0.key == key.stringValue }) else {
+            throw DecodingError.typeMismatch(
+                at: codingPath,
+                expectation: type,
+                reality: container
+            )
+        }
+        return try decodeConcrete(type, forKey: key)
+    }
+
+    public func nestedContainer<NestedKey>(
+        keyedBy _: NestedKey.Type, forKey key: Key
+    ) throws -> KeyedDecodingContainer<NestedKey> {
+        decoder.codingPath.append(key)
+        defer { decoder.codingPath.removeLast() }
+
+        let value = container.withShared { $0.element }
+        let container: XMLKeyedDecodingContainer<NestedKey>
+
+        if let keyedContainer = value as? SharedBox<KeyedBox> {
+            container = XMLKeyedDecodingContainer<NestedKey>(
+                referencing: decoder,
+                wrapping: keyedContainer
+            )
+        } else if let keyedContainer = value as? KeyedBox {
+            container = XMLKeyedDecodingContainer<NestedKey>(
+                referencing: decoder,
+                wrapping: SharedBox(keyedContainer)
+            )
+        } else {
+            throw DecodingError.typeMismatch(
+                at: codingPath,
+                expectation: [String: Any].self,
+                reality: value
+            )
+        }
+        return KeyedDecodingContainer(container)
+    }
+
+    public func nestedUnkeyedContainer(forKey key: Key) throws -> UnkeyedDecodingContainer {
+        decoder.codingPath.append(key)
+        defer { decoder.codingPath.removeLast() }
+        guard let unkeyedElement = container.withShared({ $0.element }) as? UnkeyedBox else {
+            throw DecodingError.typeMismatch(
+                at: codingPath,
+                expectation: UnkeyedBox.self,
+                reality: container
+            )
+        }
+        return XMLUnkeyedDecodingContainer(
+            referencing: decoder,
+            wrapping: SharedBox(unkeyedElement)
+        )
+    }
+
+    public func superDecoder() throws -> Decoder {
+        return try _superDecoder(forKey: XMLKey.super)
+    }
+
+    public func superDecoder(forKey key: Key) throws -> Decoder {
+        return try _superDecoder(forKey: key)
+    }
+}
+
+/// Private functions
+extension XMLChoiceDecodingContainer {
+    private func _errorDescription(of key: CodingKey) -> String {
+        switch decoder.options.keyDecodingStrategy {
+        case .convertFromSnakeCase:
+            // In this case we can attempt to recover the original value by
+            // reversing the transform
+            let original = key.stringValue
+            let converted = XMLEncoder.KeyEncodingStrategy
+                ._convertToSnakeCase(original)
+            if converted == original {
+                return "\(key) (\"\(original)\")"
+            } else {
+                return "\(key) (\"\(original)\"), converted to \(converted)"
+            }
+        default:
+            // Otherwise, just report the converted string
+            return "\(key) (\"\(key.stringValue)\")"
+        }
+    }
+
+    private func decodeSignedInteger<T>(_ type: T.Type,
+                                        forKey key: Key) throws -> T
+        where T: BinaryInteger & SignedInteger & Decodable {
+        return try decodeConcrete(type, forKey: key)
+    }
+
+    private func decodeUnsignedInteger<T>(_ type: T.Type,
+                                          forKey key: Key) throws -> T
+        where T: BinaryInteger & UnsignedInteger & Decodable {
+        return try decodeConcrete(type, forKey: key)
+    }
+
+    private func decodeFloatingPoint<T>(_ type: T.Type,
+                                        forKey key: Key) throws -> T
+        where T: BinaryFloatingPoint & Decodable {
+        return try decodeConcrete(type, forKey: key)
+    }
+
+    private func decodeConcrete<T: Decodable>(
+        _ type: T.Type,
+        forKey key: Key
+    ) throws -> T {
+        guard let strategy = self.decoder.nodeDecodings.last else {
+            preconditionFailure(
+                """
+                Attempt to access node decoding strategy from empty stack.
+                """
+            )
+        }
+        let elements = container
+            .withShared { singleElementBox -> [KeyedBox.Element] in
+                if let unkeyed = singleElementBox.element as? UnkeyedBox {
+                    return unkeyed
+                } else if let keyed = singleElementBox.element as? KeyedBox {
+                    return keyed.elements[key.stringValue]
+                } else {
+                    return []
+                }
+            }
+        decoder.codingPath.append(key)
+        let nodeDecodings = decoder.options.nodeDecodingStrategy.nodeDecodings(
+            forType: T.self,
+            with: decoder
+        )
+        decoder.nodeDecodings.append(nodeDecodings)
+        defer {
+            _ = decoder.nodeDecodings.removeLast()
+            decoder.codingPath.removeLast()
+        }
+        let box: Box = elements
+        let value: T?
+        if !(type is AnySequence.Type), let unkeyedBox = box as? UnkeyedBox,
+            let first = unkeyedBox.first {
+            value = try decoder.unbox(first)
+        } else {
+            value = try decoder.unbox(box)
+        }
+
+        if value == nil, let type = type as? AnyOptional.Type,
+            let result = type.init() as? T {
+            return result
+        }
+
+        guard let unwrapped = value else {
+            throw DecodingError.valueNotFound(type, DecodingError.Context(
+                codingPath: decoder.codingPath,
+                debugDescription:
+                "Expected \(type) value but found null instead."
+            ))
+        }
+        return unwrapped
+    }
+
+    private func _superDecoder(forKey key: CodingKey) throws -> Decoder {
+        decoder.codingPath.append(key)
+        defer { decoder.codingPath.removeLast() }
+        let box: Box = container.withShared { $0.element }
+        return XMLDecoderImplementation(
+            referencing: box,
+            options: decoder.options,
+            nodeDecodings: decoder.nodeDecodings,
+            codingPath: decoder.codingPath
+        )
+    }
+}

Sources/XMLCoder/Decoder/XMLDecoderImplementation.swift

@@ -70,9 +70,15 @@ class XMLDecoderImplementation: Decoder {
         return topContainer
     }
 
-    public func container<Key>(
-        keyedBy keyType: Key.Type
-    ) throws -> KeyedDecodingContainer<Key> {
+    public func container<Key>(keyedBy keyType: Key.Type) throws -> KeyedDecodingContainer<Key> {
+        if Key.self is XMLChoiceKey.Type {
+            return try choiceContainer(keyedBy: keyType)
+        } else {
+            return try keyedContainer(keyedBy: keyType)
+        }
+    }
+
+    public func keyedContainer<Key>(keyedBy _: Key.Type) throws -> KeyedDecodingContainer<Key> {
         let topContainer = try self.topContainer()
 
         switch topContainer {
@@ -118,6 +124,26 @@ class XMLDecoderImplementation: Decoder {
         }
     }
 
+    /// - Returns: A `KeyedDecodingContainer` for an XML choice element.
+    public func choiceContainer<Key>(keyedBy _: Key.Type) throws -> KeyedDecodingContainer<Key> {
+        let topContainer = try self.topContainer()
+        guard
+            let keyed = topContainer as? SharedBox<KeyedBox>,
+            let choiceBox = ChoiceBox(keyed.withShared { $0 })
+        else {
+            throw DecodingError.typeMismatch(
+                at: codingPath,
+                expectation: [String: Any].self,
+                reality: topContainer
+            )
+        }
+        let container = XMLChoiceDecodingContainer<Key>(
+            referencing: self,
+            wrapping: SharedBox(choiceBox)
+        )
+        return KeyedDecodingContainer(container)
+    }
+
     public func unkeyedContainer() throws -> UnkeyedDecodingContainer {
         let topContainer = try self.topContainer()
 
@@ -140,10 +166,12 @@ class XMLDecoderImplementation: Decoder {
         case let keyed as SharedBox<KeyedBox>:
             return XMLUnkeyedDecodingContainer(
                 referencing: self,
-                wrapping: SharedBox(keyed.withShared { $0.elements.map { key, box in
-                    SingleElementBox(attributes: SingleElementBox.Attributes(), key: key, element: box)
+                wrapping: SharedBox(
+                    keyed.withShared { $0.elements.map { key, box in
+                        SingleElementBox(attributes: .init(), key: key, element: box)
+                    }
                     }
-                })
+                )
             )
         default:
             throw DecodingError.typeMismatch(

Tests/XMLCoderTests/CompositeChoiceTests.swift

@@ -22,7 +22,7 @@ private enum IntOrStringWrapper: Equatable {
 }
 
 extension IntOrStringWrapper: Codable {
-    enum CodingKeys: String, CodingKey {
+    enum CodingKeys: String, XMLChoiceKey {
         case int
         case string
     }

Tests/XMLCoderTests/NestedChoiceTests.swift

@@ -52,19 +52,19 @@ extension Paragraph: Codable {
     }
 }
 
-extension Entry: XMLChoiceCodable {
-    private enum CodingKeys: String, CodingKey {
+extension Entry: Codable {
+    private enum CodingKeys: String, XMLChoiceKey {
         case run, properties, br
     }
 
     public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         do {
             self = .run(try container.decode(Run.self, forKey: .run))
-        } catch DecodingError.keyNotFound {
+        } catch {
             do {
                 self = .properties(try container.decode(Properties.self, forKey: .properties))
-            } catch DecodingError.keyNotFound {
+            } catch {
                 self = .br(try container.decode(Break.self, forKey: .br))
             }
         }