allow modelDecoder and errorDecoder to be customized in CodableSerializer. Allow JSONSerialization.ReadingOptions to be specified for SwiftyJSON. Use beta and alpha releases of RxSwift and SwiftyJSON.

Author: DenTelezhkin

Diff for: CHANGELOG.md

@@ -3,6 +3,17 @@ All notable changes to this project will be documented in this file.
 
 # Next
 
+* Added ability to customize `JSONSerialization.ReadingOptions` for `JSONDecodableSerializer`. Unlike previous releases, no options are specified by default(Previously SwiftyJSON used `allowFragments` option).
+
+To have old behavior that allows fragmented json, use:
+
+```swift
+let request = tron.swiftyJSON(readingOptions: .allowFragments).request("path")
+```
+
+* Added ability to customize `JSONDecoder` for `CodableSerializer` for both model parsing and error parsing.
+* `CodableParser` and `JSONDecodableParser` are now classes, that are subclassible.
+
 ## [4.0.0-beta.1](https://github.com/MLSDev/TRON/releases/tag/4.0.0-beta.1)
 
 **This is major release, containing breaking API changes, please read [TRON 4.0 Migration Guide](https://github.com/MLSDev/TRON/blob/master/Docs/4.0%20Migration%20Guide.md)**

Diff for: Cartfile

@@ -1,3 +1,3 @@
 github "Alamofire/Alamofire"
-github "SwiftyJSON/SwiftyJSON"
-github "ReactiveX/RxSwift" 
+github "SwiftyJSON/SwiftyJSON" "4.0.0-alpha.1"
+github "ReactiveX/RxSwift" "4.0.0-beta.0"

Diff for: Cartfile.resolved

@@ -1,4 +1,4 @@
 github "Alamofire/Alamofire" "4.5.1"
-github "Quick/Nimble" "v7.0.1"
-github "ReactiveX/RxSwift" "3.6.1"
-github "SwiftyJSON/SwiftyJSON" "3.1.4"
+github "Quick/Nimble" "v7.0.2"
+github "ReactiveX/RxSwift" "4.0.0-beta.0"
+github "SwiftyJSON/SwiftyJSON" "4.0.0-alpha.1"

Diff for: README.md

@@ -197,6 +197,17 @@ request.perform(withSuccess: { user in
 })
 ```
 
+It's possible to customize decoders for both model and error parsing:
+
+```swift
+let userDecoder = JSONDecoder()
+// Customization for user decoder...
+let errorDecoder = JSONDecoder()
+// Customization for error decoder...
+
+let request : APIRequest<User,MyAppError> = tron.codable(modelDecoder: userDecoder, errorDecoder: errorDecoder).request("me")
+```
+
 ### JSONDecodable
 
 `TRON` provides `JSONDecodable` protocol, that allows us to parse models using [SwiftyJSON](https://github.com/SwiftyJSON/SwiftyJSON):
@@ -243,6 +254,12 @@ You can also use `EmptyResponse` struct in cases where you don't care about actu
 
 Some concepts for response serialization, including array response serializer, are described in [Response Serializers document](https://github.com/MLSDev/TRON/blob/master/Docs/Response%20Serializers.md)
 
+It's possible to customize `JSONSerialization.ReadingOptions`, that are used by `SwiftyJSON.JSON` object while parsing data of the response:
+
+```swift
+let request : APIRequest<String, MyAppError> = tron.swiftyJSON(readingOptions: .allowFragments).request("status")
+```
+
 ## RxSwift
 
 ```swift

Diff for: Source/SwiftyJSONDecodable.swift

@@ -37,17 +37,22 @@ public protocol JSONDecodable  {
 }
 
 /// `JSONDecodable` data response parser
-public struct JSONDecodableParser<Model: JSONDecodable, ErrorModel: JSONDecodable> : ErrorHandlingDataResponseSerializerProtocol
+open class JSONDecodableParser<Model: JSONDecodable, ErrorModel: JSONDecodable> : ErrorHandlingDataResponseSerializerProtocol
 {
     public typealias SerializedError = ErrorModel
 
-    public init() {}
+    public let options: JSONSerialization.ReadingOptions
+    
+    public init(options: JSONSerialization.ReadingOptions) {
+        self.options = options
+    }
 
     /// A closure used by response handlers that takes a request, response, data and error and returns a result.
-    public var serializeResponse: (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Model> {
-        return { request, response, data, error in
-            let json = JSON(data: data ?? Data())
+    open var serializeResponse: (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Model> {
+        return { [weak self] request, response, data, error in
             do {
+                let data = data ?? Data()
+                let json = (try? JSON(data: data, options: self?.options ?? [])) ?? JSON.null
                 let model = try Model.init(json: json)
                 return Result.success(model)
             }
@@ -56,16 +61,15 @@ public struct JSONDecodableParser<Model: JSONDecodable, ErrorModel: JSONDecodabl
             }
         }
     }
-}
-
-extension ErrorHandlingDataResponseSerializerProtocol where SerializedError : JSONDecodable
-{
+    
     /// A closure used by response handlers that takes a parsed result, request, response, data and error and returns a serialized error.
-    public var serializeError: (Result<SerializedObject>?,URLRequest?, HTTPURLResponse?, Data?, Error?) -> APIError<SerializedError> {
-        return { erroredResponse, request, response, data, error in
+    open var serializeError: (Result<SerializedObject>?,URLRequest?, HTTPURLResponse?, Data?, Error?) -> APIError<SerializedError> {
+        return { [weak self] erroredResponse, request, response, data, error in
             let serializationError : Error? = erroredResponse?.error ?? error
             var error = APIError<SerializedError>(request: request, response: response,data: data, error: serializationError)
-            error.errorModel = try? SerializedError.init(json: JSON(data: data ?? Data()))
+            let data = data ?? Data()
+            let json = (try? JSON(data: data, options: self?.options ?? [])) ?? JSON.null
+            error.errorModel = try? SerializedError.init(json: json)
             return error
         }
     }
@@ -77,18 +81,22 @@ public enum JSONDecodableDownloadSerializationError : Error {
 }
 
 /// `JSONDecodable` download response parser
-public struct JSONDecodableDownloadParser<Model: JSONDecodable, ErrorModel: JSONDecodable> : ErrorHandlingDownloadResponseSerializerProtocol
+open class JSONDecodableDownloadParser<Model: JSONDecodable, ErrorModel: JSONDecodable> : ErrorHandlingDownloadResponseSerializerProtocol
 {
     public typealias SerializedError = ErrorModel
 
-    public init() {}
+    public let options: JSONSerialization.ReadingOptions
+    
+    public init(options: JSONSerialization.ReadingOptions) {
+        self.options = options
+    }
 
     /// A closure used by response handlers that takes a request, response, url and error and returns a result.
-    public var serializeResponse: (URLRequest?, HTTPURLResponse?, URL?, Error?) -> Result<Model> {
-        return { request, response, url, error in
+    open var serializeResponse: (URLRequest?, HTTPURLResponse?, URL?, Error?) -> Result<Model> {
+        return { [weak self] request, response, url, error in
             if let url = url, let data = try? Data(contentsOf: url) {
-                let json = JSON(data: data)
                 do {
+                    let json = (try? JSON(data: data, options: self?.options ?? [])) ?? JSON.null
                     let model = try Model.init(json: json)
                     return Result.success(model)
                 }
@@ -99,20 +107,18 @@ public struct JSONDecodableDownloadParser<Model: JSONDecodable, ErrorModel: JSON
             return .failure(JSONDecodableDownloadSerializationError.failedToCreateJSONResponse)
         }
     }
-}
-
-extension ErrorHandlingDownloadResponseSerializerProtocol where SerializedError : JSONDecodable
-{
+    
     /// A closure used by response handlers that takes a parsed result, request, response, url and error and returns a serialized error.
-    public var serializeError: (Result<SerializedObject>?,URLRequest?, HTTPURLResponse?, URL?, Error?) -> APIError<SerializedError> {
-        return { erroredResponse, request, response, url, error in
+    open var serializeError: (Result<SerializedObject>?,URLRequest?, HTTPURLResponse?, URL?, Error?) -> APIError<SerializedError> {
+        return { [weak self] erroredResponse, request, response, url, error in
             let serializationError : Error? = erroredResponse?.error ?? error
             var data : Data?
             if let url = url {
                 data = try? Data(contentsOf: url)
             }
             var error = APIError<SerializedError>(request: request, response: response,data: data, error: serializationError)
-            error.errorModel = try? SerializedError.init(json: JSON(data: data ?? Data()))
+            let json: JSON = (try? JSON(data: data ?? Data(), options: self?.options ?? [])) ?? JSON.null
+            error.errorModel = try? SerializedError.init(json: json)
             return error
         }
     }
@@ -126,9 +132,20 @@ extension JSON : JSONDecodable {
     }
 }
 
-public struct JSONDecodableSerializer
+// Serializer for objects, that conform to `JSONDecodable` protocol.
+open class JSONDecodableSerializer
 {
-    public let tron: TRON
+    // `TRON` instance to be used to send requests
+    let tron: TRON
+    
+    // Reading options to use while calling `JSONSerialization.jsonObject(withData:options:)`
+    open var options : JSONSerialization.ReadingOptions
+    
+    // Creates `JSONDecodableSerializer` with `tron` instance to send requests, and JSON reading `options` to be passed to `JSONSerialization`.
+    public init(tron: TRON, options: JSONSerialization.ReadingOptions = []) {
+        self.tron = tron
+        self.options = options
+    }
 
     /**
      Creates APIRequest with specified relative path and type RequestType.Default.
@@ -137,9 +154,9 @@ public struct JSONDecodableSerializer
 
      - returns: APIRequest instance.
      */
-    public func request<Model:JSONDecodable,ErrorModel:JSONDecodable>(_ path: String) -> APIRequest<Model,ErrorModel>
+    open func request<Model:JSONDecodable,ErrorModel:JSONDecodable>(_ path: String) -> APIRequest<Model,ErrorModel>
     {
-        return tron.request(path, responseSerializer: JSONDecodableParser())
+        return tron.request(path, responseSerializer: JSONDecodableParser(options: options))
     }
 
     /**
@@ -151,9 +168,9 @@ public struct JSONDecodableSerializer
 
      - returns: APIRequest instance.
      */
-    public func upload<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, fromFileAt fileURL: URL) -> UploadAPIRequest<Model,ErrorModel>
+    open func upload<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, fromFileAt fileURL: URL) -> UploadAPIRequest<Model,ErrorModel>
     {
-        return tron.upload(path, fromFileAt: fileURL, responseSerializer: JSONDecodableParser())
+        return tron.upload(path, fromFileAt: fileURL, responseSerializer: JSONDecodableParser(options: options))
     }
 
     /**
@@ -165,9 +182,9 @@ public struct JSONDecodableSerializer
 
      - returns: APIRequest instance.
      */
-    public func upload<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, data: Data) -> UploadAPIRequest<Model,ErrorModel>
+    open func upload<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, data: Data) -> UploadAPIRequest<Model,ErrorModel>
     {
-        return tron.upload(path, data: data, responseSerializer: JSONDecodableParser())
+        return tron.upload(path, data: data, responseSerializer: JSONDecodableParser(options: options))
     }
 
     /**
@@ -179,9 +196,9 @@ public struct JSONDecodableSerializer
 
      - returns: APIRequest instance.
      */
-    public func upload<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, from stream: InputStream) -> UploadAPIRequest<Model,ErrorModel>
+    open func upload<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, from stream: InputStream) -> UploadAPIRequest<Model,ErrorModel>
     {
-        return tron.upload(path, from: stream, responseSerializer: JSONDecodableParser())
+        return tron.upload(path, from: stream, responseSerializer: JSONDecodableParser(options: options))
     }
 
     /**
@@ -193,11 +210,11 @@ public struct JSONDecodableSerializer
 
      - returns: MultipartAPIRequest instance.
      */
-    public func uploadMultipart<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String,
+    open func uploadMultipart<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String,
                                                    formData: @escaping (MultipartFormData) -> Void) -> UploadAPIRequest<Model,ErrorModel>
     {
         return tron.uploadMultipart(path,
-                                    responseSerializer: JSONDecodableParser(),
+                                    responseSerializer: JSONDecodableParser(options: options),
                                     formData: formData)
     }
 
@@ -212,11 +229,11 @@ public struct JSONDecodableSerializer
 
      - seealso: `Alamofire.Request.suggestedDownloadDestination(directory:domain:)` method.
      */
-    public func download<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, to destination: @escaping DownloadRequest.DownloadFileDestination) -> DownloadAPIRequest<Model, ErrorModel>
+    open func download<Model:JSONDecodable, ErrorModel:JSONDecodable>(_ path: String, to destination: @escaping DownloadRequest.DownloadFileDestination) -> DownloadAPIRequest<Model, ErrorModel>
     {
         return tron.download(path,
                              to: destination,
-                             responseSerializer: JSONDecodableDownloadParser())
+                             responseSerializer: JSONDecodableDownloadParser(options: options))
     }
 
     /**
@@ -232,18 +249,27 @@ public struct JSONDecodableSerializer
 
      - seealso: `Alamofire.Request.suggestedDownloadDestination(directory:domain:)` method.
      */
-    public func download<Model:JSONDecodable,ErrorModel:JSONDecodable>(_ path: String, to destination: @escaping DownloadRequest.DownloadFileDestination, resumingFrom: Data) -> DownloadAPIRequest<Model, ErrorModel>
+    open func download<Model:JSONDecodable,ErrorModel:JSONDecodable>(_ path: String, to destination: @escaping DownloadRequest.DownloadFileDestination, resumingFrom: Data) -> DownloadAPIRequest<Model, ErrorModel>
     {
-        return tron.download(path, to: destination, resumingFrom: resumingFrom, responseSerializer: JSONDecodableDownloadParser())
+        return tron.download(path, to: destination, resumingFrom: resumingFrom, responseSerializer: JSONDecodableDownloadParser(options: options))
     }
 }
 
 extension TRON {
+    // Creates `JSONDecodableSerializer` with current `TRON` instance.
     open var swiftyJSON : JSONDecodableSerializer {
         return JSONDecodableSerializer(tron: self)
     }
+    
+    // Creates `CodableSerializer` with current `TRON` instance and specific `options` for `JSONSerialization`.
+    open func swiftyJSON(readingOptions options: JSONSerialization.ReadingOptions) -> JSONDecodableSerializer {
+        return JSONDecodableSerializer(tron: self, options: options)
+    }
 }
 
+// This approach is bad, because it allows any JSONDecodable.Type to be created, not just specific one.
+// See https://github.com/MLSDev/TRON/issues/17 for details
+
 //extension Array : JSONDecodable {
 //    public init(json: JSON) {
 //        self.init(json.arrayValue.flatMap {