Change the return type of map(JSON:) to optional, not IUO, for better type safety

`mapArray()` and `mapDictionary()` now filter out nil values from their entires.

Author: ikesyo

ObjectMapper/Core/Mapper.swift

@@ -150,7 +150,7 @@ public final class Mapper<N: Mappable> {
 	/**
 	* Maps a JSON dictionary to an object that conforms to Mappable
 	*/
-	public func map(JSON: [String : AnyObject]) -> N! {
+	public func map(JSON: [String : AnyObject]) -> N? {
 		let map = Map(mappingType: .fromJSON, JSONDictionary: JSON)
 		let object = N(map)
 		return object
@@ -191,10 +191,13 @@ public final class Mapper<N: Mappable> {
 	/**
 	* Maps an array of JSON dictionary to an array of object that conforms to Mappable
 	*/
-	public func mapArray(JSON: [[String : AnyObject]]) -> [N] {
-		return JSON.map {
+	public func mapArray(JSONArray: [[String : AnyObject]]) -> [N] {
+		return JSONArray.reduce([]) { (var values, JSON) in
 			// map every element in JSON array to type N
-			return self.map($0)
+			if let value = self.map(JSON) {
+				values.append(value)
+			}
+			return values
 		}
 	}
 
@@ -213,9 +216,14 @@ public final class Mapper<N: Mappable> {
 	* Maps a JSON dictionary of dictionaries to a dictionary of objects that conform to Mappable.
 	*/
 	public func mapDictionary(JSON: [String : [String : AnyObject]]) -> [String : N] {
-		return JSON.map { key, value in
+		return reduce(JSON, [String: N]()) { (var values, element) in
+			let (key, value) = element
+
 			// map every value in dictionary to type N
-			return (key, self.map(value))
+			if let newValue = self.map(value) {
+				values[key] = newValue
+			}
+			return values
 		}
 	}
 

ObjectMapperTests/BasicTypesTestsFromJSON.swift

@@ -253,7 +253,8 @@ class BasicTypesTestsFromJSON: XCTestCase {
 		let json: [String: [String: AnyObject]] = ["dictStringString":["string": "string"], "dictStringBool":["string": false], "dictStringInt":["string": 1], "dictStringDouble":["string": 1.1], "dictStringFloat":["string": 1.2]]
 
 		let mapper = Mapper<TestCollectionOfPrimitives>()
-		let testSet = mapper.map(json)
+		let testSet: TestCollectionOfPrimitives! = mapper.map(json)
+		expect(testSet).notTo(beNil())
 
 		expect(testSet.dictStringString).notTo(beEmpty())
 		expect(testSet.dictStringInt).notTo(beEmpty())

ObjectMapperTests/CustomTransformTests.swift

@@ -33,8 +33,8 @@ class CustomTransformTests: XCTestCase {
 		let JSON = mapper.toJSON(transforms)
 		let parsedTransforms = mapper.map(JSON)
 		expect(parsedTransforms).notTo(beNil())
-		expect(parsedTransforms.date).to(equal(transforms.date))
-		expect(parsedTransforms.dateOpt).to(equal(transforms.dateOpt))
+		expect(parsedTransforms?.date).to(equal(transforms.date))
+		expect(parsedTransforms?.dateOpt).to(equal(transforms.dateOpt))
 	}
 
 	func testISO8601DateTransform() {
@@ -45,27 +45,28 @@ class CustomTransformTests: XCTestCase {
 
 		let parsedTransforms = mapper.map(JSON)
 		expect(parsedTransforms).notTo(beNil())
-		expect(parsedTransforms.ISO8601Date).to(equal(transforms.ISO8601Date))
-		expect(parsedTransforms.ISO8601DateOpt).to(equal(transforms.ISO8601DateOpt))
+		expect(parsedTransforms?.ISO8601Date).to(equal(transforms.ISO8601Date))
+		expect(parsedTransforms?.ISO8601DateOpt).to(equal(transforms.ISO8601DateOpt))
 	}
 
 	func testISO8601DateTransformWithInvalidInput() {
 		var JSON: [String: AnyObject] = ["ISO8601Date": ""]
 		let transforms = mapper.map(JSON)
 
-		expect(transforms.ISO8601DateOpt).to(beNil())
+		expect(transforms?.ISO8601DateOpt).to(beNil())
 
 		JSON["ISO8601Date"] = "incorrect format"
 
 		let transforms2 = mapper.map(JSON)
 
-		expect(transforms2.ISO8601DateOpt).to(beNil())
+		expect(transforms2?.ISO8601DateOpt).to(beNil())
 	}
 
 	func testCustomFormatDateTransform(){
 		let dateString = "2015-03-03T02:36:44"
 		var JSON: [String: AnyObject] = ["customFormateDate": dateString]
-		let transform = mapper.map(JSON)
+		let transform: Transforms! = mapper.map(JSON)
+		expect(transform).notTo(beNil())
 
 		let JSONOutput = mapper.toJSON(transform)
 
@@ -77,7 +78,7 @@ class CustomTransformTests: XCTestCase {
 		var JSON: [String: AnyObject] = ["intWithString": "\(intValue)"]
 		let transforms = mapper.map(JSON)
 
-		expect(transforms.intWithString).to(equal(intValue))
+		expect(transforms?.intWithString).to(equal(intValue))
 	}
 
 	func testInt64MaxValue() {
@@ -88,7 +89,7 @@ class CustomTransformTests: XCTestCase {
 
 		let parsedTransforms = mapper.map(JSON)
 		expect(parsedTransforms).notTo(beNil())
-		expect(parsedTransforms.int64Value).to(equal(transforms.int64Value))
+		expect(parsedTransforms?.int64Value).to(equal(transforms.int64Value))
 	}
 
 	func testURLTranform() {
@@ -100,17 +101,17 @@ class CustomTransformTests: XCTestCase {
 
 		let parsedTransforms = mapper.map(JSON)
 		expect(parsedTransforms).notTo(beNil())
-		expect(parsedTransforms.URL).to(equal(transforms.URL))
-		expect(parsedTransforms.URLOpt).to(equal(transforms.URLOpt))
+		expect(parsedTransforms?.URL).to(equal(transforms.URL))
+		expect(parsedTransforms?.URLOpt).to(equal(transforms.URLOpt))
 	}
 
 	func testEnumTransform() {
 		var JSON: [String: AnyObject] = ["firstImageType" : "cover", "secondImageType" : "thumbnail"]
 		let transforms = mapper.map(JSON)
 
 		let imageType = Transforms.ImageType.self
-		expect(transforms.firstImageType).to(equal(imageType.Cover))
-		expect(transforms.secondImageType).to(equal(imageType.Thumbnail))
+		expect(transforms?.firstImageType).to(equal(imageType.Cover))
+		expect(transforms?.secondImageType).to(equal(imageType.Thumbnail))
 	}
 }
 

ObjectMapperTests/NestedKeysTests.swift

@@ -59,9 +59,12 @@ class NestedKeysTests: XCTestCase {
 
 		let mapper = Mapper<NestedKeys>()
 
-		let value = mapper.map(JSON)
+		let value: NestedKeys! = mapper.map(JSON)
+		expect(value).notTo(beNil())
+
 		let JSONFromValue = mapper.toJSON(value)
-		let valueFromParsedJSON = mapper.map(JSONFromValue)
+		let valueFromParsedJSON: NestedKeys! = mapper.map(JSONFromValue)
+		expect(valueFromParsedJSON).notTo(beNil())
 
 		expect(value.int64).to(equal(valueFromParsedJSON.int64))
 		expect(value.bool).to(equal(valueFromParsedJSON.bool))

ObjectMapperTests/ObjectMapperTests.swift

@@ -29,10 +29,11 @@ class ObjectMapperTests: XCTestCase {
 		let mapper = Mapper<Immutable>()
 		let JSON = [ "prop1": "Immutable!", "prop2": 255, "prop3": true ]
 
-		let immutable = mapper.map(JSON)
-		expect(immutable.prop1).to(equal("Immutable!"))
-		expect(immutable.prop2).to(equal(255))
-		expect(immutable.prop3).to(equal(true))
+		let immutable: Immutable! = mapper.map(JSON)
+		expect(immutable).notTo(beNil())
+		expect(immutable?.prop1).to(equal("Immutable!"))
+		expect(immutable?.prop2).to(equal(255))
+		expect(immutable?.prop3).to(equal(true))
 
 		let JSON2 = [ "prop1": "prop1", "prop2": NSNull() ]
 		let immutable2 = mapper.map(JSON2)
@@ -343,8 +344,8 @@ class ObjectMapperTests: XCTestCase {
 		let json = Mapper().toJSON(object)
 		let parsedObject = Mapper<Subclass>().map(json)
 
-		expect(object.base).to(equal(parsedObject.base))
-		expect(object.sub).to(equal(parsedObject.sub))
+		expect(object.base).to(equal(parsedObject?.base))
+		expect(object.sub).to(equal(parsedObject?.sub))
 	}
 
 	func testGenericSubclass() {
@@ -355,8 +356,8 @@ class ObjectMapperTests: XCTestCase {
 		let json = Mapper().toJSON(object)
 		let parsedObject = Mapper<GenericSubclass<String>>().map(json)
 
-		expect(object.base).to(equal(parsedObject.base))
-		expect(object.sub).to(equal(parsedObject.sub))
+		expect(object.base).to(equal(parsedObject?.base))
+		expect(object.sub).to(equal(parsedObject?.sub))
 	}
 
 	func testSubclassWithGenericArrayInSuperclass() {