Update README.md & BasicTests.

Author: inamiy

README.md

@@ -11,63 +11,62 @@ Elegant state machine for Swift.
 ```swift
 enum MyState: StateType {
     case State0, State1, State2
-    case AnyState   // create case=Any
-
-    init(nilLiteral: Void) {
-        self = AnyState
-    }
 }
 ```
 
 ```swift
-let machine = StateMachine<MyState, MyEvent>(state: .State0) { machine in
+// setup state machine
+let machine = Machine<MyState, NoEvent>(state: .State0) { machine in
 
     machine.addRoute(.State0 => .State1)
-    machine.addRoute(nil => .State2) { context in print("Any => 2, msg=\(context.userInfo)") }
-    machine.addRoute(.State2 => nil) { context in print("2 => Any, msg=\(context.userInfo)") }
+    machine.addRoute(.Any => .State2) { context in print("Any => 2, msg=\(context.userInfo)") }
+    machine.addRoute(.State2 => .Any) { context in print("2 => Any, msg=\(context.userInfo)") }
 
-    // add handler (handlerContext = (event, transition, order, userInfo))
+    // add handler (`context = (event, fromState, toState, userInfo)`)
     machine.addHandler(.State0 => .State1) { context in
         print("0 => 1")
     }
 
     // add errorHandler
-    machine.addErrorHandler { (event, transition, order, userInfo) in
+    machine.addErrorHandler { event, fromState, toState, userInfo in
         print("[ERROR] \(transition.fromState) => \(transition.toState)")
     }
 }
 
+// initial
+XCTAssertTrue(machine.state == .State0)
+        
 // tryState 0 => 1 => 2 => 1 => 0
+
 machine <- .State1
+XCTAssertTrue(machine.state == .State1)
+        
 machine <- (.State2, "Hello")
+XCTAssertTrue(machine.state == .State2)
+        
 machine <- (.State1, "Bye")
+XCTAssertTrue(machine.state == .State1)
+        
 machine <- .State0  // fail: no 1 => 0
-
-print("machine.state = \(machine.state)")
+XCTAssertTrue(machine.state == .State1)
 ```
 
 This will print:
 
 ```swift
 0 => 1
-Any => 2, msg=Hello
-2 => Any, msg=Bye
-[ERROR] 1 => 0
-machine.state = 1
+Any => 2, msg=Optional("Hello")
+2 => Any, msg=Optional("Bye")
+[ERROR] State1 => State0
 ```
 
 ### Transition by Event
 
-Use `<-!` operator to try transition by `Event` rather than specifying target `State` ([Test Case](https://github.com/ReactKit/SwiftState/blob/6858f8f49087c4b8b30bd980cfc81e8e74205718/SwiftStateTests/StateMachineEventTests.swift#L54-L76)).
+Use `<-!` operator to try transition by `Event` rather than specifying target `State` ([Test Case](https://github.com/ReactKit/SwiftState/blob/1be67826b3cc9187dfaac85c2e70613f3129fad6/SwiftStateTests/TryEventTests.swift#L32-L54)).
 
 ```swift
-enum MyEvent: StateEventType {
+enum MyEvent: EventType {
     case Event0, Event1
-    case AnyEvent   // create case=Any
-    
-    init(nilLiteral: Void) {
-        self = AnyEvent
-    }
 }
 ```
 
@@ -95,6 +94,8 @@ XCTAssertEqual(machine.state, MyState.State2)
 XCTAssertFalse(success, "Event0 doesn't have 2 => Any")
 ```
 
+If there is no `Event`-based transition, use built-in `NoEvent` instead.
+
 For more examples, please see XCTest cases.
 
 
@@ -106,27 +107,29 @@ For more examples, please see XCTest cases.
     - Try transition + messaging: `machine <- (.State1, "GoGoGo")`
     - Try event: `machine <-! .Event1`
 - Highly flexible transition routing
-    - using Condition
-    - using AnyState (`nil` state)
-    - or both (blacklisting): `nil => nil` + condition
-- Success/Error/Entry/Exit handlers with `order: UInt8` (no before/after handler stuff)
+    - Using `Condition`
+    - Using `.Any` state/event
+    - Blacklisting: `.Any => .Any` + `Condition`
+    - Route Mapping (closure-based routing): [#36](https://github.com/ReactKit/SwiftState/pull/36)
+- Success/Error/Entry/Exit handlers with `order: UInt8` (more flexible than before/after handlers)
 - Removable routes and handlers
 - Chaining: `.State0 => .State1 => .State2`
-- Event: `machine.addRouteEvent("WakeUp", transitions); machine <-! "WakeUp"`
 - Hierarchical State Machine: [#10](https://github.com/ReactKit/SwiftState/pull/10)
 
 ## Terms
 
-Term      | Class                         | Description
---------- | ----------------------------- | ------------------------------------------
-State     | `StateType` (protocol)        | Mostly enum, describing each state e.g. `.State0`.
-Event     | `StateEventType` (protocol)   | Name for route-group. Transition can be fired via `Event` instead of explicitly targeting next `State`.
-Machine   | `StateMachine`                | State transition manager which can register `Route` and `Handler` separately for variety of transitions.
-Transition   | `StateTransition`          | `From-` and `to-` states represented as `.State1 => .State2`. If `nil` is used for either state, it will be represented as `.AnyState`.
-Route     | `StateRoute`                  | `Transition` + `Condition`.
-Condition | `Transition -> Bool`          | Closure for validating transition. If condition returns `false`, transition will fail and associated handlers will not be invoked.
-Handler   | `HandlerContext -> Void`      | Transition callback invoked after state has been changed.
-Chain     | `StateTransitionChain`        | Group of continuous routes represented as `.State1 => .State2 => .State3`
+Term          | Type                          | Description
+------------- | ----------------------------- | ------------------------------------------
+State         | `StateType` (protocol)        | Mostly enum, describing each state e.g. `.State0`.
+Event         | `EventType` (protocol)        | Name for route-group. Transition can be fired via `Event` instead of explicitly targeting next `State`.
+State Machine | `Machine`                     | State transition manager which can register `Route`/`RouteMapping` and `Handler` separately for variety of transitions.
+Transition    | `Transition`                  | `From-` and `to-` states represented as `.State1 => .State2`. Also, `.Any` can be used to represent _any state_.
+Route         | `Route`                       | `Transition` + `Condition`.
+Condition     | `Context -> Bool`             | Closure for validating transition. If condition returns `false`, transition will fail and associated handlers will not be invoked.
+Route Mapping | `(event: E?, fromState: S, userInfo: Any?) -> S?`                | Another way of defining routes **using closure instead of transition arrows (`=>`)**. This is useful when state & event are enum with associated values. Return value (`S?`) means "preferred-toState", where passing `nil` means no routes available. See [#36](https://github.com/ReactKit/SwiftState/pull/36) for more info.
+Handler       | `Context -> Void`             | Transition callback invoked after state has been changed.
+Context       | `(event: E?, fromState: S, toState: S, userInfo: Any?)` | Closure argument for `Condition` & `Handler`.
+Chain         | `TransitionChain` / `RouteChain` | Group of continuous routes represented as `.State1 => .State2 => .State3`
 
 
 ## Related Articles

SwiftStateTests/BasicTests.swift

@@ -13,13 +13,14 @@ class BasicTests: _TestCase
 {
     func testREADME()
     {
+        // setup state machine
         let machine = Machine<MyState, NoEvent>(state: .State0) { machine in
 
             machine.addRoute(.State0 => .State1)
             machine.addRoute(.Any => .State2) { context in print("Any => 2, msg=\(context.userInfo)") }
             machine.addRoute(.State2 => .Any) { context in print("2 => Any, msg=\(context.userInfo)") }
 
-            // add handler (handlerContext = (event, transition, order, userInfo))
+            // add handler (`context = (event, fromState, toState, userInfo)`)
             machine.addHandler(.State0 => .State1) { context in
                 print("0 => 1")
             }
@@ -30,6 +31,9 @@ class BasicTests: _TestCase
             }
         }
 
+        // initial
+        XCTAssertTrue(machine.state == .State0)
+        
         // tryState 0 => 1 => 2 => 1 => 0
 
         machine <- .State1
@@ -43,8 +47,6 @@ class BasicTests: _TestCase
 
         machine <- .State0  // fail: no 1 => 0
         XCTAssertTrue(machine.state == .State1)
-        
-        print("machine.state = \(machine.state)")
     }
 
     func testREADME_string()

SwiftStateTests/MyState.swift

@@ -8,7 +8,7 @@
 
 import SwiftState
 
-enum MyState: Int, StateType
+enum MyState: StateType
 {
     case State0, State1, State2, State3
 }