'Cancel' for PromiseKit --

* Eliminate duplicate code in the cancellable extensions
* When using the 'cancellable' function with the extensions, ensure that the underlying task (if any) is always cancelled
* When using the 'cancellable' function, call 'reject' on the underlying promise (wherever possible) if 'cancel' is invoked
* Create cancellable wrappers for the extensions only for the cases where there is an underlying task that supports cancellation

Author: dougzilla32

Sources/CLGeocoder+Promise.swift

@@ -71,54 +71,3 @@ extension CLGeocoder {
 //        return self == .geocodeCanceled
 //    }
 //}
-
-//////////////////////////////////////////////////////////// Cancellation
-
-extension CLGeocoder {
-    /// Submits a reverse-geocoding request for the specified location.
-    public func cancellableReverseGeocode(location: CLLocation) -> CancellablePromise<[CLPlacemark]> {
-        return CancellablePromise { seal in
-            reverseGeocodeLocation(location, completionHandler: seal.resolve)
-        }
-    }
-
-    /// Submits a forward-geocoding request using the specified address dictionary.
-    @available(iOS, deprecated: 11.0)
-    public func cancellableGeocode(_ addressDictionary: [String: String]) -> CancellablePromise<[CLPlacemark]> {
-        return CancellablePromise { seal in
-            geocodeAddressDictionary(addressDictionary, completionHandler: seal.resolve)
-        }
-    }
-
-    /// Submits a forward-geocoding request using the specified address string.
-    public func cancellableGeocode(_ addressString: String) -> CancellablePromise<[CLPlacemark]> {
-        return CancellablePromise { seal in
-            geocodeAddressString(addressString, completionHandler: seal.resolve)
-        }
-    }
-
-    /// Submits a forward-geocoding request using the specified address string within the specified region.
-    public func cancellableGeocode(_ addressString: String, region: CLRegion?) -> CancellablePromise<[CLPlacemark]> {
-        return CancellablePromise { seal in
-            geocodeAddressString(addressString, in: region, completionHandler: seal.resolve)
-        }
-    }
-
-#if !os(tvOS) && swift(>=3.2)
-    /// Submits a forward-geocoding request using the specified postal address.
-    @available(iOS 11.0, OSX 10.13, watchOS 4.0, *)
-    public func cancellableGeocodePostalAddress(_ postalAddress: CNPostalAddress) -> CancellablePromise<[CLPlacemark]> {
-        return CancellablePromise { seal in
-            geocodePostalAddress(postalAddress, completionHandler: seal.resolve)
-        }
-    }
-
-    /// Submits a forward-geocoding requesting using the specified locale and postal address
-    @available(iOS 11.0, OSX 10.13, watchOS 4.0, *)
-    public func cancellableGeocodePostalAddress(_ postalAddress: CNPostalAddress, preferredLocale locale: Locale?) -> CancellablePromise<[CLPlacemark]> {
-        return CancellablePromise { seal in
-            geocodePostalAddress(postalAddress, preferredLocale: locale, completionHandler: seal.resolve)
-        }
-    }
-#endif
-}

Sources/CLLocationManager+Promise.swift

@@ -97,7 +97,7 @@ extension CLLocationManager {
     }
 }
 
-private class LocationManager: CLLocationManager, CLLocationManagerDelegate {
+private class LocationManager: CLLocationManager, CLLocationManagerDelegate, CancellableTask {
     let (promise, seal) = Promise<[CLLocation]>.pending()
     let satisfyingBlock: ((CLLocation) -> Bool)?
 
@@ -120,6 +120,9 @@ private class LocationManager: CLLocationManager, CLLocationManagerDelegate {
         satisfyingBlock = block
         super.init()
         delegate = self
+
+        promise.setCancellableTask(self, reject: seal.reject)
+        
     #if !os(tvOS)
         startUpdatingLocation()
     #else
@@ -138,6 +141,13 @@ private class LocationManager: CLLocationManager, CLLocationManagerDelegate {
             seal.reject(error)
         }
     }
+    
+    func cancel() {
+        self.stopUpdatingLocation()
+        isCancelled = true
+    }
+    
+    var isCancelled = false
 }
 
 
@@ -203,14 +213,16 @@ extension CLLocationManager {
 }
 
 @available(iOS 8, *)
-private class AuthorizationCatcher: CLLocationManager, CLLocationManagerDelegate {
+private class AuthorizationCatcher: CLLocationManager, CLLocationManagerDelegate, CancellableTask {
     let (promise, fulfill) = Guarantee<CLAuthorizationStatus>.pending()
     var retainCycle: AuthorizationCatcher?
     let initialAuthorizationState = CLLocationManager.authorizationStatus()
 
     init(type: PMKCLAuthorizationType) {
         super.init()
 
+        promise.setCancellableTask(self)
+
         func ask(type: PMKCLAuthorizationType) {
             delegate = self
             retainCycle = self
@@ -263,6 +275,13 @@ private class AuthorizationCatcher: CLLocationManager, CLLocationManagerDelegate
             fulfill(status)
         }
     }
+    
+    func cancel() {
+        self.retainCycle = nil
+        isCancelled = true
+    }
+    
+    var isCancelled = false
 }
 
 #endif
@@ -306,7 +325,7 @@ private enum PMKCLAuthorizationType {
     case whenInUse
 }
 
-//////////////////////////////////////////////////////////// Cancellation
+//////////////////////////////////////////////////////////// Cancellable wrappers
 
 extension CLLocationManager {
     /**
@@ -325,105 +344,10 @@ extension CLLocationManager {
        last location.
      */
     public class func cancellableRequestLocation(authorizationType: RequestAuthorizationType = .automatic, satisfying block: ((CLLocation) -> Bool)? = nil) -> CancellablePromise<[CLLocation]> {
-        
-        func std() -> CancellablePromise<[CLLocation]> {
-            return CancellableLocationManager(satisfying: block).promise
-        }
-
-        func auth() -> CancellablePromise<Void> {
-        #if os(macOS)
-            return CancellablePromise { seal in seal.fulfill(()) }
-        #else
-            func auth(type: PMKCLAuthorizationType) -> CancellablePromise<Void> {
-                return CancellableAuthorizationCatcher(type: type).promise.done(on: nil) {
-                    switch $0 {
-                    case .restricted, .denied:
-                        throw PMKError.notAuthorized
-                    default:
-                        break
-                    }
-                }
-            }
-
-            switch authorizationType {
-            case .automatic:
-                switch Bundle.main.permissionType {
-                case .always, .both:
-                    return auth(type: .always)
-                case .whenInUse:
-                    return auth(type: .whenInUse)
-                }
-            case .whenInUse:
-                return auth(type: .whenInUse)
-            case .always:
-                return auth(type: .always)
-            }
-        #endif
-        }
-
-        switch CLLocationManager.authorizationStatus() {
-        case .authorizedAlways, .authorizedWhenInUse:
-            return std()
-        case .notDetermined:
-            return auth().then(std)
-        case .denied, .restricted:
-            return CancellablePromise(error: PMKError.notAuthorized)
-        }
+        return cancellable(requestLocation(authorizationType: authorizationType, satisfying: block))
     }
 }
 
-private class CancellableLocationManager: CLLocationManager, CLLocationManagerDelegate, CancellableTask {
-    let (promise, seal) = CancellablePromise<[CLLocation]>.pending()
-    let satisfyingBlock: ((CLLocation) -> Bool)?
-
-    init(satisfying block: ((CLLocation) -> Bool)? = nil) {
-        satisfyingBlock = block
-        super.init()
-        delegate = self
-        
-        promise.appendCancellableTask(task: self, reject: seal.reject)
-        
-    #if !os(tvOS)
-        startUpdatingLocation()
-    #else
-        requestLocation()
-    #endif
-        _ = self.promise.ensure {
-            self.stopUpdatingLocation()
-        }
-    }
-
-    @objc fileprivate func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
-        if let block = satisfyingBlock {
-            let satisfiedLocations = locations.filter(block)
-            if !satisfiedLocations.isEmpty {
-                seal.fulfill(satisfiedLocations)
-            } else {
-                #if os(tvOS)
-                requestLocation()
-                #endif
-            }
-        } else {
-            seal.fulfill(locations)
-        }
-    }
-    
-    @objc func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
-        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 {
-            seal.reject(error)
-        }
-    }
-    
-    func cancel() {
-        self.stopUpdatingLocation()
-        isCancelled = true
-    }
-    
-    var isCancelled = false
-}
 
 #if !os(macOS)
 
@@ -435,127 +359,8 @@ extension CLLocationManager {
      */
     @available(iOS 8, tvOS 9, watchOS 2, *)
     public class func cancellableRequestAuthorization(type requestedAuthorizationType: RequestAuthorizationType = .automatic) -> CancellablePromise<CLAuthorizationStatus> {
-
-        let currentStatus = CLLocationManager.authorizationStatus()
-
-        func std(type: PMKCLAuthorizationType) -> CancellablePromise<CLAuthorizationStatus> {
-            if currentStatus == .notDetermined {
-                return CancellableAuthorizationCatcher(type: type).promise
-            } else {
-                return cancellable(Promise.value(currentStatus))
-            }
-        }
-
-        switch requestedAuthorizationType {
-        case .always:
-            func iOS11Check() -> CancellablePromise<CLAuthorizationStatus> {
-                switch currentStatus {
-                case .notDetermined, .authorizedWhenInUse:
-                    return CancellableAuthorizationCatcher(type: .always).promise
-                default:
-                    return cancellable(Promise.value(currentStatus))
-                }
-            }
-        #if PMKiOS11
-            // ^^ define PMKiOS11 if you deploy against the iOS 11 SDK
-            // otherwise the warning you get below cannot be removed
-            return iOS11Check()
-        #else
-            if #available(iOS 11, *) {
-                return iOS11Check()
-            } else {
-                return std(type: .always)
-            }
-        #endif
-
-        case .whenInUse:
-            return std(type: .whenInUse)
-
-        case .automatic:
-            if currentStatus == .notDetermined {
-                switch Bundle.main.permissionType {
-                case .both, .whenInUse:
-                    return CancellableAuthorizationCatcher(type: .whenInUse).promise
-                case .always:
-                    return CancellableAuthorizationCatcher(type: .always).promise
-                }
-            } else {
-                return cancellable(Promise.value(currentStatus))
-            }
-        }
-    }
-}
-
-@available(iOS 8, *)
-private class CancellableAuthorizationCatcher: CLLocationManager, CLLocationManagerDelegate, CancellableTask {
-    let (promise, seal) = CancellablePromise<CLAuthorizationStatus>.pending()
-    var retainCycle: CancellableAuthorizationCatcher?
-    let initialAuthorizationState = CLLocationManager.authorizationStatus()
-
-    init(type: PMKCLAuthorizationType) {
-        super.init()
-
-        promise.appendCancellableTask(task: self, reject: seal.reject)
-        
-        func ask(type: PMKCLAuthorizationType) {
-            delegate = self
-            retainCycle = self
-
-            switch type {
-            case .always:
-            #if os(tvOS)
-                fallthrough
-            #else
-                requestAlwaysAuthorization()
-            #endif
-            case .whenInUse:
-                requestWhenInUseAuthorization()
-            }
-
-            _ = promise.done { _ in
-                self.retainCycle = nil
-            }
-        }
-
-        func iOS11Check() {
-            switch (initialAuthorizationState, type) {
-            case (.notDetermined, .always), (.authorizedWhenInUse, .always), (.notDetermined, .whenInUse):
-                ask(type: type)
-            default:
-                seal.fulfill(initialAuthorizationState)
-            }
-        }
-
-    #if PMKiOS11
-        // ^^ define PMKiOS11 if you deploy against the iOS 11 SDK
-        // otherwise the warning you get below cannot be removed
-        iOS11Check()
-    #else
-        if #available(iOS 11, *) {
-            iOS11Check()
-        } else {
-            if initialAuthorizationState == .notDetermined {
-                ask(type: type)
-            } else {
-                seal.fulfill(initialAuthorizationState)
-            }
-        }
-    #endif
+        return cancellable(requestAuthorization(type: requestedAuthorizationType))
     }
-
-    @objc fileprivate func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
-        // `didChange` is a lie; it fires this immediately with the current status.
-        if status != initialAuthorizationState {
-            seal.fulfill(status)
-        }
-    }
-    
-    func cancel() {
-        self.retainCycle = nil
-        isCancelled = true
-    }
-    
-    var isCancelled = false
 }
 
 #endif