Add a helper method JSONError.withPrefixedCodingPath(_:)

This is intended to be used when using `JSONError`-throwing methods in
a `Decodable` implementation, in order to prepend the `Decoder`'s
`codingPath` to the error.

Author: lilyball

README.md

@@ -265,6 +265,7 @@ Unless you explicitly state otherwise, any contribution intentionally submitted
 #### Development
 
 * Add convenience property `JSONError.path`.
+* Add method `JSONError.withPrefixedCodingPath(_:)` to make it easier to use `JSONError`-throwing methods in a `Decodable` implementation.
 
 #### v3.0.1 (2018-02-18)
 

Sources/JSONError.swift

@@ -62,6 +62,40 @@ public enum JSONError: Error, CustomStringConvertible {
         }
     }
 
+    /// A helper method to modify the error path based on a `Decoder` coding path.
+    ///
+    /// This is meant to be used when using `PMJSON` accessors in a `Decodable.init(from:)`
+    /// implementation. It produces a new `JSONError` that prepends the given coding path to the
+    /// error's existing path. This can be convenient when writing a `Decodable` adapter for an
+    /// existing type that already can initialize itself from a `JSONObject. For example:
+    ///
+    ///     init(from decoder: Decoder) throws {
+    ///         var container = try decoder.singleValueContainer()
+    ///         let object = try container.decode(JSONObject.self)
+    ///         do {
+    ///             try self.init(json: object)
+    ///         } catch let error as JSONError {
+    ///             throw error.withPrefixedCodingPath(decoder.codingPath)
+    ///         }
+    ///     }
+    ///
+    /// - Parameter codingPath: A coding path. This should be taken from `decoder.codingPath`.
+    /// - Returns: A new `JSONError` that matches the receiver but with a new path.
+    public func withPrefixedCodingPath(_ codingPath: [CodingKey]) -> JSONError {
+        var prefix = ""
+        for key in codingPath {
+            if let intValue = key.intValue {
+                prefix += "[\(intValue)]"
+            } else {
+                if !prefix.isEmpty {
+                    prefix += "."
+                }
+                prefix += key.stringValue
+            }
+        }
+        return prefix.isEmpty ? self : withPrefix(prefix)
+    }
+    
     fileprivate func withPrefix(_ prefix: String) -> JSONError {
         func prefixPath(_ path: String?, with prefix: String) -> String {
             guard let path = path, !path.isEmpty else { return prefix }

Tests/PMJSONTests/SwiftCodableTests.swift

@@ -122,6 +122,70 @@ final class SwiftDecodableTests: XCTestCase {
     }
 }
 
+final class SwiftMiscellaneousCodableTests: XCTestCase {
+    private enum TestKey: CodingKey {
+        case int(Int)
+        case string(String)
+        
+        init?(intValue: Int) {
+            self = .int(intValue)
+        }
+        
+        init?(stringValue: String) {
+            self = .string(stringValue)
+        }
+        
+        var intValue: Int? {
+            switch self {
+            case .int(let x): return x
+            case .string: return nil
+            }
+        }
+        
+        var stringValue: String {
+            switch self {
+            case .int(let x): return String(x)
+            case .string(let s): return s
+            }
+        }
+    }
+    
+    func testErrorWithEmptyPrefixedCodingPath() {
+        let error = JSONError.missingOrInvalidType(path: "x", expected: .required(.number), actual: nil)
+        XCTAssertEqual(error.withPrefixedCodingPath([]).path, "x")
+    }
+    
+    func testErrorWithSingleStringPrefixedCodingPath() {
+        let error = JSONError.outOfRangeInt64(path: "x", value: 32760, expected: Int8.self)
+        XCTAssertEqual(error.withPrefixedCodingPath([TestKey.string("foo")]).path, "foo.x")
+    }
+    
+    func testErrorWithMultipleStringPrefixedCodingPath() {
+        let error = JSONError.outOfRangeDouble(path: "[1]", value: 32760, expected: Int8.self)
+        XCTAssertEqual(error.withPrefixedCodingPath([TestKey.string("foo"), TestKey.string("bar")]).path, "foo.bar[1]")
+    }
+    
+    func testErrorWithSingleIntPrefixedCodingPath() {
+        let error = JSONError.outOfRangeDecimal(path: "x", value: 32760, expected: Int8.self)
+        XCTAssertEqual(error.withPrefixedCodingPath([TestKey.int(42)]).path, "[42].x")
+    }
+    
+    func testErrorWithMultipleIntPrefixedCodingPath() {
+        let error = JSONError.missingOrInvalidType(path: "x", expected: .required(.number), actual: nil)
+        XCTAssertEqual(error.withPrefixedCodingPath([TestKey.int(2), TestKey.int(42)]).path, "[2][42].x")
+    }
+    
+    func testErrorWithMixedPrefixedCodignPath() {
+        let error = JSONError.missingOrInvalidType(path: "x", expected: .required(.number), actual: nil)
+        XCTAssertEqual(error.withPrefixedCodingPath([TestKey.string("foo"), TestKey.int(42), TestKey.string("bar")]).path, "foo[42].bar.x")
+    }
+    
+    func testErrorWithNilPathPrefixedCodingPath() {
+        let error = JSONError.missingOrInvalidType(path: nil, expected: .required(.number), actual: nil)
+        XCTAssertEqual(error.withPrefixedCodingPath([TestKey.string("foo"), TestKey.string("bar")]).path, "foo.bar")
+    }
+}
+
 /// Wrapper to make JSONEncoder/JSONDecoder happy about encoding values.
 private struct ValueWrapper: Codable {
     let value: JSON