Refactor URIDecoder/URIParser to improve handling of the deepObject style

Sources/OpenAPIRuntime/URICoder/Common/URIEncodedNode.swift

@@ -73,6 +73,10 @@ extension URIEncodedNode {
         /// The encoder appended to a node that wasn't an array.
         case appendingToNonArrayContainer
 
+        /// The encoder is trying to mark a container as array, but it's already
+        /// marked as a container of another type.
+        case markingExistingNonArrayContainerAsArray
+
         /// The encoder inserted a value for key into a node that wasn't
         /// a dictionary.
         case insertingChildValueIntoNonContainer
@@ -136,7 +140,7 @@ extension URIEncodedNode {
             // Already an array.
             break
         case .unset: self = .array([])
-        default: throw InsertionError.appendingToNonArrayContainer
+        default: throw InsertionError.markingExistingNonArrayContainerAsArray
         }
     }
 

Sources/OpenAPIRuntime/URICoder/Common/URIParsedTypes.swift

@@ -38,9 +38,6 @@ struct URIParsedKey: Hashable {
 /// A primitive value produced by `URIParser`.
 typealias URIParsedValue = String.SubSequence
 
-/// An array of primitive values produced by `URIParser`.
-typealias URIParsedValueArray = [URIParsedValue]
-
 /// A key-value produced by `URIParser`.
 struct URIParsedPair: Equatable {
 
@@ -55,9 +52,6 @@ struct URIParsedPair: Equatable {
     var value: URIParsedValue
 }
 
-/// An array of key-value pairs produced by `URIParser`.
-typealias URIParsedPairArray = [URIParsedPair]
-
 // MARK: - Extensions
 
 extension URIParsedKey: CustomStringConvertible {

Sources/OpenAPIRuntime/URICoder/Decoding/URIValueFromNodeDecoder+Keyed.swift

@@ -94,15 +94,9 @@ extension URIKeyedDecodingContainer {
 
 extension URIKeyedDecodingContainer: KeyedDecodingContainerProtocol {
 
-    var allKeys: [Key] {
-        do { return try decoder.elementKeysInCurrentDictionary().compactMap { .init(stringValue: $0) } } catch {
-            return []
-        }
-    }
+    var allKeys: [Key] { decoder.elementKeysInCurrentDictionary().compactMap { .init(stringValue: $0) } }
 
-    func contains(_ key: Key) -> Bool {
-        do { return try decoder.containsElementInCurrentDictionary(forKey: key.stringValue) } catch { return false }
-    }
+    func contains(_ key: Key) -> Bool { decoder.containsElementInCurrentDictionary(forKey: key.stringValue) }
 
     var codingPath: [any CodingKey] { decoder.codingPath }
 

Sources/OpenAPIRuntime/URICoder/Decoding/URIValueFromNodeDecoder+Single.swift

@@ -24,6 +24,11 @@ struct URISingleValueDecodingContainer {
 extension URISingleValueDecodingContainer {
 
     /// The underlying value as a single value.
+    ///
+    /// Can be nil if the underlying URI is valid, just doesn't contain any value.
+    ///
+    /// For example, an empty string input into an exploded form decoder (expecting pairs in the form `key=value`)
+    /// would result in a nil returned value.
     var value: URIParsedValue? { get throws { try decoder.currentElementAsSingleValue() } }
 
     /// Returns the value found in the underlying node converted to

Sources/OpenAPIRuntime/URICoder/Decoding/URIValueFromNodeDecoder+Unkeyed.swift

@@ -20,11 +20,14 @@ struct URIUnkeyedDecodingContainer {
     let decoder: URIValueFromNodeDecoder
 
     /// The index of the next item to be decoded.
-    private var index: URIParsedValueArray.Index = 0
+    private(set) var currentIndex: Int
 
     /// Creates a new unkeyed container ready to decode the first key.
     /// - Parameter decoder: The underlying decoder.
-    init(decoder: URIValueFromNodeDecoder) { self.decoder = decoder }
+    init(decoder: URIValueFromNodeDecoder) {
+        self.decoder = decoder
+        self.currentIndex = 0
+    }
 }
 
 extension URIUnkeyedDecodingContainer {
@@ -36,7 +39,7 @@ extension URIUnkeyedDecodingContainer {
     /// - Throws: An error if the container ran out of items.
     private mutating func _decodingNext<R>(in work: () throws -> R) throws -> R {
         guard !isAtEnd else { throw URIValueFromNodeDecoder.GeneralError.reachedEndOfUnkeyedContainer }
-        defer { index += 1 }
+        defer { currentIndex += 1 }
         return try work()
     }
 
@@ -45,7 +48,7 @@ extension URIUnkeyedDecodingContainer {
     /// - Returns: The next value found.
     /// - Throws: An error if the container ran out of items.
     private mutating func _decodeNext() throws -> URIParsedValue {
-        try _decodingNext { [decoder, index] in try decoder.nestedElementInCurrentArray(atIndex: index) }
+        try _decodingNext { [decoder, currentIndex] in try decoder.nestedElementInCurrentArray(atIndex: currentIndex) }
     }
 
     /// Returns the next value converted to the provided type.
@@ -103,9 +106,7 @@ extension URIUnkeyedDecodingContainer: UnkeyedDecodingContainer {
 
     var count: Int? { try? decoder.countOfCurrentArray() }
 
-    var isAtEnd: Bool { index == count }
-
-    var currentIndex: Int { index }
+    var isAtEnd: Bool { currentIndex == count }
 
     var codingPath: [any CodingKey] { decoder.codingPath }