Refactor clean up choice coding implementation

Rename singleElementBox -> choiceBox

Create privileged path for Choices

Sweep away commented-out code

Add comment

Don't treat top-level choice

Tighten up impl

Rename singleElementContainer method -> choiceContainer

Whoops that was the Encoder

Add unkeyed single element container et al.

Add messages to fatal errors

Omit type label

Switch to ChoiceBox based implementation

Revert pretty printing special casing

Add passing encode tests for choice elements with attributes

Add xcodeproj debris

Remove use of XMLUnkeyedSingleElementDecodingContainer

Remove unreached code in XMLChoiceDecodingContainer

Remove superDecoder methods because enums ain't classes

Put all the decode impl in one place

Whitespace

Sources/XMLCoder/Auxiliaries/Box/ChoiceBox.swift

@@ -26,7 +26,11 @@ extension ChoiceBox: SimpleBox {}
 extension ChoiceBox {
     init?(_ keyedBox: KeyedBox) {
         guard let firstKey = keyedBox.elements.keys.first else { return nil }
-        let firstElement = keyedBox.elements[firstKey]
+        guard let firstElement = keyedBox.elements[firstKey].first else { return nil }
         self.init(key: firstKey, element: firstElement)
     }
+
+    init(_ singleElementBox: SingleElementBox) {
+        self.init(key: singleElementBox.key, element: singleElementBox.element)
+    }
 }

Sources/XMLCoder/Auxiliaries/XMLCoderElement.swift

@@ -52,9 +52,6 @@ struct XMLCoderElement: Equatable {
     }
 
     func transformToBoxTree() -> Box {
-        if let value = value, self.attributes.isEmpty, self.elements.isEmpty {
-            return SingleElementBox(attributes: SingleElementBox.Attributes(), key: key, element: StringBox(value))
-        }
         let attributes = KeyedStorage(self.attributes.map { attribute in
             (key: attribute.key, value: StringBox(attribute.value) as SimpleBox)
         })
@@ -105,7 +102,7 @@ struct XMLCoderElement: Equatable {
     ) -> String {
         var string = ""
         string += element._toXMLString(
-            indented: level, withCDATA: cdata, formatting: formatting
+            indented: level + 1, withCDATA: cdata, formatting: formatting
         )
         string += prettyPrinted ? "\n" : ""
         return string
@@ -246,14 +243,16 @@ struct XMLCoderElement: Equatable {
 
 extension XMLCoderElement {
     init(key: String, box: UnkeyedBox) {
-        if box is [SingleElementBox] {
-            self.init(key: key, elements: box.map { XMLCoderElement(key: "", box: $0) })
+        if let containsChoice = box as? [ChoiceBox] {
+            self.init(key: key, elements: containsChoice.map {
+                return XMLCoderElement(key: $0.key, box: $0.element)
+            })
         } else {
             self.init(key: key, elements: box.map { XMLCoderElement(key: key, box: $0) })
         }
     }
-
-    init(key: String, box: SingleElementBox) {
+    
+    init(key: String, box: ChoiceBox) {
         self.init(key: key, elements: [XMLCoderElement(key: box.key, box: box.element)])
     }
 
@@ -309,14 +308,14 @@ extension XMLCoderElement {
             self.init(key: key, box: sharedUnkeyedBox.unboxed)
         case let sharedKeyedBox as SharedBox<KeyedBox>:
             self.init(key: key, box: sharedKeyedBox.unboxed)
-        case let sharedSingleElementBox as SharedBox<SingleElementBox>:
-            self.init(key: key, box: sharedSingleElementBox.unboxed)
+        case let sharedChoiceBox as SharedBox<ChoiceBox>:
+            self.init(key: key, box: sharedChoiceBox.unboxed)
         case let unkeyedBox as UnkeyedBox:
             self.init(key: key, box: unkeyedBox)
         case let keyedBox as KeyedBox:
             self.init(key: key, box: keyedBox)
-        case let singleElementBox as SingleElementBox:
-            self.init(key: key, box: singleElementBox)
+        case let choiceBox as ChoiceBox:
+            self.init(key: key, box: choiceBox)
         case let simpleBox as SimpleBox:
             self.init(key: key, box: simpleBox)
         case let box:

Sources/XMLCoder/Decoder/XMLChoiceDecodingContainer.swift

@@ -7,6 +7,7 @@
 
 import Foundation
 
+/// Container specialized for decoding XML choice elements.
 struct XMLChoiceDecodingContainer<K: CodingKey>: KeyedDecodingContainerProtocol {
     typealias Key = K
 
@@ -82,130 +83,12 @@ struct XMLChoiceDecodingContainer<K: CodingKey>: KeyedDecodingContainerProtocol
     }
 
     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)\")"
+        guard container.withShared({ $0.key == key.stringValue }), key is XMLChoiceKey else {
+            throw DecodingError.typeMismatch(at: codingPath, expectation: type, reality: container)
         }
-    }
-
-    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.
-                """
-            )
+            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,
@@ -216,39 +99,24 @@ extension XMLChoiceDecodingContainer {
             _ = 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)
-        }
+        return try decoder.unbox(container.withShared { $0.element })
+    }
 
-        if value == nil, let type = type as? AnyOptional.Type,
-            let result = type.init() as? T {
-            return result
-        }
+    public func nestedContainer<NestedKey>(
+        keyedBy _: NestedKey.Type, forKey key: Key
+    ) throws -> KeyedDecodingContainer<NestedKey> {
+        fatalError("Choice elements cannot produce a nested container.")
+    }
 
-        guard let unwrapped = value else {
-            throw DecodingError.valueNotFound(type, DecodingError.Context(
-                codingPath: decoder.codingPath,
-                debugDescription:
-                "Expected \(type) value but found null instead."
-            ))
-        }
-        return unwrapped
+    public func nestedUnkeyedContainer(forKey key: Key) throws -> UnkeyedDecodingContainer {
+        fatalError("Choice elements cannot produce a unkeyed nested container.")
     }
 
-    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
-        )
+    public func superDecoder() throws -> Decoder {
+        fatalError("XMLChoiceDecodingContainer cannot produce a super decoder.")
+    }
+
+    public func superDecoder(forKey key: Key) throws -> Decoder {
+        fatalError("XMLChoiceDecodingContainer cannot produce a super decoder.")
     }
 }

Sources/XMLCoder/Decoder/XMLDecoderImplementation.swift

@@ -127,10 +127,16 @@ 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 {
+        let choiceBox: ChoiceBox?
+        switch topContainer {
+        case let choice as ChoiceBox:
+            choiceBox = choice
+        case let keyed as SharedBox<KeyedBox>:
+            choiceBox = ChoiceBox(keyed.withShared { $0 })
+        default:
+            choiceBox = nil
+        }
+        guard let box = choiceBox else {
             throw DecodingError.typeMismatch(
                 at: codingPath,
                 expectation: [String: Any].self,
@@ -139,7 +145,7 @@ class XMLDecoderImplementation: Decoder {
         }
         let container = XMLChoiceDecodingContainer<Key>(
             referencing: self,
-            wrapping: SharedBox(choiceBox)
+            wrapping: SharedBox(box)
         )
         return KeyedDecodingContainer(container)
     }
@@ -404,21 +410,8 @@ 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
 
@@ -438,8 +431,6 @@ 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 {

Sources/XMLCoder/Decoder/XMLUnkeyedDecodingContainer.swift

@@ -102,7 +102,19 @@ struct XMLUnkeyedDecodingContainer: UnkeyedDecodingContainer {
             unkeyedBox[self.currentIndex]
         }
 
-        let value = try decode(decoder, box)
+        var value: T?
+        if let singleElement = box as? SingleElementBox {
+            do {
+                // Drill down to the element in the case of an nested unkeyed element
+                value = try decode(decoder, singleElement.element)
+            } catch {
+                // Specialize for choice elements
+                value = try decode(decoder, ChoiceBox(key: singleElement.key, element: singleElement.element))
+            }
+        } else {
+            value = try decode(decoder, box)
+        }
+
 
         defer { currentIndex += 1 }