Add state for onEnter and onExit events

Gray-Wind · Gray-Wind · commit 7c7969d05eef · 2022-02-28T13:54:24.000+02:00
diff --git a/Swift/Sources/StateMachine/StateMachine.swift b/Swift/Sources/StateMachine/StateMachine.swift
@@ -56,7 +56,7 @@ open class StateMachine<State: StateMachineHashable, Event: StateMachineHashable
     private let states: States
     private var observers: [Observer] = []
 
-    private typealias EnterExitAction = () -> Void
+    private typealias EnterExitAction = (State) throws -> Void
 
     private var onEnterActions: [State.HashableIdentifier: EnterExitAction]
     private var onExitActions: [State.HashableIdentifier: EnterExitAction]
@@ -127,13 +127,15 @@ open class StateMachine<State: StateMachineHashable, Event: StateMachineHashable
                                                          event: event,
                                                          toState: action.toState ?? state,
                                                          sideEffect: action.sideEffect)
+                let fromState = state
                 if let toState: State = action.toState {
                     state = toState
                 }
 
-                if stateIdentifier != state.hashableIdentifier {
-                    onExitActions[stateIdentifier]?()
-                    onEnterActions[state.hashableIdentifier]?()
+                // if not `dontTransition`
+                if action.toState != nil {
+                    try onExitActions[stateIdentifier]?(fromState)
+                    try onEnterActions[state.hashableIdentifier]?(state)
                 }
 
                 result = .success(transition)
@@ -201,11 +203,11 @@ extension StateMachineBuilder {
         .state(state: state, events: build())
     }
 
-    public static func onEnter(_ perform: @escaping () -> Void) -> [EventHandler] {
+    public static func onEnter(_ perform: @escaping (State) throws -> Void) -> [EventHandler] {
         [EventHandler(event: nil, action: nil, eventType: .onEnter(perform))]
     }
 
-    public static func onExit(_ perform: @escaping () -> Void) -> [EventHandler] {
+    public static func onExit(_ perform: @escaping (State) throws -> Void) -> [EventHandler] {
         [EventHandler(event: nil, action: nil, eventType: .onExit(perform))]
     }
 
@@ -312,15 +314,15 @@ public enum StateMachineTypes {
         }
     }
 
-    fileprivate enum EventType {
-        case normal, onEnter(() -> Void), onExit(() -> Void)
+    fileprivate enum EventType<State> {
+        case normal, onEnter((State) throws -> Void), onExit((State) throws -> Void)
     }
 
     public struct EventHandler<State: StateMachineHashable, Event: StateMachineHashable, SideEffect> {
 
         fileprivate let event: Event.HashableIdentifier?
         fileprivate let action: Action<State, Event, SideEffect>.Factory?
-        fileprivate var eventType = EventType.normal
+        fileprivate var eventType = EventType<State>.normal
     }
 
     public struct Action<State: StateMachineHashable, Event: StateMachineHashable, SideEffect> {
diff --git a/Swift/Tests/StateMachineTests/StateMachine_Matter_Tests.swift b/Swift/Tests/StateMachineTests/StateMachine_Matter_Tests.swift
@@ -46,21 +46,21 @@ final class StateMachine_Matter_Tests: XCTestCase, StateMachineBuilder {
         MatterStateMachine {
             initialState(_state)
             state(.solid) {
-                onEnter {
+                onEnter { _ in
                     logger.log(Message.enteredSolid.rawValue)
                 }
-                onExit {
+                onExit { _ in
                     logger.log(Message.exitSolid.rawValue)
                 }
                 on(.melt) {
                     transition(to: .liquid, emit: .logMelted)
                 }
             }
             state(.liquid) {
-                onEnter {
+                onEnter { _ in
                     logger.log(Message.enteredLiquid.rawValue)
                 }
-                onExit {
+                onExit { _ in
                     logger.log(Message.exitLiquid.rawValue)
                 }
                 on(.freeze) {
@@ -71,10 +71,10 @@ final class StateMachine_Matter_Tests: XCTestCase, StateMachineBuilder {
                 }
             }
             state(.gas) {
-                onEnter {
+                onEnter { _ in
                     logger.log(Message.enteredGas.rawValue)
                 }
-                onExit {
+                onExit { _ in
                     logger.log(Message.exitGas.rawValue)
                 }
                 on(.condense) {
diff --git a/Swift/Tests/StateMachineTests/StateMachine_Turnstile_Tests.swift b/Swift/Tests/StateMachineTests/StateMachine_Turnstile_Tests.swift
@@ -45,11 +45,13 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
         TurnstileStateMachine {
             initialState(_state)
             state(.locked) {
-                onEnter {
-                    logger.log(Message.enterLocked.rawValue)
+                onEnter { state in
+                    let credit: Int = try state.credit()
+                    logger.log("\(Message.enterLocked.rawValue) \(credit)")
                 }
-                onExit {
-                    logger.log(Message.exitLocked.rawValue)
+                onExit { state in
+                    let credit: Int = try state.credit()
+                    logger.log("\(Message.exitLocked.rawValue) \(credit)")
                 }
                 on(.insertCoin) { locked, insertCoin in
                     let newCredit: Int = try locked.credit() + insertCoin.value()
@@ -67,21 +69,21 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
                 }
             }
             state(.unlocked) {
-                onEnter {
+                onEnter { _ in
                     logger.log(Message.enterUnlocked.rawValue)
                 }
-                onExit {
+                onExit { _ in
                     logger.log(Message.exitUnlocked.rawValue)
                 }
                 on(.admitPerson) {
                     transition(to: .locked(credit: 0), emit: .closeDoors)
                 }
             }
             state(.broken) {
-                onEnter {
+                onEnter { _ in
                     logger.log(Message.enterBroken.rawValue)
                 }
-                onExit {
+                onExit { _ in
                     logger.log(Message.exitBroken.rawValue)
                 }
                 on(.machineRepairDidComplete) { broken in
@@ -123,7 +125,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
                                                     event: .insertCoin(10),
                                                     toState: .locked(credit: 10),
                                                     sideEffect: nil)))
-        expect(self.logger).to(noLog())
+        expect(self.logger).to(log("\(Message.exitLocked) 0", "\(Message.enterLocked) 10"))
     }
 
     func test_givenStateIsLocked_whenInsertCoin_andCreditEqualsFarePrice_shouldTransitionToUnlockedStateAndOpenDoors() throws {
@@ -140,7 +142,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
                                                     event: .insertCoin(15),
                                                     toState: .unlocked,
                                                     sideEffect: .openDoors)))
-        expect(self.logger).to(log(Message.exitLocked.rawValue, Message.enterUnlocked.rawValue))
+        expect(self.logger).to(log("\(Message.exitLocked) 35", Message.enterUnlocked.rawValue))
     }
 
     func test_givenStateIsLocked_whenInsertCoin_andCreditMoreThanFarePrice_shouldTransitionToUnlockedStateAndOpenDoors() throws {
@@ -157,7 +159,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
                                                     event: .insertCoin(20),
                                                     toState: .unlocked,
                                                     sideEffect: .openDoors)))
-        expect(self.logger).to(log(Message.exitLocked.rawValue, Message.enterUnlocked.rawValue))
+        expect(self.logger).to(log("\(Message.exitLocked) 35", Message.enterUnlocked.rawValue))
     }
 
     func test_givenStateIsLocked_whenAdmitPerson_shouldTransitionToLockedStateAndSoundAlarm() throws {
@@ -191,7 +193,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
                                                     event: .machineDidFail,
                                                     toState: .broken(oldState: .locked(credit: 15)),
                                                     sideEffect: .orderRepair)))
-        expect(self.logger).to(log(Message.exitLocked.rawValue, Message.enterBroken.rawValue))
+        expect(self.logger).to(log("\(Message.exitLocked.rawValue) 15", Message.enterBroken.rawValue))
     }
 
     func test_givenStateIsUnlocked_whenAdmitPerson_shouldTransitionToLockedStateAndCloseDoors() throws {
@@ -208,7 +210,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
                                                     event: .admitPerson,
                                                     toState: .locked(credit: 0),
                                                     sideEffect: .closeDoors)))
-        expect(self.logger).to(log(Message.exitUnlocked.rawValue, Message.enterLocked.rawValue))
+        expect(self.logger).to(log(Message.exitUnlocked.rawValue, "\(Message.enterLocked) 0"))
     }
 
     func test_givenStateIsBroken_whenMachineRepairDidComplete_shouldTransitionToLockedState() throws {
@@ -225,7 +227,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {
                                                     event: .machineRepairDidComplete,
                                                     toState: .locked(credit: 15),
                                                     sideEffect: nil)))
-        expect(self.logger).to(log(Message.exitBroken.rawValue, Message.enterLocked.rawValue))
+        expect(self.logger).to(log(Message.exitBroken.rawValue, "\(Message.enterLocked) 15"))
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ open class StateMachine<State: StateMachineHashable, Event: StateMachineHashable`
`56`	`56`	`private let states: States`
`57`	`57`	`private var observers: [Observer] = []`
`58`	`58`
`59`		`- private typealias EnterExitAction = () -> Void`
	`59`	`+ private typealias EnterExitAction = (State) throws -> Void`
`60`	`60`
`61`	`61`	`private var onEnterActions: [State.HashableIdentifier: EnterExitAction]`
`62`	`62`	`private var onExitActions: [State.HashableIdentifier: EnterExitAction]`
`@@ -127,13 +127,15 @@ open class StateMachine<State: StateMachineHashable, Event: StateMachineHashable`
`127`	`127`	`event: event,`
`128`	`128`	`toState: action.toState ?? state,`
`129`	`129`	`sideEffect: action.sideEffect)`
	`130`	`+ let fromState = state`
`130`	`131`	`if let toState: State = action.toState {`
`131`	`132`	`state = toState`
`132`	`133`	`}`
`133`	`134`
`134`		`- if stateIdentifier != state.hashableIdentifier {`
`135`		`- onExitActions[stateIdentifier]?()`
`136`		`- onEnterActions[state.hashableIdentifier]?()`
	`135`	+ // if not `dontTransition`
	`136`	`+ if action.toState != nil {`
	`137`	`+ try onExitActions[stateIdentifier]?(fromState)`
	`138`	`+ try onEnterActions[state.hashableIdentifier]?(state)`
`137`	`139`	`}`
`138`	`140`
`139`	`141`	`result = .success(transition)`
`@@ -201,11 +203,11 @@ extension StateMachineBuilder {`
`201`	`203`	`.state(state: state, events: build())`
`202`	`204`	`}`
`203`	`205`
`204`		`- public static func onEnter(_ perform: @escaping () -> Void) -> [EventHandler] {`
	`206`	`+ public static func onEnter(_ perform: @escaping (State) throws -> Void) -> [EventHandler] {`
`205`	`207`	`[EventHandler(event: nil, action: nil, eventType: .onEnter(perform))]`
`206`	`208`	`}`
`207`	`209`
`208`		`- public static func onExit(_ perform: @escaping () -> Void) -> [EventHandler] {`
	`210`	`+ public static func onExit(_ perform: @escaping (State) throws -> Void) -> [EventHandler] {`
`209`	`211`	`[EventHandler(event: nil, action: nil, eventType: .onExit(perform))]`
`210`	`212`	`}`
`211`	`213`
`@@ -312,15 +314,15 @@ public enum StateMachineTypes {`
`312`	`314`	`}`
`313`	`315`	`}`
`314`	`316`
`315`		`- fileprivate enum EventType {`
`316`		`- case normal, onEnter(() -> Void), onExit(() -> Void)`
	`317`	`+ fileprivate enum EventType<State> {`
	`318`	`+ case normal, onEnter((State) throws -> Void), onExit((State) throws -> Void)`
`317`	`319`	`}`
`318`	`320`
`319`	`321`	`public struct EventHandler<State: StateMachineHashable, Event: StateMachineHashable, SideEffect> {`
`320`	`322`
`321`	`323`	`fileprivate let event: Event.HashableIdentifier?`
`322`	`324`	`fileprivate let action: Action<State, Event, SideEffect>.Factory?`
`323`		`- fileprivate var eventType = EventType.normal`
	`325`	`+ fileprivate var eventType = EventType<State>.normal`
`324`	`326`	`}`
`325`	`327`
`326`	`328`	`public struct Action<State: StateMachineHashable, Event: StateMachineHashable, SideEffect> {`
Original file line number	Diff line number	Diff line change
`@@ -46,21 +46,21 @@ final class StateMachine_Matter_Tests: XCTestCase, StateMachineBuilder {`
`46`	`46`	`MatterStateMachine {`
`47`	`47`	`initialState(_state)`
`48`	`48`	`state(.solid) {`
`49`		`- onEnter {`
	`49`	`+ onEnter { _ in`
`50`	`50`	`logger.log(Message.enteredSolid.rawValue)`
`51`	`51`	`}`
`52`		`- onExit {`
	`52`	`+ onExit { _ in`
`53`	`53`	`logger.log(Message.exitSolid.rawValue)`
`54`	`54`	`}`
`55`	`55`	`on(.melt) {`
`56`	`56`	`transition(to: .liquid, emit: .logMelted)`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`	`state(.liquid) {`
`60`		`- onEnter {`
	`60`	`+ onEnter { _ in`
`61`	`61`	`logger.log(Message.enteredLiquid.rawValue)`
`62`	`62`	`}`
`63`		`- onExit {`
	`63`	`+ onExit { _ in`
`64`	`64`	`logger.log(Message.exitLiquid.rawValue)`
`65`	`65`	`}`
`66`	`66`	`on(.freeze) {`
`@@ -71,10 +71,10 @@ final class StateMachine_Matter_Tests: XCTestCase, StateMachineBuilder {`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`	`state(.gas) {`
`74`		`- onEnter {`
	`74`	`+ onEnter { _ in`
`75`	`75`	`logger.log(Message.enteredGas.rawValue)`
`76`	`76`	`}`
`77`		`- onExit {`
	`77`	`+ onExit { _ in`
`78`	`78`	`logger.log(Message.exitGas.rawValue)`
`79`	`79`	`}`
`80`	`80`	`on(.condense) {`
Original file line number	Diff line number	Diff line change
`@@ -45,11 +45,13 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`45`	`45`	`TurnstileStateMachine {`
`46`	`46`	`initialState(_state)`
`47`	`47`	`state(.locked) {`
`48`		`- onEnter {`
`49`		`- logger.log(Message.enterLocked.rawValue)`
	`48`	`+ onEnter { state in`
	`49`	`+ let credit: Int = try state.credit()`
	`50`	`+ logger.log("\(Message.enterLocked.rawValue) \(credit)")`
`50`	`51`	`}`
`51`		`- onExit {`
`52`		`- logger.log(Message.exitLocked.rawValue)`
	`52`	`+ onExit { state in`
	`53`	`+ let credit: Int = try state.credit()`
	`54`	`+ logger.log("\(Message.exitLocked.rawValue) \(credit)")`
`53`	`55`	`}`
`54`	`56`	`on(.insertCoin) { locked, insertCoin in`
`55`	`57`	`let newCredit: Int = try locked.credit() + insertCoin.value()`
`@@ -67,21 +69,21 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`67`	`69`	`}`
`68`	`70`	`}`
`69`	`71`	`state(.unlocked) {`
`70`		`- onEnter {`
	`72`	`+ onEnter { _ in`
`71`	`73`	`logger.log(Message.enterUnlocked.rawValue)`
`72`	`74`	`}`
`73`		`- onExit {`
	`75`	`+ onExit { _ in`
`74`	`76`	`logger.log(Message.exitUnlocked.rawValue)`
`75`	`77`	`}`
`76`	`78`	`on(.admitPerson) {`
`77`	`79`	`transition(to: .locked(credit: 0), emit: .closeDoors)`
`78`	`80`	`}`
`79`	`81`	`}`
`80`	`82`	`state(.broken) {`
`81`		`- onEnter {`
	`83`	`+ onEnter { _ in`
`82`	`84`	`logger.log(Message.enterBroken.rawValue)`
`83`	`85`	`}`
`84`		`- onExit {`
	`86`	`+ onExit { _ in`
`85`	`87`	`logger.log(Message.exitBroken.rawValue)`
`86`	`88`	`}`
`87`	`89`	`on(.machineRepairDidComplete) { broken in`
`@@ -123,7 +125,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`123`	`125`	`event: .insertCoin(10),`
`124`	`126`	`toState: .locked(credit: 10),`
`125`	`127`	`sideEffect: nil)))`
`126`		`- expect(self.logger).to(noLog())`
	`128`	`+ expect(self.logger).to(log("\(Message.exitLocked) 0", "\(Message.enterLocked) 10"))`
`127`	`129`	`}`
`128`	`130`
`129`	`131`	`func test_givenStateIsLocked_whenInsertCoin_andCreditEqualsFarePrice_shouldTransitionToUnlockedStateAndOpenDoors() throws {`
`@@ -140,7 +142,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`140`	`142`	`event: .insertCoin(15),`
`141`	`143`	`toState: .unlocked,`
`142`	`144`	`sideEffect: .openDoors)))`
`143`		`- expect(self.logger).to(log(Message.exitLocked.rawValue, Message.enterUnlocked.rawValue))`
	`145`	`+ expect(self.logger).to(log("\(Message.exitLocked) 35", Message.enterUnlocked.rawValue))`
`144`	`146`	`}`
`145`	`147`
`146`	`148`	`func test_givenStateIsLocked_whenInsertCoin_andCreditMoreThanFarePrice_shouldTransitionToUnlockedStateAndOpenDoors() throws {`
`@@ -157,7 +159,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`157`	`159`	`event: .insertCoin(20),`
`158`	`160`	`toState: .unlocked,`
`159`	`161`	`sideEffect: .openDoors)))`
`160`		`- expect(self.logger).to(log(Message.exitLocked.rawValue, Message.enterUnlocked.rawValue))`
	`162`	`+ expect(self.logger).to(log("\(Message.exitLocked) 35", Message.enterUnlocked.rawValue))`
`161`	`163`	`}`
`162`	`164`
`163`	`165`	`func test_givenStateIsLocked_whenAdmitPerson_shouldTransitionToLockedStateAndSoundAlarm() throws {`
`@@ -191,7 +193,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`191`	`193`	`event: .machineDidFail,`
`192`	`194`	`toState: .broken(oldState: .locked(credit: 15)),`
`193`	`195`	`sideEffect: .orderRepair)))`
`194`		`- expect(self.logger).to(log(Message.exitLocked.rawValue, Message.enterBroken.rawValue))`
	`196`	`+ expect(self.logger).to(log("\(Message.exitLocked.rawValue) 15", Message.enterBroken.rawValue))`
`195`	`197`	`}`
`196`	`198`
`197`	`199`	`func test_givenStateIsUnlocked_whenAdmitPerson_shouldTransitionToLockedStateAndCloseDoors() throws {`
`@@ -208,7 +210,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`208`	`210`	`event: .admitPerson,`
`209`	`211`	`toState: .locked(credit: 0),`
`210`	`212`	`sideEffect: .closeDoors)))`
`211`		`- expect(self.logger).to(log(Message.exitUnlocked.rawValue, Message.enterLocked.rawValue))`
	`213`	`+ expect(self.logger).to(log(Message.exitUnlocked.rawValue, "\(Message.enterLocked) 0"))`
`212`	`214`	`}`
`213`	`215`
`214`	`216`	`func test_givenStateIsBroken_whenMachineRepairDidComplete_shouldTransitionToLockedState() throws {`
`@@ -225,7 +227,7 @@ final class StateMachine_Turnstile_Tests: XCTestCase, StateMachineBuilder {`
`225`	`227`	`event: .machineRepairDidComplete,`
`226`	`228`	`toState: .locked(credit: 15),`
`227`	`229`	`sideEffect: nil)))`
`228`		`- expect(self.logger).to(log(Message.exitBroken.rawValue, Message.enterLocked.rawValue))`
	`230`	`+ expect(self.logger).to(log(Message.exitBroken.rawValue, "\(Message.enterLocked) 15"))`
`229`	`231`	`}`
`230`	`232`	`}`
`231`	`233`