Add .sticky dispatching option

Author: GarthSnyder

Sources/DispatchState.swift

@@ -125,6 +125,9 @@ struct DispatchState: Dispatcher {
                         // Does not change chain dispatcher, but does confirm if appropriate
                         state.location.confirm()
                     }
+                case .sticky:
+                    state.chainStrategy = StickyStrategy()
+                    state.location = .primed
             }
         } else {
             state.chainStrategy = StandardStrategy(dispatcher: state.dispatcher)
@@ -190,7 +193,11 @@ struct DispatchState: Dispatcher {
                 case .default:
                     return (dispatcher: defaultDispatcher, explicit: true)
                 case .chain:
+                    // ChainDispatchStrategy should have claimed this
                     fatalError("`on: .chain` used without a chain dispatcher")
+                case .sticky:
+                    // Repeat previous dispatcher
+                    return (dispatcher: self.dispatcher, explicit: true)
             }
         }
 
@@ -218,13 +225,16 @@ struct StandardStrategy: ChainDispatchStrategy {
         guard let sentinel = given as? SentinelDispatcher else { return nil }
 
         switch sentinel.type {
-        case .default:
-            // Explicit; punt
-            return nil
-        case .unspecified:
-            return (dispatcher: dispatcher, explicit: false)
-        case .chain:
-            return (dispatcher: dispatcher, explicit: true)
+            case .default:
+                // Explicit; punt
+                return nil
+            case .unspecified:
+                return (dispatcher: dispatcher, explicit: false)
+            case .chain:
+                return (dispatcher: dispatcher, explicit: true)
+            case .sticky:
+                return nil
+            
         }
     }
 }
@@ -234,17 +244,19 @@ struct StickyStrategy: ChainDispatchStrategy {
 
     func nextDispatcher(previous: DispatchState, givenDispatcher given: Dispatcher) -> SourcedDispatcher? {
 
-        // Chain dispatcher has nothing to say about explicitly specified dispatchers
-        guard let sentinel = given as? SentinelDispatcher else { return nil }
-        
-        switch sentinel.type {
-        case .default:
-            // Explicit; punt
-            return nil
-        case .unspecified:
-            return (dispatcher: previous.dispatcher, explicit: false)
-        case .chain:
-            return (dispatcher: previous.dispatcher, explicit: true)
+        if let sentinel = given as? SentinelDispatcher {
+            switch sentinel.type {
+                case .default:
+                    // Explicit; punt
+                    return nil
+                case .unspecified:
+                    return (dispatcher: previous.dispatcher, explicit: false)
+                case .chain, .sticky:
+                    return (dispatcher: previous.dispatcher, explicit: true)
+            }
+        } else {
+            // Claim an explicit dispatcher because we do want to ratify the chain dispatcher in this case
+            return (dispatcher: given, explicit: true)
         }
     }
 }

Sources/Dispatcher.swift

@@ -73,6 +73,7 @@ public extension DispatchQueue {
     static let unspecified = DispatchQueue(label: "unspecified.promisekit.org") // Parameter not provided
     static let `default` = DispatchQueue(label: "default.promisekit.org")  // Explicit request for default behavior
     static let chain = DispatchQueue(label: "chain.promisekit.org")  // Execute on same Dispatcher as previous closure
+    static let sticky = DispatchQueue(label: "sticky.promisekit.org")  // Reuse the previous dispatcher if not explicitly specified
 }
 
 public extension DispatchQueue {
@@ -110,7 +111,8 @@ extension DispatchQueue {
             case .unspecified: return SentinelDispatcher(type: .unspecified, flags: flags)
             case .default:     return SentinelDispatcher(type: .default, flags: flags)
             case .chain:       return SentinelDispatcher(type: .chain, flags: flags)
-            default:
+            case .sticky:      return SentinelDispatcher(type: .sticky, flags: flags)
+           default:
                 if let flags = flags {
                     return self.asDispatcher(flags: flags)
                 }

Sources/Dispatchers/SentinelDispatcher.swift

@@ -8,6 +8,7 @@ struct SentinelDispatcher: Dispatcher {
         case unspecified  // Parameter not provided
         case `default`    // Explicit request for global default
         case chain        // Explicit request to use the chain dispatcher
+        case sticky       // Continue using same dispatcher until changed
     }
 
     let type: SentinelType

Tests/Core/ChainDispatcherTests.swift

@@ -237,5 +237,79 @@ class ChainDispatcherTests: XCTestCase {
         XCTAssert(log == "failedToConfirmChainDispatcher")
     }
 
+    func testStickyChainDispatcher() {
+        let ex = expectation(description: "Sticky chain dispatcher")
+        let dispatcher = RecordingDispatcher()
+        let log = captureLog {
+            Promise.value(42).dispatch(on: .sticky).then {
+                Promise.value($0 + 10)
+            }.map {
+                $0 + 20
+            }.done(on: dispatcher) {
+                XCTAssert($0 == 72)
+            }.map {
+                123  // Tail
+            }.catch { error in
+                // NOP - not dispatched
+            }.finally {
+                ex.fulfill()
+            }
+        }
+        waitForExpectations(timeout: 1)
+        XCTAssert(defaultBodyDispatcher.dispatchCount == 2)
+        XCTAssert(defaultTailDispatcher.dispatchCount == 0)
+        XCTAssert(dispatcher.dispatchCount == 3)
+        XCTAssert(log == nil)
+    }
+    
+    func testUnconfirmedStickyChainDispatcher() {
+        let ex = expectation(description: "Unconfirmed sticky chain dispatcher")
+        let dispatcher = RecordingDispatcher()
+        let log = captureLog {
+            Promise.value(42).dispatch(on: .sticky).then(on: dispatcher) {
+                Promise.value($0 + 10)
+            }.map {
+                $0 + 20
+            }.done {
+                XCTAssert($0 == 72)
+            }.map(on: defaultTailDispatcher) {
+                123  // Tail
+            }.catch { error in
+                // NOP - not dispatched
+            }.finally {
+                ex.fulfill()
+            }
+        }
+        waitForExpectations(timeout: 1)
+        XCTAssert(defaultBodyDispatcher.dispatchCount == 0)
+        XCTAssert(defaultTailDispatcher.dispatchCount == 2)
+        XCTAssert(dispatcher.dispatchCount == 3)
+        XCTAssert(log == "failedToConfirmChainDispatcher")
+    }
+
+    func testAdHocStickyDispatchers() {
+        let ex = expectation(description: "Ad hoc sticky dispatching")
+        let dispatcher = RecordingDispatcher()
+        let log = captureLog {
+            Promise.value(42).then(on: dispatcher) {
+                Promise.value($0 + 10)
+            }.map(on: .sticky) {
+                $0 + 20
+            }.done(on: .sticky) {
+                XCTAssert($0 == 72)
+            }.map(on: defaultBodyDispatcher) {
+                123  // Tail
+            }.catch(on: .sticky) { error in
+                // NOP - not dispatched
+            }.finally {
+                ex.fulfill()
+            }
+        }
+        waitForExpectations(timeout: 1)
+        XCTAssert(defaultBodyDispatcher.dispatchCount == 1)
+        XCTAssert(defaultTailDispatcher.dispatchCount == 1)
+        XCTAssert(dispatcher.dispatchCount == 3)
+        XCTAssert(log == nil)
+    }
 }