Support Array Of Fields For Custom Transformation

Returns `nil` if key doesn't exist or transformation for found value throws.

Sources/Mapper.swift

@@ -346,6 +346,23 @@ public struct Mapper {
         return (try? transformation(try self.JSONFromField(field))).flatMap { $0 }
     }
 
+    /// Get an optional typed value from the given fields by using the given transformation
+    ///
+    /// - parameter fields:         The array of fields to retrieve from the source data, can be an empty
+    ///                             string to return the entire data set
+    /// - parameter transformation: The transformation function used to create the expected value
+    ///
+    /// - returns: The value of type T for the given field, if the transformation function doesn't throw
+    ///            otherwise nil
+    public func optionalFrom<T>(_ fields: [String], transformation: (Any) throws -> T?) -> T? {
+        for field in fields {
+            if let value = try? transformation((try self.JSONFromField(field))) {
+                return value
+            }
+        }
+        return nil
+    }
+
     // MARK: - Private
 
     /// Get the object for a given field. If an empty string is passed, return the entire data source. This

Tests/MapperTests/CustomTransformationTests.swift

@@ -75,4 +75,52 @@ final class CustomTransformationTests: XCTestCase {
             XCTFail("Shouldn't have failed to create Test")
         }
     }
+
+    func testOptionalCustomTransformationArrayOfKeys() {
+        struct Test: Mappable {
+            let value: Int?
+            init(map: Mapper) throws {
+                value = map.optionalFrom(["a", "b"], transformation: { thing in
+                    if let a = thing as? Int {
+                        return a + 1
+                    }
+                    throw MapperError.customError(field: nil, message: "")
+                })
+            }
+        }
+
+        let test = try? Test(map: Mapper(JSON: ["a": "##", "b": 1]))
+        XCTAssertEqual(test?.value, 2)
+    }
+
+    func testOptionalCustomTransformationArrayOfKeysFails() {
+        struct Test: Mappable {
+            let value: Int?
+            init(map: Mapper) throws {
+                value = map.optionalFrom(["a", "b"], transformation: { thing in
+                    throw MapperError.customError(field: nil, message: "")
+                })
+            }
+        }
+
+        let test = try? Test(map: Mapper(JSON: ["a": "##", "b": 1]))
+        XCTAssertNil(test?.value)
+    }
+
+    func testOptionalCustomTransformationArrayOfKeysReturnsNil() {
+        struct Test: Mappable {
+            let value: Int?
+            init(map: Mapper) throws {
+                value = map.optionalFrom(["a", "b"], transformation: { thing in
+                    if let a = thing as? Int {
+                        return a + 1
+                    }
+                    throw MapperError.customError(field: nil, message: "")
+                })
+            }
+        }
+
+        let test = try? Test(map: Mapper(JSON: [:]))
+        XCTAssertNil(test?.value)
+    }
 }