• Moved Equatable extensions from tests to framework
• Moved Result get-properties extensions to framework
• Add rest of cases on FrisbeeError: Equatable
• Add == overload when Entity: Equatable on Result
• Add Sequence.extensiveCombine on testing target to enable cartesian product of Sequences [0,1] x [a, b, c] = [(0,a), (0,b), (0,c), (1,a), (1,b), (1,c)]

This allows URL to be build beforehand by someone else

The String argument overloads should prefer/use URL overloads since they are already converted and ready for use

Both Getable and Postable have methods that conveniently receives a url as String. The problem with this is that any object that adopts those protocols will have to add those methods as wells, and we can't be sure they will implement the right way - just validate the url and call the version with url: URl.

We could just create extensions to the protocols with those convenient methods implemented like so:

extension Getable {
    @discardableResult
    public func get<T: Decodable>(url: String, onComplete: @escaping OnComplete<T>) -> Cancellable {
        guard let url = URL(string: url) else {
            onComplete(.fail(FrisbeeError.invalidUrl))
            return NilCancellable()
        }
        return get(url: url, onComplete: onComplete)
    }
}

That way the client can still use URL as strings and we are sure it behaves correctly.

JSON (de/en)coders can be configured with some other options, this just allows them to be inserted before initializing the adapters

More work should be done on whoever uses them

Until now it was possible to integrate just with JSON. Now it is possible to integrate with Data and with this is possible to download images from Data.

First part of issue #8 implementing POST method.

• [x] Create a body builder (birl!);
• [x] Create body builder tests;
• [x] Create NetworkPost class;
• [x] Create NetworkPostTests.

Created an init for FrisbeError and remove some error handling in NetworkGet. With that is more easy to test error handling and .unknown error is unnecessary.

• Update LinuxMain.swift
• Remove unnecessary setup method at URLRequestFactoryTests
• Extract test structs to files
• Extract XCTest extension to file
• Rename some tests

For now, every time a new request is made with NetworkGetter.makeRequest, a new URLSession is used

Allow injection of URLSession to enable use of delegates and queues

As mentioned at issue #8, it should be possible to accept an empty body, like when the server sends 204 (HTTP NOT CONTENT), it could be retrieved

I did this due to some problems while I was working on DELETE HTTP VERB.

Postable and Postable are basically the same thing.

public protocol Getable {
    @discardableResult
    func get<T: Decodable>(url: String,
                           onComplete: @escaping OnComplete<T>) -> Cancellable
    @discardableResult
    func get<T: Decodable>(url: URL,
                           onComplete: @escaping OnComplete<T>) -> Cancellable
    @discardableResult
    func get<T: Decodable, U: Encodable>(url: String, query: U,
                                         onComplete: @escaping OnComplete<T>) -> Cancellable
    @discardableResult
    func get<T: Decodable, U: Encodable>(url: URL, query: U,
                                         onComplete: @escaping OnComplete<T>) -> Cancellable
}

protocol Postable {
    @discardableResult
    func post<T: Decodable>(url: String,
                            onComplete: @escaping OnComplete<T>) -> Cancellable
    @discardableResult
    func post<T: Decodable>(url: URL,
                            onComplete: @escaping OnComplete<T>) -> Cancellable
    @discardableResult
    func post<T: Decodable, U: Encodable>(url: String, body: U,
                                          onComplete: @escaping OnComplete<T>) -> Cancellable
    @discardableResult
    func post<T: Decodable, U: Encodable>(url: URL, body: U,
                                          onComplete: @escaping OnComplete<T>) -> Cancellable
}

Why do not make one protocol and then extend it if necessary?

Why implement Promise/Future

Promise<Value> enables more functionalities for chaining and perpetuating operations than a simple (Result<Value>) -> Void callback by allowing

• Multiple transformations: map, flatMap
• Error catching and treating
• Easier operation workload dispatching to other threads/queues

Basic snippet

Inspired by RxSwift, Future (from fp paradigms) and Promise (from js):

public final class Promise<Value> {
    let callback: (@escaping (PromiseEvent<Value>) -> Void) -> Void

    public init(_ callback: @escaping (@escaping (PromiseEvent<Value>) -> Void) -> Void) {
        self.callback = callback
    }

    public func work(_ callback: @escaping (PromiseEvent<Value>) -> Void) {
        self.callback(callback)
    }

    public func then(onFulfilled: ((Value) -> Void)? = nil,
                     onFailed: ((Error) -> Void)? = nil) {
        self.work { event in
            switch event {
            case .value(let value):
                onFulfilled?(value)
            case .error(let error):
                onFailed?(error)
            }
        }
    }

    public func map<T>(_ transform: @escaping (Value) throws -> T) -> Promise<T> {
        return Promise<T> { callback in
            self.work { event in callback(event.map(transform)) }
        }
    }

    public func flatMap<T>(_ transform: @escaping (Value) throws -> Promise<T>) -> Promise<T> {
        return Promise<T> { callback in
            self.work { event in
                switch event {
                case .value(let value):
                    do {
                        try transform(value).work(callback)
                    } catch {
                        callback(.error(error))
                    }
                case .error(let error):
                    callback(.error(error))
                }
            }
        }
    }
}

extension Promise {
    public convenience init(value: Value) {
        self.init { callback in callback(.value(value)) }
    }

    public convenience init(error: Error) {
        self.init { callback in callback(.error(error)) }
    }

    public static func just(_ value: Value) -> Promise<Value> {
        return Promise(value: value)
    }

    public static func error(_ error: Error) -> Promise<Value> {
        return Promise(error: error)
    }

    public static func empty() -> Promise<Void> {
        return Promise<Void>(value: ())
    }
}

Use examples

Simple async dispatching

// creates the Promise,
let somePromise = Promise<Int> { callback in
    DispatchQueue.main.asyncAfter(deadline: .now() + 10) {
        callback(.value(0))
    }
}

somePromise
    .map { $0 * $0 }
    // only starts the work when this function is called
    .work { event in
        switch event {
            case .value(let value): ...
            case .error(let error): ...
        }
     }

// another way of listening to the result
somePromise.then(onFulfilled: { value in ... }, 
                 onFailed: { error in ... })

Other ways of creating Promises

Promise.just(0)
Promise<Value>.error(SomeError)
Promise.empty() // of Void type

Similarities

Using RxSwift as a reference, a Promise is a Single Cold Observable. It contains some work which will only be executed when someone subscribes to it There should be ways of making them hot Observables, share subscriptions, combine with others (eg: zip) etc

But differently from RxSwift, Promises do not send a stream of multiple objects, just zero or one (Value or Error) And it should be noted that it also doesn't have to deal with disposables and whatnot

References

RxSwift khanlou/Promise

Implement all (post, put, patch, delete) HTTP verbs. Creating other classes like NetworkGetter to keep it conforms to SOLID.

• [x] POST #16
• [x] PUT #27
• [ ] DELETE

It is nice to empower anyone to build their own mocks. But, I think that Frisbee must provide a ready for use mock. Something like that:

public class MockGetter<Entity: Decodable>: Getable {
    var resultOnComplete: Result<Entity>
    var didCallGet = false

    // ...

    public func get<Entity: Decodable>(url: String, onComplete: @escaping (Result<Entity>) -> Void) {
        didCallGet = true
        completionHandler(resultOnComplete)
    }
}