Lowercased enum cases in documentation and comments.

Author: mattprowse

README.md

@@ -10,20 +10,20 @@ Elegant state machine for Swift.
 
 ```swift
 enum MyState: StateType {
-    case State0, State1, State2
+    case state0, state1, state2
 }
 ```
 
 ```swift
 // setup state machine
-let machine = StateMachine<MyState, NoEvent>(state: .State0) { machine in
+let machine = StateMachine<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)") }
+    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 (`context = (event, fromState, toState, userInfo)`)
-    machine.addHandler(.State0 => .State1) { context in
+    machine.addHandler(.state0 => .state1) { context in
         print("0 => 1")
     }
 
@@ -34,21 +34,21 @@ let machine = StateMachine<MyState, NoEvent>(state: .State0) { machine in
 }
 
 // initial
-XCTAssertEqual(machine.state, MyState.State0)
+XCTAssertEqual(machine.state, MyState.state0)
 
 // tryState 0 => 1 => 2 => 1 => 0
 
-machine <- .State1
-XCTAssertEqual(machine.state, MyState.State1)
+machine <- .state1
+XCTAssertEqual(machine.state, MyState.state1)
 
-machine <- (.State2, "Hello")
-XCTAssertEqual(machine.state, MyState.State2)
+machine <- (.state2, "Hello")
+XCTAssertEqual(machine.state, MyState.state2)
 
-machine <- (.State1, "Bye")
-XCTAssertEqual(machine.state, MyState.State1)
+machine <- (.state1, "Bye")
+XCTAssertEqual(machine.state, MyState.state1)
 
-machine <- .State0  // fail: no 1 => 0
-XCTAssertEqual(machine.state, MyState.State1)
+machine <- .state0  // fail: no 1 => 0
+XCTAssertEqual(machine.state, MyState.state1)
 ```
 
 This will print:
@@ -57,7 +57,7 @@ This will print:
 0 => 1
 Any => 2, msg=Optional("Hello")
 2 => Any, msg=Optional("Bye")
-[ERROR] State1 => State0
+[ERROR] state1 => state0
 ```
 
 ### Transition by Event
@@ -66,39 +66,39 @@ Use `<-!` operator to try transition by `Event` rather than specifying target `S
 
 ```swift
 enum MyEvent: EventType {
-    case Event0, Event1
+    case event0, event1
 }
 ```
 
 ```swift
-let machine = StateMachine<MyState, MyEvent>(state: .State0) { machine in
+let machine = StateMachine<MyState, MyEvent>(state: .state0) { machine in
 
     // add 0 => 1 => 2
-    machine.addRoutes(event: .Event0, transitions: [
-        .State0 => .State1,
-        .State1 => .State2,
+    machine.addRoutes(event: .event0, transitions: [
+        .state0 => .state1,
+        .state1 => .state2,
     ])
 
     // add event handler
-    machine.addHandler(event: .Event0) { context in
-        print(".Event0 triggered!")
+    machine.addHandler(event: .event0) { context in
+        print(".event0 triggered!")
     }
 }
 
 // initial
-XCTAssertEqual(machine.state, MyState.State0)
+XCTAssertEqual(machine.state, MyState.state0)
 
 // tryEvent
-machine <-! .Event0
-XCTAssertEqual(machine.state, MyState.State1)
+machine <-! .event0
+XCTAssertEqual(machine.state, MyState.state1)
 
 // tryEvent
-machine <-! .Event0
-XCTAssertEqual(machine.state, MyState.State2)
+machine <-! .event0
+XCTAssertEqual(machine.state, MyState.state2)
 
 // tryEvent (fails)
-machine <-! .Event0
-XCTAssertEqual(machine.state, MyState.State2, "Event0 doesn't have 2 => Any")
+machine <-! .event0
+XCTAssertEqual(machine.state, MyState.state2, "event0 doesn't have 2 => Any")
 ```
 
 If there is no `Event`-based transition, use built-in `NoEvent` instead.
@@ -116,25 +116,25 @@ For example:
 
 ```swift
 enum StrState: StateType {
-    case Str(String) ...
+    case str(String) ...
 }
 enum StrEvent: EventType {
-    case Str(String) ...
+    case str(String) ...
 }
 
-let machine = Machine<StrState, StrEvent>(state: .Str("initial")) { machine in
+let machine = Machine<StrState, StrEvent>(state: .str("initial")) { machine in
 
     machine.addRouteMapping { event, fromState, userInfo -> StrState? in
         // no route for no-event
         guard let event = event else { return nil }
 
         switch (event, fromState) {
-            case (.Str("gogogo"), .Str("initial")):
-                return .Str("Phase 1")
-            case (.Str("gogogo"), .Str("Phase 1")):
-                return .Str("Phase 2")
-            case (.Str("finish"), .Str("Phase 2")):
-                return .Str("end")
+            case (.str("gogogo"), .str("initial")):
+                return .str("Phase 1")
+            case (.str("gogogo"), .str("Phase 1")):
+                return .str("Phase 2")
+            case (.str("finish"), .str("Phase 2")):
+                return .str("end")
             default:
                 return nil
         }
@@ -143,31 +143,31 @@ let machine = Machine<StrState, StrEvent>(state: .Str("initial")) { machine in
 }
 
 // initial
-XCTAssertEqual(machine.state, StrState.Str("initial"))
+XCTAssertEqual(machine.state, StrState.str("initial"))
 
 // tryEvent (fails)
-machine <-! .Str("go?")
-XCTAssertEqual(machine.state, StrState.Str("initial"), "No change.")
+machine <-! .str("go?")
+XCTAssertEqual(machine.state, StrState.str("initial"), "No change.")
 
 // tryEvent
-machine <-! .Str("gogogo")
-XCTAssertEqual(machine.state, StrState.Str("Phase 1"))
+machine <-! .str("gogogo")
+XCTAssertEqual(machine.state, StrState.str("Phase 1"))
 
 // tryEvent (fails)
-machine <-! .Str("finish")
-XCTAssertEqual(machine.state, StrState.Str("Phase 1"), "No change.")
+machine <-! .str("finish")
+XCTAssertEqual(machine.state, StrState.str("Phase 1"), "No change.")
 
 // tryEvent
-machine <-! .Str("gogogo")
-XCTAssertEqual(machine.state, StrState.Str("Phase 2"))
+machine <-! .str("gogogo")
+XCTAssertEqual(machine.state, StrState.str("Phase 2"))
 
 // tryEvent (fails)
-machine <-! .Str("gogogo")
-XCTAssertEqual(machine.state, StrState.Str("Phase 2"), "No change.")
+machine <-! .str("gogogo")
+XCTAssertEqual(machine.state, StrState.str("Phase 2"), "No change.")
 
 // tryEvent
-machine <-! .Str("finish")
-XCTAssertEqual(machine.state, StrState.Str("end"))
+machine <-! .str("finish")
+XCTAssertEqual(machine.state, StrState.str("end"))
 ```
 
 This behaves very similar to JavaScript's safe state-container [rackt/Redux](https://github.com/rackt/redux), where `RouteMapping` can be interpretted as `Redux.Reducer`.
@@ -178,40 +178,40 @@ For more examples, please see XCTest cases.
 ## Features
 
 - Easy Swift syntax
-    - Transition: `.State0 => .State1`, `[.State0, .State1] => .State2`
-    - Try state: `machine <- .State1`
-    - Try state + messaging: `machine <- (.State1, "GoGoGo")`
-    - Try event: `machine <-! .Event1`
+    - Transition: `.state0 => .state1`, `[.state0, .state1] => .state2`
+    - Try state: `machine <- .state1`
+    - Try state + messaging: `machine <- (.state1, "GoGoGo")`
+    - Try event: `machine <-! .event1`
 - Highly flexible transition routing
     - Using `Condition`
-    - Using `.Any` state
-        - Entry handling: `.Any => .SomeState`
-        - Exit handling: `.SomeState => .Any`
-        - Blacklisting: `.Any => .Any` + `Condition`
-    - Using `.Any` event
+    - Using `.any` state
+        - Entry handling: `.any => .someState`
+        - Exit handling: `.someState => .any`
+        - Blacklisting: `.any => .any` + `Condition`
+    - Using `.any` event
 
     - Route Mapping (closure-based routing): [#36](https://github.com/ReactKit/SwiftState/pull/36)
 - Success/Error handlers with `order: UInt8` (more flexible than before/after handlers)
 - Removable routes and handlers using `Disposable`
-- Route Chaining: `.State0 => .State1 => .State2`
+- Route Chaining: `.state0 => .state1 => .state2`
 - Hierarchical State Machine: [#10](https://github.com/ReactKit/SwiftState/pull/10)
 
 
 ## Terms
 
 Term          | Type                          | Description
 ------------- | ----------------------------- | ------------------------------------------
-State         | `StateType` (protocol)        | Mostly enum, describing each state e.g. `.State0`.
+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_.
+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.
-State Route Mapping | `(fromState: S, userInfo: Any?) -> [S]?`                | Another way of defining routes **using closure instead of transition arrows (`=>`)**. This is useful when state is enum with associated values. Return value (`[S]?`) means multiple `toState`s from single `fromState` (synonym for multiple routing e.g. `.State0 => [.State1, .State2]`). See [#36](https://github.com/ReactKit/SwiftState/pull/36) for more info.
+State Route Mapping | `(fromState: S, userInfo: Any?) -> [S]?`                | Another way of defining routes **using closure instead of transition arrows (`=>`)**. This is useful when state is enum with associated values. Return value (`[S]?`) means multiple `toState`s from single `fromState` (synonym for multiple routing e.g. `.state0 => [.state1, .state2]`). See [#36](https://github.com/ReactKit/SwiftState/pull/36) for more info.
 Handler       | `Context -> Void`             | Transition callback invoked when state has been changed successfully.
 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`
+Chain         | `TransitionChain` / `RouteChain` | Group of continuous routes represented as `.state1 => .state2 => .state3`
 
 
 ## Related Articles

Sources/EventType.swift

@@ -10,7 +10,7 @@ public protocol EventType: Hashable {}
 
 // MARK: Event
 
-/// `EventType` wrapper for handling `.Any` event.
+/// `EventType` wrapper for handling `.any` event.
 public enum Event<E: EventType>
 {
     case some(E)

Sources/Machine.swift

@@ -73,7 +73,7 @@ public class Machine<S: StateType, E: EventType>
         guard let fromState = transition.fromState.rawValue,
             let toState = transition.toState.rawValue else
         {
-            assertionFailure("State = `.Any` is not supported for `hasRoute()` (always returns `false`)")
+            assertionFailure("State = `.any` is not supported for `hasRoute()` (always returns `false`)")
             return false
         }
 
@@ -164,7 +164,7 @@ public class Machine<S: StateType, E: EventType>
             for (transition, keyConditionDict) in routeDict {
                 if transition.fromState == .some(self.state) || transition.fromState == .any {
                     for (_, condition) in keyConditionDict {
-                        // if toState is `.Any`, always treat as identity transition
+                        // if toState is `.any`, always treat as identity transition
                         let toState = transition.toState.rawValue ?? self.state
 
                         if _canPassCondition(condition, forEvent: event, fromState: self.state, toState: toState, userInfo: userInfo) {

Sources/Route.swift

@@ -23,10 +23,10 @@ public struct Route<S: StateType, E: EventType>
 // MARK: - Custom Operators
 //--------------------------------------------------
 
-/// e.g. [.State0, .State1] => .State, allowing [0 => 2, 1 => 2]
+/// e.g. [.state0, .state1] => .state, allowing [0 => 2, 1 => 2]
 public func => <S: StateType, E: EventType>(leftStates: [S], right: State<S>) -> Route<S, E>
 {
-    // NOTE: don't reuse ".Any => .Any + condition" for efficiency
+    // NOTE: don't reuse ".any => .any + condition" for efficiency
     return Route(transition: .any => right, condition: { context -> Bool in
         return leftStates.contains(context.fromState)
     })
@@ -37,7 +37,7 @@ public func => <S: StateType, E: EventType>(leftStates: [S], right: S) -> Route<
     return leftStates => .some(right)
 }
 
-/// e.g. .State0 => [.State1, .State], allowing [0 => 1, 0 => 2]
+/// e.g. .state0 => [.state1, .state], allowing [0 => 1, 0 => 2]
 public func => <S: StateType, E: EventType>(left: State<S>, rightStates: [S]) -> Route<S, E>
 {
     return Route(transition: left => .any, condition: { context -> Bool in
@@ -50,7 +50,7 @@ public func => <S: StateType, E: EventType>(left: S, rightStates: [S]) -> Route<
     return .some(left) => rightStates
 }
 
-/// e.g. [.State0, .State1] => [.State, .State3], allowing [0 => 2, 0 => 3, 1 => 2, 1 => 3]
+/// e.g. [.state0, .state1] => [.state, .state3], allowing [0 => 2, 0 => 3, 1 => 2, 1 => 3]
 public func => <S: StateType, E: EventType>(leftStates: [S], rightStates: [S]) -> Route<S, E>
 {
     return Route(transition: .any => .any, condition: { context -> Bool in

Sources/StateMachine.swift

@@ -15,7 +15,7 @@
 public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
 {
     /// Closure-based routes for `tryState()`.
-    /// - Returns: Multiple `toState`s from single `fromState`, similar to `.State0 => [.State1, .State2]`
+    /// - Returns: Multiple `toState`s from single `fromState`, similar to `.state0 => [.state1, .state2]`
     public typealias StateRouteMapping = (_ fromState: S, _ userInfo: Any?) -> [S]?
 
     private lazy var _routes: _RouteDict = [:]
@@ -52,7 +52,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
         guard let fromState = transition.fromState.rawValue,
             let toState = transition.toState.rawValue else
         {
-            assertionFailure("State = `.Any` is not supported for `hasRoute()` (always returns `false`)")
+            assertionFailure("State = `.any` is not supported for `hasRoute()` (always returns `false`)")
             return false
         }
 

Sources/StateType.swift

@@ -10,7 +10,7 @@ public protocol StateType: Hashable {}
 
 // MARK: State
 
-/// `StateType` wrapper for handling `.Any` state.
+/// `StateType` wrapper for handling `.any` state.
 public enum State<S: StateType>
 {
     case some(S)

Sources/Transition.swift

@@ -7,8 +7,8 @@
 //
 
 ///
-/// "From-" and "to-" states represented as `.State1 => .State2`.
-/// Also, `.Any` can be used to represent _any state_.
+/// "From-" and "to-" states represented as `.state1 => .state2`.
+/// Also, `.any` can be used to represent _any state_.
 ///
 public struct Transition<S: StateType>: Hashable
 {
@@ -54,7 +54,7 @@ public func == <S: StateType>(left: Transition<S>, right: Transition<S>) -> Bool
 
 infix operator => : AdditionPrecedence
 
-/// e.g. .State0 => .State1
+/// e.g. .state0 => .state1
 public func => <S: StateType>(left: State<S>, right: State<S>) -> Transition<S>
 {
     return Transition(fromState: left, toState: right)

Sources/TransitionChain.swift

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014年 Yasuhiro Inami. All rights reserved.
 //
 
-/// Group of continuous `Transition`s represented as `.State1 => .State2 => .State3`.
+/// Group of continuous `Transition`s represented as `.state1 => .state2 => .state3`.
 public struct TransitionChain<S: StateType>
 {
     public private(set) var states: [State<S>]
@@ -37,7 +37,7 @@ public struct TransitionChain<S: StateType>
 // MARK: - Custom Operators
 //--------------------------------------------------
 
-// e.g. (.State0 => .State1) => .State
+// e.g. (.state0 => .state1) => .state
 public func => <S: StateType>(left: Transition<S>, right: State<S>) -> TransitionChain<S>
 {
     return TransitionChain(states: [left.fromState, left.toState]) => right
@@ -58,7 +58,7 @@ public func => <S: StateType>(left: TransitionChain<S>, right: S) -> TransitionC
     return left => .some(right)
 }
 
-// e.g. .State0 => (.State1 => .State)
+// e.g. .state0 => (.state1 => .state)
 public func => <S: StateType>(left: State<S>, right: Transition<S>) -> TransitionChain<S>
 {
     return left => TransitionChain(states: [right.fromState, right.toState])

Tests/BasicTests.swift

@@ -61,7 +61,7 @@ class BasicTests: _TestCase
 
             // add event handler
             machine.addHandler(event: .event0) { context in
-                print(".Event0 triggered!")
+                print(".event0 triggered!")
             }
         }