Merge pull request #18 from vadymmarkov/feature/recover

Feature: promise recover

README.md

@@ -28,6 +28,7 @@ asynchronous code up to the next level.
   * [Fail](#fail)
   * [Always](#always)
   * [Then](#then)
+  * [Recover](#recover)
   * [When](#when)
 * [Installation](#installation)
 * [Author](#author)
@@ -229,6 +230,26 @@ promise2.thenInBackground({ data -> Promise<NSData> in
 })
 ```
 
+### Recover
+Returns a new ***promise*** that can be used to continue the chain when an
+error was thrown.
+
+```swift
+let promise = Promise<String>()
+// Recover the chain
+promise
+  .recover({ error -> Promise<String> in
+    return Promise({
+      return "Recovered"
+    })
+  })
+  .done({ string in
+    print(string) // Recovered
+  })
+// Reject the promise
+promise.reject(Error.notFound)
+```
+
 ### When
 Provides a way to execute callback functions based on one or more
 ***promises***. The ***when*** method returns a new "master" ***promise*** that

Sources/When/Promise.swift

@@ -123,7 +123,7 @@ open class Promise<T> {
 
   // MARK: - Helpers
 
-  private func update(state: State<T>?) {
+  fileprivate func update(state: State<T>?) {
     dispatch(queue) {
       guard let state = state, let result = state.result else {
         return
@@ -156,25 +156,6 @@ open class Promise<T> {
     observer = nil
   }
 
-  fileprivate func addObserver<U>(on queue: DispatchQueue, promise: Promise<U>, _ body: @escaping (T) throws -> U?) {
-    observer = Observer(queue: queue) { result in
-      switch result {
-      case let .success(value):
-        do {
-          if let result = try body(value) {
-            promise.resolve(result)
-          }
-        } catch {
-          promise.reject(error)
-        }
-      case let .failure(error):
-        promise.reject(error)
-      }
-    }
-
-    update(state: state)
-  }
-
   private func dispatch(_ queue: DispatchQueue, closure: @escaping () -> Void) {
     if queue === instantQueue {
       closure()
@@ -190,13 +171,11 @@ extension Promise {
   public func then<U>(on queue: DispatchQueue = mainQueue, _ body: @escaping (T) throws -> U) -> Promise<U> {
     let promise = Promise<U>(queue: queue)
     addObserver(on: queue, promise: promise, body)
-
     return promise
   }
 
   public func then<U>(on queue: DispatchQueue = mainQueue, _ body: @escaping (T) throws -> Promise<U>) -> Promise<U> {
     let promise = Promise<U>(queue: queue)
-
     addObserver(on: queue, promise: promise) { value -> U? in
       let nextPromise = try body(value)
       nextPromise.addObserver(on: queue, promise: promise) { value -> U? in
@@ -205,7 +184,6 @@ extension Promise {
 
       return nil
     }
-
     return promise
   }
 
@@ -217,7 +195,80 @@ extension Promise {
     return then(on: backgroundQueue, body)
   }
 
+  fileprivate func addObserver<U>(on queue: DispatchQueue, promise: Promise<U>, _ body: @escaping (T) throws -> U?) {
+    observer = Observer(queue: queue) { result in
+      switch result {
+      case let .success(value):
+        do {
+          if let result = try body(value) {
+            promise.resolve(result)
+          }
+        } catch {
+          promise.reject(error)
+        }
+      case let .failure(error):
+        promise.reject(error)
+      }
+    }
+
+    update(state: state)
+  }
+
   func asVoid() -> Promise<Void> {
     return then(on: instantQueue) { _ in return }
   }
 }
+
+// MARK: - Recover
+
+extension Promise {
+  /**
+   Helps to recover from certain errors. Continues the chain if a given closure does not throw.
+   */
+  public func recover(on queue: DispatchQueue = mainQueue,
+                      _ body: @escaping (Error) throws -> T) -> Promise<T> {
+    let promise = Promise<T>(queue: queue)
+    addRecoverObserver(on: queue, promise: promise, body)
+    return promise
+  }
+
+  /**
+   Helps to recover from certain errors. Continues the chain if a given closure does not throw.
+   */
+  public func recover(on queue: DispatchQueue = mainQueue,
+                      _ body: @escaping (Error) throws -> Promise<T>) -> Promise<T> {
+    let promise = Promise<T>(queue: queue)
+    addRecoverObserver(on: queue, promise: promise) { error -> T? in
+      let nextPromise = try body(error)
+      nextPromise.addObserver(on: queue, promise: promise) { value -> T? in
+        return value
+      }
+
+      return nil
+    }
+    return promise
+  }
+
+  /**
+   Adds a recover observer.
+   */
+  private func addRecoverObserver(on queue: DispatchQueue, promise: Promise<T>,
+                                  _ body: @escaping (Error) throws -> T?) {
+    observer = Observer(queue: queue) { result in
+      switch result {
+      case let .success(value):
+        promise.resolve(value)
+      case let .failure(error):
+        do {
+          if let result = try body(error) {
+            promise.resolve(result)
+          }
+        } catch {
+          promise.reject(error)
+        }
+      }
+    }
+
+    update(state: state)
+  }
+}

WhenTests/Shared/Helpers/SpecError.swift

@@ -2,4 +2,5 @@ import Foundation
 
 enum SpecError: Error {
   case notFound
+  case rejected
 }

WhenTests/Shared/PromiseSpec.swift

@@ -366,6 +366,92 @@ class PromiseSpec: QuickSpec {
           }
         }
       }
+
+      describe("#recover") {
+        beforeEach {
+          promise = Promise<String>()
+        }
+
+        context("with a body that transforms result") {
+          context("with a body throws an error") {
+            it("rejects the promise") {
+              let failExpectation = self.expectation(description: "Then fail expectation")
+
+              promise
+                .recover({ error -> String in
+                  throw SpecError.notFound
+                })
+                .fail({ error in
+                  expect(error is SpecError).to(beTrue())
+                  failExpectation.fulfill()
+                })
+
+              promise.reject(SpecError.rejected)
+              self.waitForExpectations(timeout: 2.0, handler:nil)
+            }
+          }
+
+          context("with a body that returns a value") {
+            it("resolves the promise") {
+              let doneExpectation = self.expectation(description: "Then done expectation")
+
+              promise
+                .recover({ error in
+                  return "Recovered"
+                })
+                .done({ value in
+                  expect(value).to(equal("Recovered"))
+                  doneExpectation.fulfill()
+                })
+
+              promise.reject(SpecError.rejected)
+              self.waitForExpectations(timeout: 2.0, handler:nil)
+            }
+          }
+        }
+
+        context("with a body that returns a new promise") {
+          context("with a rejected promise") {
+            it("rejects the promise") {
+              let failExpectation = self.expectation(description: "Then fail expectation")
+
+              promise
+                .recover({ error in
+                  return Promise({
+                    throw SpecError.notFound
+                  })
+                })
+                .fail({ error in
+                  expect(error is SpecError).to(beTrue())
+                  failExpectation.fulfill()
+                })
+
+              promise.reject(SpecError.rejected)
+              self.waitForExpectations(timeout: 2.0, handler:nil)
+            }
+          }
+
+          context("with a body that returns a value") {
+            it("with a resolved promise") {
+              let doneExpectation = self.expectation(description: "Then done expectation")
+
+              promise
+                .recover({ error -> Promise<String> in
+                  return Promise({
+                    return "Recovered"
+                  })
+                })
+                .done({ value in
+                  expect(value).to(equal("Recovered"))
+                  doneExpectation.fulfill()
+                })
+
+              promise.reject(SpecError.rejected)
+              self.waitForExpectations(timeout: 2.0, handler:nil)
+            }
+          }
+        }
+      }
     }
   }
 }