PMK 5.0.0

Author: mxcl

.gitignore

@@ -1,5 +1,5 @@
 *.xcodeproj/**/xcuserdata/
 *.xcscmblueprint
 /Carthage
-/Cartfile.resolved
 /.build
+.DS_Store

Cartfile

@@ -1 +1 @@
-github "mxcl/PromiseKit" ~> 4.0
+github "mxcl/PromiseKit" ~> 5.0

Cartfile.resolved

@@ -0,0 +1 @@
+github "mxcl/PromiseKit" "5.0.0"

Sources/CLGeocoder+AnyPromise.m

@@ -6,10 +6,6 @@
 
 @implementation CLGeocoder (PromiseKit)
 
-+ (void)load {
-    [NSError registerCancelledErrorDomain:kCLErrorDomain code:kCLErrorGeocodeCanceled];
-}
-
 - (AnyPromise *)reverseGeocode:(CLLocation *)location {
     return [AnyPromise promiseWithResolverBlock:^(PMKResolver resolve) {
        [self reverseGeocodeLocation:location completionHandler:^(NSArray *placemarks, NSError *error) {

Sources/CLGeocoder+Promise.swift

@@ -1,5 +1,5 @@
 import CoreLocation.CLGeocoder
-#if !COCOAPODS
+#if !PMKCOCOAPODS
 import PromiseKit
 #endif
 
@@ -15,63 +15,37 @@ import PromiseKit
 */
 extension CLGeocoder {
     /// Submits a reverse-geocoding request for the specified location.
-    public func reverseGeocode(location: CLLocation) -> PlacemarkPromise {
-        return PlacemarkPromise.go { resolve in
-            reverseGeocodeLocation(location, completionHandler: resolve)
+    public func reverseGeocode(location: CLLocation) -> Promise<[CLPlacemark]> {
+        return Promise(.pending) { seal in
+            reverseGeocodeLocation(location, completionHandler: seal.resolve)
         }
     }
 
     /// Submits a forward-geocoding request using the specified address dictionary.
-    public func geocode(_ addressDictionary: [String: String]) -> PlacemarkPromise {
-        return PlacemarkPromise.go { resolve in
-            geocodeAddressDictionary(addressDictionary, completionHandler: resolve)
+    public func geocode(_ addressDictionary: [String: String]) -> Promise<[CLPlacemark]> {
+        return Promise(.pending) { seal in
+            geocodeAddressDictionary(addressDictionary, completionHandler: seal.resolve)
         }
     }
 
     /// Submits a forward-geocoding request using the specified address string.
-    public func geocode(_ addressString: String) -> PlacemarkPromise {
-        return PlacemarkPromise.go { resolve in
-            geocodeAddressString(addressString, completionHandler: resolve)
+    public func geocode(_ addressString: String) -> Promise<[CLPlacemark]> {
+        return Promise(.pending) { seal in
+            geocodeAddressString(addressString, completionHandler: seal.resolve)
         }
     }
 
     /// Submits a forward-geocoding request using the specified address string within the specified region.
-    public func geocode(_ addressString: String, region: CLRegion?) -> PlacemarkPromise {
-        return PlacemarkPromise.go { resolve in
-            geocodeAddressString(addressString, in: region, completionHandler: resolve)
+    public func geocode(_ addressString: String, region: CLRegion?) -> Promise<[CLPlacemark]> {
+        return Promise(.pending) { seal in
+            geocodeAddressString(addressString, in: region, completionHandler: seal.resolve)
         }
     }
 }
 
-// Xcode 8 beta 6 doesn't import CLError as Swift.Error
+// TODO still not possible in Swift 3.2
 //extension CLError: CancellableError {
 //    public var isCancelled: Bool {
 //        return self == .geocodeCanceled
 //    }
 //}
-
-/// A promise that returns the first CLPlacemark from an array of results.
-public class PlacemarkPromise: Promise<CLPlacemark> {
-
-    /// Returns all CLPlacemarks rather than just the first
-    public func asArray() -> Promise<[CLPlacemark]> {
-        return then(on: zalgo) { _ in return self.placemarks }
-    }
-
-    private var placemarks: [CLPlacemark]!
-
-    fileprivate class func go(_ body: (@escaping ([CLPlacemark]?, Error?) -> Void) -> Void) -> PlacemarkPromise {
-        var promise: PlacemarkPromise!
-        promise = PlacemarkPromise { fulfill, reject in
-            body { placemarks, error in
-                if let error = error {
-                    reject(error)
-                } else {
-                    promise.placemarks = placemarks
-                    fulfill(placemarks!.first!)
-                }
-            }
-        }
-        return promise
-    }
-}

Sources/CLLocationManager+Promise.swift

@@ -1,5 +1,5 @@
 import CoreLocation.CLLocationManager
-#if !COCOAPODS
+#if !PMKCOCOAPODS
 import PromiseKit
 #endif
 
@@ -27,11 +27,6 @@ extension CLLocationManager {
         case whenInUse
     }
 
-    fileprivate class func promiseDoneForLocationManager(_ manager: CLLocationManager) -> Void {
-        manager.delegate = nil
-        manager.stopUpdatingLocation()
-    }
-  
     /**
       - Returns: A new promise that fulfills with the most recent CLLocation.
       - Note: To return all locations call `allResults()`. 
@@ -40,38 +35,40 @@ extension CLLocationManager {
       want to force one or the other, change this parameter from its default
       value.
      */
-    public class func promise(_ requestAuthorizationType: RequestAuthorizationType = .automatic) -> LocationPromise {
-        return promise(yielding: auther(requestAuthorizationType))
+    public class func requestLocation(authorizationType: RequestAuthorizationType = .automatic) -> Promise<[CLLocation]> {
+        return promise(yielding: auther(authorizationType))
+    }
+
+    @available(*, deprecated: 5.0, renamed: "requestLocation")
+    public class func promise(_ requestAuthorizationType: RequestAuthorizationType = .automatic) -> Promise<[CLLocation]> {
+        return requestLocation(authorizationType: requestAuthorizationType)
     }
 
-    private class func promise(yielding yield: (CLLocationManager) -> Void = { _ in }) -> LocationPromise {
+    private class func promise(yielding yield: (CLLocationManager) -> Void = { _ in }) -> Promise<[CLLocation]> {
         let manager = LocationManager()
         manager.delegate = manager
         yield(manager)
         manager.startUpdatingLocation()
-        _ = manager.promise.always {
-            CLLocationManager.promiseDoneForLocationManager(manager)
+        _ = manager.promise.ensure {
+            manager.stopUpdatingLocation()
         }
         return manager.promise
     }
 }
 
 private class LocationManager: CLLocationManager, CLLocationManagerDelegate {
-    let (promise, fulfill, reject) = LocationPromise.foo()
+    let (promise, seal) = Promise<[CLLocation]>.pending()
 
-    @objc fileprivate func locationManager(_ manager: CLLocationManager, didUpdateLocations ll: [CLLocation]) {
-        let locations = ll 
-        fulfill(locations)
-        CLLocationManager.promiseDoneForLocationManager(manager)
+    @objc fileprivate func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        seal.fulfill(locations)
     }
 
     @objc func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
-        let error = error as NSError
-        if error.code == CLError.locationUnknown.rawValue && error.domain == kCLErrorDomain {
+        let (domain, code) = { ($0.domain, $0.code) }(error as NSError)
+        if code == CLError.locationUnknown.rawValue && domain == kCLErrorDomain {
             // Apple docs say you should just ignore this error
         } else {
-            reject(error)
-            CLLocationManager.promiseDoneForLocationManager(manager)
+            seal.reject(error)
         }
     }
 }
@@ -80,22 +77,17 @@ private class LocationManager: CLLocationManager, CLLocationManagerDelegate {
 #if os(iOS)
 
 extension CLLocationManager {
-    /**
-     Cannot error, despite the fact this might be more useful in some
-     circumstances, we stick with our decision that errors are errors
-     and errors only. Thus your catch handler is always catching failures
-     and not being abused for logic.
-    */
+    /// request CoreLocation authorization from user
     @available(iOS 8, *)
-    public class func requestAuthorization(type: RequestAuthorizationType = .automatic) -> Promise<CLAuthorizationStatus> {
+    public class func requestAuthorization(type: RequestAuthorizationType = .automatic) -> Guarantee<CLAuthorizationStatus> {
         return AuthorizationCatcher(auther: auther(type), type: type).promise
     }
 }
 
 @available(iOS 8, *)
 private class AuthorizationCatcher: CLLocationManager, CLLocationManagerDelegate {
-    let (promise, fulfill, _) = Promise<CLAuthorizationStatus>.pending()
-    var retainCycle: AnyObject?
+    let (promise, fulfill) = Guarantee<CLAuthorizationStatus>.pending()
+    var retainCycle: AuthorizationCatcher?
 
     init(auther: (CLLocationManager) -> Void, type: CLLocationManager.RequestAuthorizationType) {
         super.init()
@@ -108,12 +100,14 @@ private class AuthorizationCatcher: CLLocationManager, CLLocationManagerDelegate
         default:
             fulfill(status)
         }
+        promise.done { _ in
+            self.retainCycle = nil
+        }
     }
 
     @objc fileprivate func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
         if status != .notDetermined {
             fulfill(status)
-            retainCycle = nil
         }
     }
 }
@@ -156,27 +150,4 @@ private func auther(_ requestAuthorizationType: CLLocationManager.RequestAuthori
 
 #endif
 
-
-/// The promise returned by CLLocationManager.promise()
-public class LocationPromise: Promise<CLLocation> {
-    // convoluted for concurrency guarantees
-    private let (parentPromise, fulfill, reject) = Promise<[CLLocation]>.pending()
-
-    /// Convert the promise so that all Location results are returned
-    public func asArray() -> Promise<[CLLocation]> {
-        return parentPromise
-    }
-
-    fileprivate class func foo() -> (LocationPromise, ([CLLocation]) -> Void, (Error) -> Void) {
-        var fulfill: ((CLLocation) -> Void)!
-        var reject: ((Error) -> Void)!
-        let promise = LocationPromise { fulfill = $0; reject = $1 }
-
-        _ = promise.parentPromise.then(on: zalgo) { fulfill($0.last!) }
-        promise.parentPromise.catch(on: zalgo, execute: reject)
-
-        return (promise, promise.fulfill, promise.reject)
-    }
-}
-
 #endif

Tests/CLGeocoderTests.swift

@@ -7,52 +7,52 @@ class CLGeocoderTests: XCTestCase {
     func test_reverseGeocodeLocation() {
         class MockGeocoder: CLGeocoder {
             override func reverseGeocodeLocation(_ location: CLLocation, completionHandler: @escaping CLGeocodeCompletionHandler) {
-                after(interval: 0).then {
+                after(.seconds(0)).done {
                     completionHandler([dummyPlacemark], nil)
                 }
             }
         }
 
         let ex = expectation(description: "")
-        MockGeocoder().reverseGeocode(location: CLLocation()).then { x -> Void in
-            XCTAssertEqual(x, dummyPlacemark)
+        MockGeocoder().reverseGeocode(location: CLLocation()).done { x in
+            XCTAssertEqual(x, [dummyPlacemark])
             ex.fulfill()
         }
-        waitForExpectations(timeout: 1, handler: nil)
+        waitForExpectations(timeout: 1)
     }
 
     func test_geocodeAddressDictionary() {
         class MockGeocoder: CLGeocoder {
             override func geocodeAddressDictionary(_ addressDictionary: [AnyHashable : Any], completionHandler: @escaping CLGeocodeCompletionHandler) {
-                after(interval: 0.0).then {
+                after(.seconds(0)).done {
                     completionHandler([dummyPlacemark], nil)
                 }
             }
         }
 
         let ex = expectation(description: "")
-        MockGeocoder().geocode([:]).then { x -> Void in
-            XCTAssertEqual(x, dummyPlacemark)
+        MockGeocoder().geocode([:]).done { x in
+            XCTAssertEqual(x, [dummyPlacemark])
             ex.fulfill()
         }
-        waitForExpectations(timeout: 1, handler: nil)
+        waitForExpectations(timeout: 1)
     }
 
     func test_geocodeAddressString() {
         class MockGeocoder: CLGeocoder {
             override func geocodeAddressString(_ addressString: String, completionHandler: @escaping CLGeocodeCompletionHandler) {
-                after(interval: 0.0).then {
+                after(.seconds(0)).done {
                     completionHandler([dummyPlacemark], nil)
                 }
             }
         }
 
         let ex = expectation(description: "")
-        MockGeocoder().geocode("").then { x -> Void in
-            XCTAssertEqual(x, dummyPlacemark)
+        MockGeocoder().geocode("").done { x in
+            XCTAssertEqual(x, [dummyPlacemark])
             ex.fulfill()
         }
-        waitForExpectations(timeout: 1, handler: nil)
+        waitForExpectations(timeout: 1)
     }
 }
 

Tests/CLLocationManagerTests.swift

@@ -6,24 +6,11 @@ import XCTest
 #if !os(tvOS)
 
 class Test_CLLocationManager_Swift: XCTestCase {
-    func test_fulfills_with_one_location() {
-        swizzle(CLLocationManager.self, #selector(CLLocationManager.startUpdatingLocation)) {
-            let ex = expectation(description: "")
-
-            CLLocationManager.promise().then { x -> Void in
-                XCTAssertEqual(x, dummy.last!)
-                ex.fulfill()
-            }
-
-            waitForExpectations(timeout: 1, handler: nil)
-        }
-    }
-
     func test_fulfills_with_multiple_locations() {
         swizzle(CLLocationManager.self, #selector(CLLocationManager.startUpdatingLocation)) {
             let ex = expectation(description: "")
 
-            CLLocationManager.promise().asArray().then { x -> Void in
+            CLLocationManager.promise().done { x in
                 XCTAssertEqual(x, dummy)
                 ex.fulfill()
             }
@@ -36,8 +23,8 @@ class Test_CLLocationManager_Swift: XCTestCase {
     func test_requestAuthorization() {
         let ex = expectation(description: "")
 
-        CLLocationManager.requestAuthorization().then { x -> Void in
-            XCTAssertEqual(x, CLAuthorizationStatus.restricted)
+        CLLocationManager.requestAuthorization().done {
+            XCTAssertEqual($0, CLAuthorizationStatus.restricted)
             ex.fulfill()
         }
 
@@ -52,7 +39,7 @@ private let dummy = [CLLocation(latitude: 0, longitude: 0), CLLocation(latitude:
 
 extension CLLocationManager {
     @objc func pmk_startUpdatingLocation() {
-        after(interval: 0.1).then {
+        after(.milliseconds(100)).done {
             self.delegate!.locationManager?(self, didUpdateLocations: dummy)
         }
     }