rewrite parseable protocol with associated types, inject response and error parsers everywhere

Author: DenTelezhkin

CHANGELOG.md

@@ -1,6 +1,14 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## Next
+
+* `Parseable` protocol was rewritten from generic static func to having associatedtype and a func inside. This is done to broaden support for any kinds of mappers. Good example would be CoreData objects creation, that requires different contexts for background threads, and was difficult to implement using old syntax.
+* All `TRON` request methods now contain obligatory `responseParser` and `errorParser` properties, that define, how response and errors are parsed.
+* `APIStub` objects are now using `responseParser` and `errorParser` of the request, and therefore have been entirely rewritten with new properties, that accept `Data` objects instead of directly setting result.
+* `JSONDecodable` protocol now provides convenience methods to use with `TRON` and `APIRequest`, that work the same as before, therefore almost maintaining backwards code compatibility for `TRON/SwiftyJSON` subspec.
+* `ErrorBuilder` class was removed.
+
 ## [2.0.0-beta.1](https://github.com/MLSDev/TRON/releases/tag/2.0.0-beta.1)
 
 `TRON` 2.0 is supported on iOS 9.0, macOS 10.11 and higher due to Alamofire.framework required versions. Read [migration guide](/Docs/2.0 Migration Guide.md) for overview of API changes.

Carthage/Checkouts/Nimble

@@ -28,7 +28,7 @@ import Alamofire
 /**
  `APIRequest` encapsulates request creation logic, stubbing options, and response/error parsing. 
  */
-open class APIRequest<Model: Parseable, ErrorModel: Parseable>: BaseRequest<Model,ErrorModel> {
+open class APIRequest<Model, ErrorModel>: BaseRequest<Model,ErrorModel> {
 
     override func alamofireRequest(from manager: SessionManager) -> Request {
             return manager.request(urlBuilder.url(forPath: path), method: method,

Source/Core/APIRequest.swift

@@ -40,32 +40,57 @@ public extension APIStub {
     public func buildModel(fromFileNamed fileName: String, inBundle bundle: Bundle = Bundle.main) {
         if let filePath = bundle.path(forResource: fileName as String, ofType: nil)
         {
-            guard let data = try? Data(contentsOf: URL(fileURLWithPath: filePath)) else {
-                    print("failed building response model from file: \(filePath)")
-                return
-            }
-            model = try? Model.parse(data)
+            successData = try? Data(contentsOf: URL(fileURLWithPath: filePath))
         }
     }
 }
 
 /**
  `APIStub` instance that is used to represent stubbed successful or unsuccessful response value.
  */
-open class APIStub<Model: Parseable, ErrorModel: Parseable> {
+open class APIStub<Model, ErrorModel> {
 
     /// Should the stub be successful. By default - true
     open var successful = true
 
+    /// Data to be passed to successful stub
+    open var successData : Data?
+    
+    /// Error to be passed into request's `errorParser` if stub is failureful.
+    open var errorRequest : URLRequest?
+    
+    /// HTTP response to be passed into request's `errorParser` if stub is failureful.
+    open var errorResponse: HTTPURLResponse?
+    
+    /// Error Data to be passed into request's `errorParser` if stub is failureful.
+    open var errorData : Data?
+    
+    /// Loading error to be passed into request's `errorParser` if stub is failureful.
+    open var loadingError : Error?
+    
     /// Response model for successful API stub
-    open var model : Model?
+    open var model : Model? {
+        guard let data = successData else { return nil }
+        guard let request = request else { return nil}
+        return try? request.responseParser(data)
+    }
 
     /// Error model for unsuccessful API stub
-    open var error: APIError<ErrorModel>?
+    open var error: APIError<ErrorModel>? {
+        return request?.errorParser(errorRequest, errorResponse, errorData, loadingError)
+    }
 
     /// Delay before stub is executed
     open var stubDelay = 0.1
 
+    /// Weak request property, that is used when executing stubs using request `errorParser` or `responseParser`.
+    open weak var request: BaseRequest<Model,ErrorModel>?
+    
+    /// Creates `APIStub`, and configures it for `request`.
+    init(request: BaseRequest<Model,ErrorModel>) {
+        self.request = request
+    }
+    
     /**
      Stub current request.
 
@@ -74,12 +99,18 @@ open class APIStub<Model: Parseable, ErrorModel: Parseable> {
      - parameter failureBlock: Failure block to be executed if request fails. Nil by default.
      */
     open func performStub(withSuccess successBlock: ((Model) -> Void)? = nil, failure failureBlock: ((APIError<ErrorModel>) -> Void)? = nil) {
-        if let model = model, successful {
-            delay(stubDelay) {
+        delay(stubDelay) { [weak self] in
+            if self?.successful ?? false {
+                guard let model = self?.model else {
+                    print("Attempting to stub successful request, however successData is nil")
+                    return
+                }
                 successBlock?(model)
-            }
-        } else if let error = error {
-            delay(stubDelay) {
+            } else {
+                guard let error = self?.error else {
+                    print("Attempting to stub failed request, however apiStub does not produce error")
+                    return
+                }
                 failureBlock?(error)
             }
         }
@@ -91,33 +122,48 @@ open class APIStub<Model: Parseable, ErrorModel: Parseable> {
      - parameter completionBlock: Completion block to be executed when request is stubbed.
      */
     open func performStub(withCompletion completionBlock : @escaping ((Alamofire.DataResponse<Model>) -> Void)) {
-        delay(stubDelay) {
+        delay(stubDelay) { [weak self] in
             let result : Alamofire.Result<Model>
-            if let model = self.model, self.successful {
+            if self?.successful ?? false {
+                guard let model = self?.model else {
+                    print("Attempting to stub successful request, however successData is nil")
+                    return
+                }
                 result = Result.success(model)
-            } else if let error = self.error {
-                result = Result.failure(error)
             } else {
-                let error : APIError<ErrorModel> = APIError(request: nil, response: nil, data: nil, error: nil)
+                guard let error = self?.error else {
+                    print("Attempting to stub failed request, however apiStub does not produce error")
+                    return
+                }
                 result = Result.failure(error)
             }
             let response: Alamofire.DataResponse<Model> = Alamofire.DataResponse(request: nil, response: nil, data: nil, result: result)
             completionBlock(response)
         }
     }
 
+    /**
+     Stub current download request.
+     
+     - parameter completionBlock: Completion block to be executed when request is stubbed.
+     */
     open func performStub(withCompletion completionBlock : @escaping ((Alamofire.DownloadResponse<Model>) -> Void)) {
-        delay(stubDelay) {
+        delay(stubDelay) { [weak self] in
             let result : Alamofire.Result<Model>
-            if let model = self.model, self.successful {
+            if self?.successful ?? false {
+                guard let model = self?.model else {
+                    print("Attempting to stub successful download request, however successData is nil")
+                    return
+                }
                 result = Result.success(model)
-            } else if let error = self.error {
-                result = Result.failure(error)
             } else {
-                let error : APIError<ErrorModel> = APIError(request: nil, response: nil, data: nil, error: nil)
+                guard let error = self?.error else {
+                    print("Attempting to stub failed download request, however apiStub does not produce error")
+                    return
+                }
                 result = Result.failure(error)
             }
-            let response: Alamofire.DownloadResponse<Model> = DownloadResponse(request: nil, response: nil, temporaryURL: nil, destinationURL: nil, resumeData: nil, result: result)
+            let response: DownloadResponse<Model> = DownloadResponse(request: nil, response: nil, temporaryURL: nil, destinationURL: nil, resumeData: nil, result: result)
             completionBlock(response)
         }
     }

Source/Core/APIStub.swift

@@ -84,7 +84,13 @@ public protocol TronDelegate: class {
 }
 
 /// Base class, that contains common functionality, extracted from `APIRequest` and `MultipartAPIRequest`.
-open class BaseRequest<Model: Parseable, ErrorModel: Parseable> {
+open class BaseRequest<Model, ErrorModel> {
+    
+    /// Serializes Data into Model
+    public typealias ResponseParser = (Data) throws -> Model
+    
+    /// Serializes received failed response into APIError<ErrorModel> object
+    public typealias ErrorParser = (_ request: URLRequest?, _ response: HTTPURLResponse?, _ data: Data?, _ error: Error?) -> APIError<ErrorModel>
 
     /// Relative path of current request
     open let path: String
@@ -111,14 +117,17 @@ open class BaseRequest<Model: Parseable, ErrorModel: Parseable> {
     /// URL builder for current request
     open var urlBuilder: URLBuildable
 
-    /// Error builder for current request
-    open var errorBuilder = ErrorBuilder<ErrorModel>()
+    /// Serializes Data into Model
+    open var responseParser : ResponseParser
+    
+    /// Serializes received failed response into APIError<ErrorModel> object
+    open var errorParser : ErrorParser
 
     /// Is stubbing enabled for current request?
     open var stubbingEnabled = false
 
     /// API stub to be used when stubbing this request
-    open var apiStub = APIStub<Model, ErrorModel>()
+    lazy open var apiStub : APIStub<Model, ErrorModel> = { return APIStub(request: self) }()
 
     /// Queue, used for processing response, received from the server. Defaults to TRON.processingQueue queue.
     open var processingQueue : DispatchQueue
@@ -133,7 +142,7 @@ open class BaseRequest<Model: Parseable, ErrorModel: Parseable> {
     open var plugins : [Plugin] = []
 
     /// Creates `BaseRequest` instance, initialized with several `TRON` properties.
-    public init(path: String, tron: TRON) {
+    public init(path: String, tron: TRON, responseParser: @escaping ResponseParser, errorParser: @escaping ErrorParser) {
         self.path = path
         self.tronDelegate = tron
         self.stubbingEnabled = tron.stubbingEnabled
@@ -142,6 +151,8 @@ open class BaseRequest<Model: Parseable, ErrorModel: Parseable> {
         self.processingQueue = tron.processingQueue
         self.resultDeliveryQueue = tron.resultDeliveryQueue
         self.parameterEncoding = tron.parameterEncoding
+        self.responseParser = responseParser
+        self.errorParser = errorParser
         self.apiStub.successful = tron.stubbingShouldBeSuccessful
     }
 
@@ -156,18 +167,15 @@ open class BaseRequest<Model: Parseable, ErrorModel: Parseable> {
                     $0.requestDidReceiveResponse(urlRequest, response,data,error)
                 }
             })
-            guard error == nil else {
-                return .failure(self.errorBuilder.buildErrorFromRequest(urlRequest, response: response, data: data, error: error))
+            if let error = error {
+                return .failure(self.errorParser(urlRequest, response, data, error))
             }
             let model: Model
-            do {
-                model = try Model.parse(data ?? Data())
+            do { try model = self.responseParser(data ?? Data()) }
+            catch {
+                return .failure(self.errorParser(urlRequest, response, data, error))
             }
-            catch let parsingError {
-                return .failure(self.errorBuilder.buildErrorFromRequest(urlRequest, response: response, data: data, error: parsingError))
-            }
-            return .success(model)
-        }
+            return .success(model)        }
     }
 
     internal func performStub(success: ((Model) -> Void)?, failure: ((APIError<ErrorModel>) -> Void)?) -> Bool {

Source/Core/BaseRequest.swift

@@ -36,14 +36,16 @@ public enum DownloadRequestType {
 /**
  `DownloadAPIRequest` encapsulates download request creation logic, stubbing options, and response/error parsing.
  */
-open class DownloadAPIRequest<ErrorModel: Parseable>: BaseRequest<EmptyResponse,ErrorModel> {
+open class DownloadAPIRequest<ErrorModel>: BaseRequest<EmptyResponse,ErrorModel> {
 
     let type : DownloadRequestType
 
     // Creates `DownloadAPIRequest` with specified `type`, `path` and configures it with to be used with `tron`.
-    public init(type: DownloadRequestType, path: String, tron: TRON) {
+    public init(type: DownloadRequestType, path: String, tron: TRON, errorParser: @escaping ErrorParser) {
         self.type = type
-        super.init(path: path, tron: tron)
+        super.init(path: path, tron: tron,
+                   responseParser: { try EmptyResponseParser().parse($0)},
+                   errorParser: errorParser)
     }
 
     override func alamofireRequest(from manager: SessionManager) -> Request? {
@@ -101,7 +103,7 @@ open class DownloadAPIRequest<ErrorModel: Parseable>: BaseRequest<EmptyResponse,
                 }
             })
             guard error == nil else {
-                return .failure(self.errorBuilder.buildErrorFromRequest(urlRequest, response: response, data: nil, error: error))
+                return .failure(self.errorParser(urlRequest, response, nil,  error))
             }
             return .success(EmptyResponse())
         }

Source/Core/DownloadAPIRequest.swift

@@ -26,12 +26,10 @@
 import Foundation
 
 /// Struct, that can be used as Model generic constraint in cases, where you don't care about response type.
-public struct EmptyResponse : Parseable {
-    
-    public static func parse<T : Parseable>(_ data: Data) throws -> T {
-        guard let type = T.self as? EmptyResponse.Type else {
-            throw ParsingError.wrongType
-        }
-        return type.init() as! T
+public struct EmptyResponse  {}
+
+public struct EmptyResponseParser : Parseable {
+    public func parse(_ data: Data) throws -> EmptyResponse {
+        return EmptyResponse()
     }
 }

Source/Core/EmptyResponse.swift

@@ -25,34 +25,8 @@
 
 import Foundation
 
-/**
- `ErrorBuilder` class is used to build error object from unsuccessful API requests.
- */
-open class ErrorBuilder<U:Parseable>
-{
-    /// initialize default error builder
-    public init() {}
-    
-    /**
-     Build concrete APIError instance.
-     
-     - parameter request: URLRequest that was unsuccessful
-     
-     - parameter response: response received from web service
-     
-     - parameter data: data, contained in response
-     
-     - error: Error instance, created by Foundation Loading System or Alamofire.
-     
-     - returns APIError instance
-     */
-    open func buildErrorFromRequest(_ request : URLRequest?, response: HTTPURLResponse?, data: Data?, error: Error?) -> APIError<U> {
-        return APIError<U>(request: request, response: response, data: data, error: error)
-    }
-}
-
 /// `APIError<T>` is used as a generic wrapper for all kinds of APIErrors.
-public struct APIError<T:Parseable> : Error {
+public struct APIError<T> : Error {
 
     /// URLRequest that was unsuccessful
     public let request : URLRequest?
@@ -86,7 +60,6 @@ public struct APIError<T:Parseable> : Error {
         self.response = response
         self.data = data
         self.error = error
-        self.errorModel = try? T.parse(data ?? Data())
     }
 
     /**

Source/Core/ErrorBuilder.swift

@@ -29,21 +29,8 @@ import Foundation
  Protocol, that allows creating parsed models from Data, received in request response.
  */
 public protocol Parseable {
+    associatedtype ModelType
 
     /// Parse `data`, creating `Parseable` model.
-    static func parse<T:Parseable>(_ data: Data) throws -> T
-}
-
-/// Enum with possible parsing errors.
-public enum ParsingError : Error
-{
-    /**
-     Error is thrown, if `Parseable` object does not satisfy requirement of current parser
-     
-     For example, `JSONDecodable` tries to decode object that is `Parseable` but not `JSONDecodable`, it raises following error.
-     */
-    case wrongType
-    
-    /// `Parseable` protocol throwed an error while creating `Parseable` model
-    case constructionFailed
+    func parse(_ data: Data) throws -> ModelType
 }