2.2.0 — Generated Files

Author: mxcl

.checkout

@@ -24,7 +24,7 @@ extension NSNotificationCenter {
     public class func once(name: String) -> Promise<NSNotification> {
         return Promise { fulfill, _ in
             var id: AnyObject?
-            id = NSNotificationCenter.defaultCenter().addObserverForName(name, object: nil, queue: PMKOperationQueue){ note in
+            id = NSNotificationCenter.defaultCenter().addObserverForName(name, object: nil, queue: nil){ note in
                 fulfill(note)
                 NSNotificationCenter.defaultCenter().removeObserver(id!)
             }

Categories/Foundation/NSNotificationCenter+Promise.swift

@@ -56,7 +56,7 @@ + (AnyPromise *)promise:(NSURLRequest *)rq {
     static id q = nil;
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
-        q = [NSOperationQueue new];  //TODO use PMKOperationQueue from swift if you can figure out how
+        q = [NSOperationQueue new];
     });
 
     return [AnyPromise promiseWithResolverBlock:^(PMKResolver resolve) {

Categories/Foundation/NSURLConnection+AnyPromise.m

@@ -166,6 +166,7 @@ extension NSURLResponse {
     }
 }
 
+private let Q = NSOperationQueue()
 
 private func fetch(var request: NSURLRequest) -> Promise<(NSData, NSURLResponse)> {
     if request.valueForHTTPHeaderField("User-Agent") == nil {
@@ -175,7 +176,7 @@ private func fetch(var request: NSURLRequest) -> Promise<(NSData, NSURLResponse)
     }
 
     return Promise { fulfill, prereject in
-        NSURLConnection.sendAsynchronousRequest(request, queue: PMKOperationQueue) { rsp, data, err in
+        NSURLConnection.sendAsynchronousRequest(request, queue: Q) { rsp, data, err in
 
             assert(!NSThread.isMainThread())
 

Categories/Foundation/NSURLConnection+Promise.swift

@@ -16,7 +16,7 @@ extension UIViewController {
         proxy.retainCycle = proxy
         vc.mailComposeDelegate = proxy
         presentViewController(vc, animated: animated, completion: completion)
-        proxy.promise.finally(on: zalgo) {
+        proxy.promise.finally {
             self.dismissViewControllerAnimated(animated, completion: nil)
         }
         return proxy.promise

Categories/MessagesUI/MFMailComposeViewController+Promise.swift

@@ -921,7 +921,10 @@ static id PMKCallVariadicBlock(id frock, id result) {
     });
 
     id err = PMKUnhandledExceptionHandler(thrown);
-    if (!err) @throw thrown;
+    if (!err) {
+        NSLog(@"PromiseKit no longer catches *all* exceptions. However you can change this behavior by setting a new PMKProcessUnhandledException handler.");
+        @throw thrown;
+    }
     return err;
 }
 
@@ -1279,14 +1282,14 @@ + (instancetype)promiseWithBooleanAdapter:(void (^)(PMKBooleanAdapter adapter))b
 #import <Foundation/NSError.h>
 #import <Foundation/NSProgress.h>
 #import <Foundation/NSNull.h>
+#import <libkern/OSAtomic.h>
 
 // NSProgress resources:
 //  * https://robots.thoughtbot.com/asynchronous-nsprogress
 //  * http://oleb.net/blog/2014/03/nsprogress/
 // NSProgress! Beware!
 //  * https://github.com/AFNetworking/AFNetworking/issues/2261
 
-
 AnyPromise *PMKWhen(id promises) {
     if (promises == nil)
         return [AnyPromise promiseWithValue:[NSError errorWithDomain:PMKErrorDomain code:PMKInvalidUsageError userInfo:@{NSLocalizedDescriptionKey: @"PMKWhen(nil)"}]];
@@ -1304,54 +1307,57 @@ + (instancetype)promiseWithBooleanAdapter:(void (^)(PMKBooleanAdapter adapter))b
     NSProgress *progress = [NSProgress progressWithTotalUnitCount:[promises count]];
     progress.pausable = NO;
     progress.cancellable = NO;
+#else
+    struct PMKProgress {
+        int completedUnitCount;
+        int totalUnitCount;
+    };
+    __block struct PMKProgress progress;
 #endif
 
-    PMKResolver resolve;
-    AnyPromise *rootPromise = [[AnyPromise alloc] initWithResolver:&resolve];
-    __block void (^fulfill)();
-
-    __block NSInteger countdown = [promises count];
-    void (^yield)(id, id, void(^)(id)) = ^(AnyPromise *promise, id key, void(^set)(id)) {
-        if (![promise isKindOfClass:[AnyPromise class]])
-            promise = [AnyPromise promiseWithValue:promise];
-        [promise pipe:^(id value){
-            if (!rootPromise.pending) {
-                // suppress “already resolved” log message
-            } else if (IsError(value)) {
-              #ifndef PMKDisableProgress
-                progress.completedUnitCount = progress.totalUnitCount;
-              #endif
-                resolve(NSErrorSupplement(value, @{PMKFailingPromiseIndexKey: key}));
-            } else {
-              #ifndef PMKDisableProgress
-                progress.completedUnitCount++;
-              #endif
-                set(promise.value);  // we use -value to unwrap PMKManifolds
-                if (--countdown == 0)
-                    fulfill();
-            }
-        }];
-    };
+    __block int32_t countdown = (int32_t)[promises count];
+    BOOL const isdict = [promises isKindOfClass:[NSDictionary class]];
 
-    if ([promises isKindOfClass:[NSDictionary class]]) {
-        NSMutableDictionary *results = [NSMutableDictionary new];
-        fulfill = ^{ resolve(results); };
+    return [AnyPromise promiseWithResolverBlock:^(PMKResolver resolve) {
+        NSInteger index = 0;
 
-        for (id key in promises) {
-            yield(promises[key], key, ^(id value){
-                results[key] = value;
-            });
-        }
-    } else {
-        NSPointerArray *results = NSPointerArrayMake([promises count]);
-        fulfill = ^{ resolve(results.allObjects); };
+        for (__strong id key in promises) {
+            AnyPromise *promise = isdict ? promises[key] : key;
+            if (!isdict) key = @(index);
 
-        [promises enumerateObjectsUsingBlock:^(id promise, NSUInteger ii, BOOL *stop) {
-            yield(promise, @(ii), ^(id value){
-                [results replacePointerAtIndex:ii withPointer:(__bridge void *)(value ?: [NSNull null])];
-            });
-        }];
-    }
-    
-    return rootPromise;
+            if (![promise isKindOfClass:[AnyPromise class]])
+                promise = [AnyPromise promiseWithValue:promise];
+
+            [promise pipe:^(id value){
+                if (progress.fractionCompleted >= 1)
+                    return;
+
+                if (IsError(value)) {
+                    progress.completedUnitCount = progress.totalUnitCount;
+                    resolve(NSErrorSupplement(value, @{PMKFailingPromiseIndexKey: key}));
+                }
+                else if (OSAtomicDecrement32(&countdown) == 0) {
+                    progress.completedUnitCount = progress.totalUnitCount;
+
+                    id results;
+                    if (isdict) {
+                        results = [NSMutableDictionary new];
+                        for (id key in promises) {
+                            id promise = promises[key];
+                            results[key] = IsPromise(promise) ? ((AnyPromise *)promise).value : promise;
+                        }
+                    } else {
+                        results = [NSMutableArray new];
+                        for (AnyPromise *promise in promises) {
+                            id value = IsPromise(promise) ? (promise.value ?: [NSNull null]) : promise;
+                            [results addObject:value];
+                        }
+                    }
+                    resolve(results);
+                } else {
+                    progress.completedUnitCount++;
+                }
+            }];
+        }
+    }];
 }

PromiseKit.m

@@ -273,6 +273,46 @@ public typealias AnyPromise = PMKPromise
             }
         }
     }
+
+    /**
+     Continue a Promise<T> chain from an AnyPromise.
+    */
+    public func then(on q: dispatch_queue_t = dispatch_get_main_queue(), body: (AnyObject?) -> AnyPromise) -> Promise<AnyObject?> {
+        return Promise { fulfill, reject in
+            pipe { object in
+                if let error = object as? NSError {
+                    reject(error)
+                } else {
+                    contain_zalgo(q) {
+                        body(object).pipe { object in
+                            if let error = object as? NSError {
+                                reject(error)
+                            } else {
+                                fulfill(object)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     Continue a Promise<T> chain from an AnyPromise.
+    */
+    public func then<T>(on q: dispatch_queue_t = dispatch_get_main_queue(), body: (AnyObject?) -> Promise<T>) -> Promise<T> {
+        return Promise(passthru: { resolve in
+            pipe { object in
+                if let error = object as? NSError {
+                    resolve(.Rejected(error))
+                } else {
+                    contain_zalgo(q) {
+                        body(object).pipe(resolve)
+                    }
+                }
+            }
+        })
+    }
 }
 
 
@@ -626,7 +666,7 @@ public class Promise<T> {
       public designated unsealed initializer! Making this convenience would be
       inefficient. Not very inefficient, but still it seems distasteful to me.
      */
-    init(passthru: ((Resolution) -> Void) -> Void) {
+    init(@noescape passthru: ((Resolution) -> Void) -> Void) {
         var resolve: ((Resolution) -> Void)!
         state = UnsealedState(resolver: &resolve)
         passthru(resolve)
@@ -986,6 +1026,12 @@ public func firstly<T>(promise: () -> Promise<T>) -> Promise<T> {
     return promise()
 }
 
+
+public enum ErrorPolicy {
+    case AllErrors
+    case AllErrorsExceptCancellation
+}
+
 public func race<T>(promises: Promise<T>...) -> Promise<T> {
     return Promise(passthru: { resolve in
         for promise in promises {
@@ -1244,15 +1290,18 @@ private func when<T>(promises: [Promise<T>]) -> Promise<Void> {
     var countdown = promises.count
     if countdown == 0 {
         fulfill()
+        return rootPromise
     }
+    let barrier = dispatch_queue_create("org.promisekit.barrier.when", DISPATCH_QUEUE_CONCURRENT)
 
     for (index, promise) in enumerate(promises) {
         promise.pipe { resolution in
-            if rootPromise.pending {
+            if !rootPromise.pending { return }
+
+            dispatch_barrier_sync(barrier) {
                 switch resolution {
                 case .Rejected(let error):
                     progress.completedUnitCount = progress.totalUnitCount
-                    //TODO PMKFailingPromiseIndexKey
                     reject(error)
                 case .Fulfilled:
                     progress.completedUnitCount++