Add progress(progressTupleClosure)

Author: inamiy

SwiftTask/SwiftTask.swift

@@ -93,8 +93,13 @@ public class Task<Progress, Value, Error>
 
     internal var machine: Machine!
 
+    /// progress value
     public internal(set) var progress: Progress?
+    
+    /// fulfilled value
     public internal(set) var value: Value?
+    
+    /// rejected/cancelled tuple info
     public internal(set) var errorInfo: ErrorInfo?
 
     public var state: TaskState
@@ -194,7 +199,8 @@ public class Task<Progress, Value, Error>
         }
 
         // TODO: how to nest these inside StateMachine's initClosure? (using `self` is not permitted)
-        self.machine.addEventHandler(.Progress, order: 90) { [weak self] context in
+        // NOTE: use order > 100 (default) to let `progressTupleClosure(self.progress, newValue)` be invoked first before updating old `self.progress`
+        self.machine.addEventHandler(.Progress, order: 110) { [weak self] context in
             if let progress = context.userInfo as? Progress {
                 if let self_ = self {
                     self_.progress = progress
@@ -272,6 +278,7 @@ public class Task<Progress, Value, Error>
         self._cancel(error: nil)
     }
 
+    /// progress + newValue only
     public func progress(progressClosure: Progress -> Void) -> Task
     {
         self.machine.addEventHandler(.Progress) { [weak self] context in
@@ -283,6 +290,20 @@ public class Task<Progress, Value, Error>
         return self
     }
 
+    /// progress + (oldValue, newValue)
+    public func progress(progressTupleClosure: (oldValue: Progress?, newValue: Progress) -> Void) -> Task
+    {
+        self.machine.addEventHandler(.Progress) { [weak self] context in
+            if let progress = context.userInfo as? Progress {
+                if let self_ = self {
+                    progressTupleClosure(oldValue: self_.progress, newValue: progress)
+                }
+            }
+        }
+        
+        return self
+    }
+    
     /// then (fulfilled & rejected) + returning value
     public func then<Value2>(thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>
     {

SwiftTaskTests/SwiftTaskTests.swift

@@ -478,6 +478,50 @@ class SwiftTaskTests: _TestCase
         self.wait()
     }
 
+    func testProgressTuple()
+    {
+        var expect = self.expectationWithDescription(__FUNCTION__)
+        var progressCount = 0
+        
+        Task<Float, String, ErrorString> { (progress, fulfill, reject, configure) in
+            
+            self.perform {
+                progress(0.5)
+                progress(1.0)
+                fulfill("OK")
+            }
+            
+        }.progress { (oldValue: Float?, newValue: Float) in     // progressTupleClosure
+            
+            progressCount++
+            
+            if self.isAsync {
+                if !((oldValue == nil && newValue == 0.5) || (oldValue! == 0.5 && newValue == 1.0)) {
+                    XCTFail("Invalid progressTuple (\(oldValue), \(newValue)).")
+                }
+            }
+            else {
+                XCTFail("When isAsync=false, 1st task closure is already performed before registering this progress closure, so this closure should not be reached.")
+            }
+            
+        }.then { (value: String) -> Void in
+            
+            XCTAssertEqual(value, "OK")
+            
+            if self.isAsync {
+                XCTAssertEqual(progressCount, 2)
+            }
+            else {
+                XCTAssertLessThanOrEqual(progressCount, 0, "progressCount should be 0 because progress closure should not be invoked when isAsync=false")
+            }
+            
+            expect.fulfill()
+                
+        }
+        
+        self.wait()
+    }
+    
     //--------------------------------------------------
     // MARK: - Cancel
     //--------------------------------------------------