Replace PromiseKit with async/await api

Author: kolyasev

Cartfile

@@ -6,10 +6,10 @@ import PackageDescription
 let package = Package(
     name: "SwiftJSONRPC",
     platforms: [
-        .macOS(.v10_12),
-        .iOS(.v10),
-        .tvOS(.v10),
-        .watchOS(.v3)
+        .macOS(.v10_15),
+        .iOS(.v13),
+        .tvOS(.v13),
+        .watchOS(.v6)
     ],
     products: [
         .library(
@@ -18,12 +18,11 @@ let package = Package(
         ),
     ],
     dependencies: [
-        .package(url: "https://github.com/mxcl/PromiseKit.git", from: "6.13.1")
     ],
     targets: [
         .target(
             name: "SwiftJSONRPC",
-            dependencies: ["PromiseKit"],
+            dependencies: [],
             path: "Sources"
         ),
         .testTarget(

Cartfile.resolved

@@ -11,15 +11,14 @@
 
 ```swift
 import SwiftJSONRPC
-import PromiseKit
 
 class UserService: RPCService {
-    func vote(rating: Int) -> Promise<Int> {
-        return invoke("vote", params: ["rating": rating])
+    func vote(rating: Int) async throws -> Int {
+        return try await invoke("vote", params: ["rating": rating])
     }
-    
-    func create(name: String) -> Promise<UserModel> {
-        return invoke("create", params: ["name": name])
+
+    func create(name: String) async throws -> UserModel {
+        return try await invoke("create", params: ["name": name])
     }
 
     // And other JSON-RPC methods
@@ -39,21 +38,7 @@ let client = RPCClient(url: url)
 let service = MyService(client: client)
 
 // Perform request
-service.vote(rating: 5)
-```
-
-### Result Handling
-
-SwiftJSONRPC uses [PromiseKit](https://github.com/mxcl/PromiseKit) to return result.
-
-```swift
-service.vote(rating: 5)
-    .done { newRating in
-        // Handle result
-    }
-    .catch { error in
-        // Handle error
-    }
+try await service.vote(rating: 5)
 ```
 
 #### Result Serialization
@@ -90,28 +75,26 @@ After that use this struct as `RPCService.Result` generic parameter:
 
 ```swift
 class UserService: RPCService {
-    func create(name: String) -> Promise<UserModel> {
-        return invoke("create", params: ["name": name])
+    func create(name: String) async throws -> UserModel {
+        return try await invoke("create", params: ["name": name])
     }
 }
 ```
 ```swift
-service.create(name: "testuser").done { user in
-    print("User created with ID = \(user.id)")
-}
+let user = try await service.create(name: "testuser")
+print("User created with ID = \(user.id)")
 ```
 
 Using array of `Parcelable` objects is also supported:
 
 ```swift
 extension UserService {
-    func allUsers() -> Promise<[UserModel]> {
-        return invoke("all_users")
+    func allUsers() async throws -> [UserModel] {
+        return try await invoke("all_users")
     }
 }
 ```
 
-
 ## Advanced Usage
 
 ### Request Executor

Package.resolved

@@ -7,156 +7,128 @@
 // ----------------------------------------------------------------------------
 
 import Foundation
-import PromiseKit
 
-// ----------------------------------------------------------------------------
+open class RPCClient {
+
+    // MARK: - Properties
+
+    public var requestRetrier: RequestRetrier? = nil
+
+    // MARK: - Private Properties
+
+    private let requestExecutor: RequestExecutor
+
+    private let requestIdGenerator = RequestIdGenerator()
 
-open class RPCClient
-{
-// MARK: - Construction
+    // MARK: - Initialization
 
-    public init(requestExecutor: RequestExecutor)
-    {
-        // Init instance variables
+    public init(requestExecutor: RequestExecutor) {
         self.requestExecutor = requestExecutor
     }
 
-    public convenience init(url: URL)
-    {
+    public convenience init(url: URL) {
         let requestExecutor = HTTPRequestExecutor(url: url)
         self.init(requestExecutor: requestExecutor)
     }
 
-// MARK: - Properties
-
-    public var requestRetrier: RequestRetrier? = nil
-
-// MARK: - Public Functions
+    // MARK: - Public Functions
 
-    open func invoke<Result>(_ invocation: Invocation<Result>) -> Promise<Result>
-    {
+    open func invoke<Result>(_ invocation: Invocation<Result>) async throws -> Result {
         // Init request
         let request = makeRequest(invocation: invocation)
 
-        // Init result dispatcher
-        let resultDispatcher = ResultDispatcher(invocation: invocation)
-
         // Perform request
-        DispatchQueue.global().async { [weak self] in
-            self?.execute(request: request, withResultDispatcher: resultDispatcher)
-        }
-
-        return resultDispatcher.promise
+        return try await execute(request: request, with: invocation.parser)
     }
 
-// MARK: - Private Functions
+    // MARK: - Private Functions
 
-    private func makeRequest<Result>(invocation: Invocation<Result>) -> Request
-    {
+    private func makeRequest<Result>(invocation: Invocation<Result>) -> Request {
         // TODO: Support notification type calls without identifiers
-        // Generate request indentifier
-        let identifier = self.requestIdGenerator.next()
+        // Generate request identifier
+        let identifier = requestIdGenerator.next()
 
         // Init request
-        return Request(id: identifier, invocation: invocation)
+        return Request(
+            id: identifier,
+            method: invocation.method,
+            params: invocation.params
+        )
     }
 
-    private func execute<R>(request: Request, withResultDispatcher resultDispatcher: ResultDispatcher<R>)
-    {
-        execute(request: request) { result in
-            resultDispatcher.dispatch(result: result)
+    private func execute<Result>(request: Request, with parser: AnyResultParser<Result>) async throws -> Result {
+        return try await withCheckedThrowingContinuation { continuation in
+            execute(request: request) { result in
+                do {
+                    continuation.resume(returning: try result.result(with: parser))
+                } catch {
+                    continuation.resume(throwing: error)
+                }
+            }
         }
     }
 
-    private func execute(request: Request, completionHandler: @escaping (RequestExecutorResult) -> Void)
-    {
-        self.requestExecutor.execute(request: request) { [weak self] result in
-            if let instance = self,
-               instance.shouldRetry(request: request, afterResult: result)
-            {
-                instance.execute(request: request, completionHandler: completionHandler)
-            }
-            else {
+    private func execute(request: Request, completionHandler: @escaping (RequestExecutorResult) -> Void) {
+        requestExecutor.execute(request: request) { [weak self] result in
+            if let self = self,
+               self.shouldRetry(request: request, afterResult: result) {
+                self.execute(request: request, completionHandler: completionHandler)
+            } else {
                 completionHandler(result)
             }
         }
     }
 
-    private func shouldRetry(request: Request, afterResult result: RequestExecutorResult) -> Bool
-    {
+    private func shouldRetry(request: Request, afterResult result: RequestExecutorResult) -> Bool {
         let retry: Bool
 
         if case .response(let response) = result,
-           let requestRetrier = self.requestRetrier
-        {
+           let requestRetrier = self.requestRetrier {
             retry = requestRetrier.should(client: self, retryRequest: request, afterResponse: response)
-        }
-        else {
+        } else {
             retry = false
         }
 
         return retry
     }
 
-// MARK: - Constants
+    // MARK: - Constants
 
     static let Version = "2.0"
 
-// MARK: - Variables
-
-    private let requestExecutor: RequestExecutor
-
-    private let requestIdGenerator = RequestIdGenerator()
-
 }
 
-// ----------------------------------------------------------------------------
+private extension RequestExecutorResult {
 
-extension ResultDispatcher
-{
-// MARK: - Private Functions
+    // MARK: - Functions
 
-    fileprivate func dispatch(result: RequestExecutorResult)
-    {
-        switch result
-        {
-            case .response(let response):
-                dispatch(response: response)
-
-            case .error(let error):
-                dispatch(error: InvocationError.applicationError(cause: error))
-
-            case .cancel:
-                dispatch(error: InvocationError.canceled)
+    func result<Result>(with parser: AnyResultParser<Result>) throws -> Result {
+        switch self {
+        case .response(let response):
+            return try result(for: response, with: parser)
+        case .error(let error):
+            throw InvocationError.applicationError(cause: error)
+        case .cancel:
+            throw InvocationError.canceled
         }
     }
 
-    fileprivate func dispatch(response: Response)
-    {
-        switch response.body
-        {
-            case .success(let successBody):
-                dispatchSuccessBody(successBody)
+    // MARK: - Private Functions
 
-            case .error(let error):
-                dispatch(error: InvocationError.rpcError(error: error))
+    private func result<Result>(for response: Response, with parser: AnyResultParser<Result>) throws -> Result {
+        switch response.body {
+        case .success(let successBody):
+            return try resultForSuccessBody(successBody, with: parser)
+        case .error(let error):
+            throw InvocationError.rpcError(error: error)
         }
     }
 
-    fileprivate func dispatchSuccessBody(_ body: AnyObject)
-    {
+    private func resultForSuccessBody<Result>(_ body: AnyObject, with parser: AnyResultParser<Result>) throws -> Result {
         do {
-            let result = try self.invocation.parser.parse(body)
-            dispatch(result: result)
-        }
-        catch (let cause)
-        {
-            let error = InvocationError.applicationError(cause: cause)
-            dispatch(error: error)
+            return try parser.parse(body)
+        } catch {
+            throw InvocationError.applicationError(cause: error)
         }
     }
-
 }
-
-// ----------------------------------------------------------------------------
-