Improve addAnyHandler().

Author: inamiy

Sources/StateMachine.swift

@@ -268,7 +268,9 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     //--------------------------------------------------
 
     // MARK: addHandler (no-event)
-    
+
+    /// Add `handler` that is called when `tryState()` succeeds for target `transition`.
+    /// - Note: `handler` will not be invoked for `tryEvent()`.
     public func addHandler(transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
     {
         if self._handlers[transition] == nil {
@@ -310,10 +312,17 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
 
     // MARK: addAnyHandler (event-based & state-based)
 
-    public func addAnyHandler(order order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    /// Add `handler` that is called when either `tryEvent()` or `tryState()` succeeds for target `transition`.
+    public func addAnyHandler(transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
     {
-        let disposable1 = self.addHandler(.Any => .Any, order: order, handler: handler)
-        let disposable2 = self.addHandler(event: .Any, order: order, handler: handler)
+        let disposable1 = self.addHandler(transition, order: order, handler: handler)
+        let disposable2 = self.addHandler(event: .Any, order: order) { context in
+            if (transition.fromState == .Any || transition.fromState == context.fromState) &&
+                (transition.toState == .Any || transition.toState == context.toState)
+            {
+                handler(context)
+            }
+        }
 
         return ActionDisposable {
             disposable1.dispose()

Tests/StateMachineEventTests.swift

@@ -381,7 +381,7 @@ class StateMachineEventTests: _TestCase
 
     func testAddAnyHandler()
     {
-        var invokeCount = 0
+        var invokeCounts = [0, 0, 0, 0, 0, 0]
 
         let machine = StateMachine<MyState, MyEvent>(state: .State0) { machine in
 
@@ -394,28 +394,54 @@ class StateMachineEventTests: _TestCase
             // add 2 => 3 (state-based)
             machine.addRoute(.State2 => .State3)
 
+            //
             // addAnyHandler (for both event-based & state-based)
-            machine.addAnyHandler { context in
-                invokeCount++
-                return
+            //
+
+            machine.addAnyHandler(.State0 => .State1) { context in
+                invokeCounts[0]++
+            }
+
+            machine.addAnyHandler(.State1 => .State2) { context in
+                invokeCounts[1]++
+            }
+
+            machine.addAnyHandler(.State2 => .State3) { context in
+                invokeCounts[2]++
+            }
+
+            machine.addAnyHandler(.Any => .State3) { context in
+                invokeCounts[3]++
+            }
+
+            machine.addAnyHandler(.State0 => .Any) { context in
+                invokeCounts[4]++
+            }
+
+            machine.addAnyHandler(.Any => .Any) { context in
+                invokeCounts[5]++
             }
 
         }
 
+        // initial
+        XCTAssertEqual(machine.state, MyState.State0)
+        XCTAssertEqual(invokeCounts, [0, 0, 0, 0, 0, 0])
+
         // tryEvent
         machine <-! .Event0
         XCTAssertEqual(machine.state, MyState.State1)
-        XCTAssertEqual(invokeCount, 1)
+        XCTAssertEqual(invokeCounts, [1, 0, 0, 0, 1, 1])
 
         // tryEvent
         machine <-! .Event0
         XCTAssertEqual(machine.state, MyState.State2)
-        XCTAssertEqual(invokeCount, 2)
+        XCTAssertEqual(invokeCounts, [1, 1, 0, 0, 1, 2])
 
         // tryState
         machine <- .State3
         XCTAssertEqual(machine.state, MyState.State3)
-        XCTAssertEqual(invokeCount, 3)
+        XCTAssertEqual(invokeCounts, [1, 1, 1, 1, 1, 3])
 
     }