added new method to add phases

Author: jvk75

ParallelSwift.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = 'ParallelSwift'
-  s.version          = '1.2.0'
+  s.version          = '1.3.0'
   s.summary          = 'Execute multiple methods in parallel with simple API.'
 
 

ParallelSwift/ParallelSwift.swift

@@ -51,7 +51,18 @@ public class ParallelSwift {
     public func addPhase(_ executionThread: ExecutionThread = .background,  phase: @escaping ( @escaping () -> () ) -> ()) {
         phases.append((executionThread, phase))
     }
-    
+
+    /// Add execution phases as array (variadic function). Once the input closure of a phase is called phase in considered finnished.
+    ///
+    /// With optional thread parameter (all phases in the iput array are executed in the same way.
+    /// - .main : phase is executed in main thread
+    /// - .background (default) : phase is excuted at background
+    public func addPhases(_ executionThread: ExecutionThread = .background, phases: ( @escaping () -> () ) -> ()...) {
+        phases.forEach {
+            self.phases.append((executionThread, $0))
+        }
+    }
+
     /// Start all phases in parallel. ExecutionMode defines when completion is called (see documentation)
     public func execute(_ type: ExecutionType = .all,  complete: @escaping () -> ()) {
         self.numberOfPhases = phases.count

README.md

@@ -34,10 +34,11 @@ Execution closure is executed immediately after phases are started.
 
 ## Usage 
 
-Add methods to be executed as  closure with ```addPhases``` 
+Add methods to be executed as  closure with ```addPhase``` (one by one) or with ```addPhases``` (as array).
+Both methods take one parameter that defines where the phase/s are executed (.main or .background (default)) 
 Once excute is called all phases are launch simultaneusly (in parallel). 
 
-Methods will mark themself finnished a by calling  ```done``` .
+Methods will mark themself finnished a by calling input closure (e.g. ```done``` in the example) .
 
 Execution completion closure is always executed in main thread. See modes.
 
@@ -52,7 +53,7 @@ Execution completion closure is always executed in main thread. See modes.
        print("2")
        done()
     }
-    p.addPhase { done in
+    p.addPhase(.main) { done in
         print("3")
         done()
     }
@@ -61,6 +62,8 @@ Execution completion closure is always executed in main thread. See modes.
     }
 ```
 
+See tests for more use cases.
+
 ### Parameters
 
 ```timeout``` : Time in seconds after which execute completion is called even if phases are still running. *Default: 0 (no timeout)*

Test/ParallelTest/ParallelTests/ParallelTestTests.swift

@@ -51,7 +51,36 @@ class ParallelTests: XCTestCase {
             }
         }
     }
-    
+
+    func doPhasesVariadic() {
+        p = ParallelSwift()
+        result = ""
+        p?.timeout = 0
+        p?.addPhases(phases:
+            { done in
+                DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 1){
+                    print("1")
+                    self.result.append("1")
+                    done()
+                }
+            },
+            { done in
+                DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 2){
+                    print("2")
+                    self.result.append("2")
+                    done()
+                }
+            },
+            { done in
+                DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 3){
+                    print("3")
+                    self.result.append("3")
+                    done()
+                }
+            }
+        )
+    }
+
     func testTimeoutAll() {
 
         let e = expectation(description: "time")
@@ -90,20 +119,37 @@ class ParallelTests: XCTestCase {
 
         let e = expectation(description: "all")
         doPhases()
-        
+
         p?.sufflePhases = true
-        
+
         p?.execute(.all) {
             XCTAssert(self.result == "123")
             e.fulfill()
             print("all done")
         }
-        
+
         waitForExpectations(timeout: 4, handler: { _ in
             print("Test done")
         })
     }
-    
+    func testModeAllVariadic() {
+
+        let e = expectation(description: "all")
+        doPhasesVariadic()
+
+        p?.sufflePhases = true
+
+        p?.execute(.all) {
+            XCTAssert(self.result == "123")
+            e.fulfill()
+            print("all done")
+        }
+
+        waitForExpectations(timeout: 4, handler: { _ in
+            print("Test done")
+        })
+    }
+
     func testModeAny() {
 
         let e = expectation(description: "any")