Fix Decoding of Arrays of Empty Elements

Sources/XMLCoder/Decoder/XMLDecoderImplementation.swift

@@ -319,10 +319,16 @@ extension XMLDecoderImplementation {
     }
 
     func unbox(_ box: Box) throws -> String {
-        let stringBox: StringBox = try typedBox(box, for: String.self)
-        let string = stringBox.unboxed
+        do {
+            let stringBox: StringBox = try typedBox(box, for: String.self)
+            return stringBox.unboxed
+        } catch {
+            if box is NullBox {
+                return ""
+            }
+        }
 
-        return string
+        return ""
     }
 
     func unbox(_ box: Box) throws -> Date {

Sources/XMLCoder/Decoder/XMLKeyedDecodingContainer.swift

@@ -79,8 +79,8 @@ struct XMLKeyedDecodingContainer<K: CodingKey>: KeyedDecodingContainerProtocol {
 
         let box = elements.first ?? attributes.first
 
-        if let singleKeyed = box as? SingleKeyedBox {
-            return singleKeyed.element.isNull
+        if box is SingleKeyedBox {
+            return false
         }
 
         return box?.isNull ?? true
@@ -160,14 +160,19 @@ struct XMLKeyedDecodingContainer<K: CodingKey>: KeyedDecodingContainerProtocol {
         decoder.codingPath.append(key)
         defer { decoder.codingPath.removeLast() }
 
-        let elements = container.withShared { keyedBox in
-            keyedBox.elements[key.stringValue]
-        }
+        let elements = container.unboxed.elements[key.stringValue]
 
-        return XMLUnkeyedDecodingContainer(
-            referencing: decoder,
-            wrapping: SharedBox(elements)
-        )
+        if let containsKeyed = elements as? [KeyedBox], let keyed = containsKeyed.first {
+            return XMLUnkeyedDecodingContainer(
+                referencing: decoder,
+                wrapping: SharedBox(keyed.elements.map(SingleKeyedBox.init))
+            )
+        } else {
+            return XMLUnkeyedDecodingContainer(
+                referencing: decoder,
+                wrapping: SharedBox(elements)
+            )
+        }
     }
 
     public func superDecoder() throws -> Decoder {

Sources/XMLCoder/Decoder/XMLUnkeyedDecodingContainer.swift

@@ -105,11 +105,15 @@ struct XMLUnkeyedDecodingContainer: UnkeyedDecodingContainer {
         var value: T?
         if let singleKeyed = box as? SingleKeyedBox {
             do {
-                // Drill down to the element in the case of an nested unkeyed element
-                value = try decode(decoder, singleKeyed.element)
+                value = try decode(decoder, singleKeyed)
             } catch {
-                // Specialize for choice elements
-                value = try decode(decoder, ChoiceBox(key: singleKeyed.key, element: singleKeyed.element))
+                do {
+                    // Drill down to the element in the case of an nested unkeyed element
+                    value = try decode(decoder, singleKeyed.element)
+                } catch {
+                    // Specialize for choice elements
+                    value = try decode(decoder, ChoiceBox(key: singleKeyed.key, element: singleKeyed.element))
+                }
             }
         } else {
             value = try decode(decoder, box)

Tests/XMLCoderTests/BorderTest.swift

@@ -24,6 +24,16 @@ struct Borders: Codable, Equatable {
     }
 }
 
+struct LeftBorders: Codable, Equatable {
+    let items: [LeftBorder?]
+    let count: Int
+
+    enum CodingKeys: String, CodingKey {
+        case items = "border"
+        case count
+    }
+}
+
 struct Border: Codable, Equatable {
     struct Value: Codable, Equatable {
         let style: String?
@@ -48,10 +58,30 @@ struct Border: Codable, Equatable {
     }
 }
 
+struct LeftBorder: Codable, Equatable {
+    struct Value: Codable, Equatable {
+        let style: String?
+    }
+
+    var left: Value
+    var right: Value?
+    var top: Value?
+    var bottom: Value?
+    var diagonal: Value?
+    var horizontal: Value?
+    var vertical: Value?
+}
+
 final class BorderTest: XCTestCase {
     func testSingleEmpty() throws {
         let result = try XMLDecoder().decode(Borders.self, from: xml)
         XCTAssertEqual(result.count, 1)
+        XCTAssertEqual(result.items[0], Border())
+    }
+
+    func testLeftBorder() throws {
+        let result = try XMLDecoder().decode(LeftBorders.self, from: xml)
+        XCTAssertEqual(result.count, 1)
         XCTAssertEqual(result.items[0], nil)
     }
 }

Tests/XMLCoderTests/BreakfastTest.swift

@@ -16,7 +16,6 @@ private let xml = """
     <name>Belgian Waffles</name>
     <price>$5.95</price>
     <description>Two of our famous Belgian Waffles with plenty of real maple syrup</description>
-    <calories></calories>
   </food>
   <food>
     <name>Strawberry Belgian Waffles</name>

Tests/XMLCoderTests/EmptyArrayTest.swift

@@ -0,0 +1,68 @@
+//
+//  EmptyArrayTest.swift
+//  XMLCoderTests
+//
+//  Created by Benjamin Wetherfield on 10/1/19.
+//
+
+import XCTest
+@testable import XMLCoder
+
+struct Empty: Equatable, Codable {}
+
+struct EmptyArray: Equatable, Codable {
+    enum CodingKeys: String, CodingKey { case empties = "empty" }
+    let empties: [Empty]
+}
+
+struct EmptyWrapper: Equatable, Codable {
+    let empty: Empty
+}
+
+struct OptionalEmptyWrapper: Equatable, Codable {
+    let empty: Empty?
+}
+
+private let xml = """
+<container>
+    <empty/>
+    <empty/>
+    <empty/>
+</container>
+"""
+
+private let xmlArray = """
+<container>
+    <empty/>
+    <empty/>
+    <empty/>
+</container>
+"""
+
+private let xmlContainsEmpty = """
+<container>
+    <empty/>
+</container>
+"""
+
+class EmptyArrayTest: XCTestCase {
+    func testEmptyArrayDecode() throws {
+        let decoded = try XMLDecoder().decode([Empty].self, from: xml.data(using: .utf8)!)
+        XCTAssertEqual(decoded, [Empty(), Empty(), Empty()])
+    }
+
+    func testWrappedEmptyArrayDecode() throws {
+        let decoded = try XMLDecoder().decode(EmptyArray.self, from: xmlArray.data(using: .utf8)!)
+        XCTAssertEqual(decoded, EmptyArray(empties: [Empty(), Empty(), Empty()]))
+    }
+
+    func testWrappedEmptyDecode() throws {
+        let decoded = try XMLDecoder().decode(EmptyWrapper.self, from: xmlContainsEmpty.data(using: .utf8)!)
+        XCTAssertEqual(decoded, EmptyWrapper(empty: Empty()))
+    }
+
+    func testWrappedOptionalEmptyDecode() throws {
+        let decoded = try XMLDecoder().decode(OptionalEmptyWrapper.self, from: xmlContainsEmpty.data(using: .utf8)!)
+        XCTAssertEqual(decoded, OptionalEmptyWrapper(empty: Empty()))
+    }
+}

Tests/XMLCoderTests/EmptyElementEmptyStringTests.swift

@@ -9,6 +9,42 @@ import XCTest
 import XMLCoder
 
 class EmptyElementEmptyStringTests: XCTestCase {
+    struct ExplicitNestingContainer: Equatable, Decodable {
+        let things: ContainedArray
+
+        struct ContainedArray: Equatable, Decodable {
+            let thing: [Thing]
+
+            init(_ things: [Thing]) {
+                thing = things
+            }
+        }
+    }
+
+    struct NestingContainer: Equatable, Decodable {
+        let things: [Thing]
+
+        enum CodingKeys: String, CodingKey {
+            case things
+        }
+
+        init(from decoder: Decoder) throws {
+            let container = try decoder.container(keyedBy: CodingKeys.self)
+
+            var things = [Thing]()
+            if var thingContainer = try? container.nestedUnkeyedContainer(forKey: .things) {
+                while !thingContainer.isAtEnd {
+                    things.append(try thingContainer.decode(Thing.self))
+                }
+            }
+            self.things = things
+        }
+
+        init(things: [Thing]) {
+            self.things = things
+        }
+    }
+
     struct Parent: Equatable, Codable {
         let thing: Thing
     }
@@ -58,6 +94,23 @@ class EmptyElementEmptyStringTests: XCTestCase {
         XCTAssertEqual(expected, result)
     }
 
+    func testArrayOfSomeEmptyElementStringDecoding() throws {
+        let xml = """
+        <container>
+            <thing></thing>
+            <thing attribute="x">Non-Empty!</thing>
+            <thing>Non-Empty!</thing>
+        </container>
+        """
+        let expected = [
+            Thing(attribute: nil, value: ""),
+            Thing(attribute: "x", value: "Non-Empty!"),
+            Thing(attribute: nil, value: "Non-Empty!"),
+        ]
+        let result = try XMLDecoder().decode([Thing].self, from: xml.data(using: .utf8)!)
+        XCTAssertEqual(expected, result)
+    }
+
     func testNestedEmptyElementEmptyStringDecoding() throws {
         let xml = """
         <parent>
@@ -68,4 +121,88 @@ class EmptyElementEmptyStringTests: XCTestCase {
         let result = try XMLDecoder().decode(Parent.self, from: xml.data(using: .utf8)!)
         XCTAssertEqual(expected, result)
     }
+
+    func testExplicitlyNestedArrayOfEmptyElementEmptyStringDecoding() throws {
+        let xml = """
+        <container>
+            <things>
+                <thing></thing>
+                <thing attribute="x"></thing>
+                <thing></thing>
+            </things>
+        </container>
+        """
+        let expected = ExplicitNestingContainer(
+            things: .init([
+                Thing(attribute: nil, value: ""),
+                Thing(attribute: "x", value: ""),
+                Thing(attribute: nil, value: ""),
+            ])
+        )
+        let result = try XMLDecoder().decode(ExplicitNestingContainer.self, from: xml.data(using: .utf8)!)
+        XCTAssertEqual(expected, result)
+    }
+
+    func testExplicitlyNestedArrayOfSomeEmptyElementEmptyStringDecoding() throws {
+        let xml = """
+        <container>
+            <things>
+                <thing></thing>
+                <thing attribute="x">Non-Empty!</thing>
+                <thing>Non-Empty!</thing>
+            </things>
+        </container>
+        """
+        let expected = ExplicitNestingContainer(
+            things: .init([
+                Thing(attribute: nil, value: ""),
+                Thing(attribute: "x", value: "Non-Empty!"),
+                Thing(attribute: nil, value: "Non-Empty!"),
+            ])
+        )
+        let result = try XMLDecoder().decode(ExplicitNestingContainer.self, from: xml.data(using: .utf8)!)
+        XCTAssertEqual(expected, result)
+    }
+
+    func testNestedArrayOfEmptyElementEmptyStringDecoding() throws {
+        let xml = """
+        <container>
+            <things>
+                <thing></thing>
+                <thing attribute="x"></thing>
+                <thing></thing>
+            </things>
+        </container>
+        """
+        let expected = NestingContainer(
+            things: [
+                Thing(attribute: nil, value: ""),
+                Thing(attribute: "x", value: ""),
+                Thing(attribute: nil, value: ""),
+            ]
+        )
+        let result = try XMLDecoder().decode(NestingContainer.self, from: xml.data(using: .utf8)!)
+        XCTAssertEqual(expected, result)
+    }
+
+    func testNestedArrayOfSomeEmptyElementEmptyStringDecoding() throws {
+        let xml = """
+        <container>
+            <things>
+                <thing></thing>
+                <thing attribute="x">Non-Empty!</thing>
+                <thing>Non-Empty!</thing>
+            </things>
+        </container>
+        """
+        let expected = NestingContainer(
+            things: [
+                Thing(attribute: nil, value: ""),
+                Thing(attribute: "x", value: "Non-Empty!"),
+                Thing(attribute: nil, value: "Non-Empty!"),
+            ]
+        )
+        let result = try XMLDecoder().decode(NestingContainer.self, from: xml.data(using: .utf8)!)
+        XCTAssertEqual(expected, result)
+    }
 }

Tests/XMLCoderTests/Minimal/NullTests.swift

@@ -52,4 +52,18 @@ class NullTests: XCTestCase {
         let encoded = try encoder.encode(decoded, withRootKey: "container")
         XCTAssertEqual(String(data: encoded, encoding: .utf8)!, xmlString)
     }
+
+    func testNullElement() {
+        let decoder = XMLDecoder()
+
+        let xmlString =
+            """
+            <container>
+                <value/>
+            </container>
+            """
+        let xmlData = xmlString.data(using: .utf8)!
+
+        XCTAssertThrowsError(try decoder.decode(Container.self, from: xmlData))
+    }
 }