Remove class Failed

Author: mantono

lib/src/main/kotlin/io/nexure/fsm/StateMachine.kt

@@ -27,13 +27,8 @@ interface StateMachine<S : Any, E : Any, N : Any> {
      * with [signal] as input. Returns a [Transition] indicating if the transition was permitted and
      * successful or not.
      *
-     * Any [Exception] that is thrown will be caught and a part of the Transition return value.
-     * Note that only instances of [Exception] will be caught, and instances of [Throwable] which do
-     * not inherit from [Exception] - like [Error] - will not be caught.
-     *
      * It is recommended that the return value is checked for the desired outcome, if it is critical
-     * that an event for example is accepted and not rejected, or that any thrown exceptions are
-     * handled or reported.
+     * that an event for example is accepted and not rejected.
      */
     fun onEvent(current: S, event: E, signal: N): Transition<S>
 

lib/src/main/kotlin/io/nexure/fsm/StateMachineImpl.kt

@@ -44,12 +44,8 @@ internal class StateMachineImpl<S : Any, E : Any, N : Any>(
 
     override fun onEvent(current: S, event: E, signal: N): Transition<S> {
         val next: S = nextState(current, event) ?: return Rejected
-        return try {
-            executeTransition(current, next, event, signal)
-            Executed(next)
-        } catch (e: Exception) {
-            Failed(e)
-        }
+        executeTransition(current, next, event, signal)
+        return Executed(next)
     }
 
     private fun nextState(current: S, event: E): S? {

lib/src/main/kotlin/io/nexure/fsm/Transition.kt

@@ -5,29 +5,22 @@ package io.nexure.fsm
  * rejected by the state machine, or if there was an exception while processing the event.
  */
 sealed class Transition<out S : Any> {
-    fun transitioned(): Boolean {
-        return when (this) {
-            is Executed -> true
-            is Failed, Rejected -> false
-        }
-    }
+    fun transitioned(): Boolean = this is Executed<S>
 
     /**
      * Returns
      * - The new state if the transition was permitted and successful ([Executed])
      * - `null` if the transitioned was rejected ([Rejected])
-     * - Throws an exception if such occurred ([Failed])
      */
-    fun stateOrThrow(): S? {
+    fun stateOrNull(): S? {
         return when (this) {
             is Executed -> this.state
             Rejected -> null
-            is Failed -> throw this.exception
         }
     }
 
     /**
-     * Invoke this lambda if a transition was exceuted and successful
+     * Invoke this lambda if a transition was executed and successful
      */
     inline fun onExecution(handle: (state: S) -> Unit): Transition<S> {
         if (this is Executed) {
@@ -45,17 +38,6 @@ sealed class Transition<out S : Any> {
         }
         return this
     }
-
-    /**
-     * Invoke this lambda if an exception was thrown by either an interceptor or during the
-     * execution of the action associated with the event/transition
-     */
-    inline fun onFailure(handle: (exception: Exception) -> Unit): Transition<S> {
-        if (this is Failed) {
-            handle(this.exception)
-        }
-        return this
-    }
 }
 
 /**
@@ -73,12 +55,3 @@ data class Executed<S : Any>(val state: S) : Transition<S>() {
 object Rejected : Transition<Nothing>() {
     override fun toString(): String = "Rejected"
 }
-
-/**
- * The event could not be processed due to an exception while executing the action associated
- * with this state transition, or while executing any interceptors, if such are present.
- * Some part of the action may have completed while others may not have.
- */
-data class Failed(val exception: Exception) : Transition<Nothing>() {
-    override fun toString(): String = "Failed($exception)"
-}

lib/src/test/kotlin/io/nexure/fsm/StateMachineTest.kt

@@ -155,30 +155,6 @@ class StateMachineTest {
         assertEquals(32, value)
     }
 
-    @Test
-    fun `test exception in interceptor is caught and returned as failure`() {
-        val exception = IllegalArgumentException("foo")
-        val fsm = StateMachine.builder<State, Event, Int>()
-            .initial(State.S1)
-            .connect(State.S1, State.S2, Event.E2)
-            .intercept { _, _, _, _ -> throw exception }
-            .build()
-
-        assertEquals(Failed(exception), fsm.onEvent(State.S1, Event.E2, 0))
-    }
-
-    @Test
-    fun `test exception in post interceptor is caught and returned as failure`() {
-        val exception = IllegalArgumentException("foo")
-        val fsm = StateMachine.builder<State, Event, Int>()
-            .initial(State.S1)
-            .connect(State.S1, State.S2, Event.E2)
-            .postIntercept { _, _, _, _ -> throw exception }
-            .build()
-
-        assertEquals(Failed(exception), fsm.onEvent(State.S1, Event.E2, 0))
-    }
-
     @Test
     fun `test transition with Action`() {
         val semaphore = Semaphore(10)
@@ -237,17 +213,6 @@ class StateMachineTest {
         assertEquals(Rejected, fsm.onEvent(State.S1, Event.E3, false))
     }
 
-    @Test
-    fun `test exception in action is caught`() {
-        val exception = IllegalArgumentException("foo")
-        val fsm = StateMachine.builder<State, Event, Boolean>()
-            .initial(State.S1)
-            .connect(State.S1, State.S2, Event.E1) { throw exception }
-            .build()
-
-        assertEquals(Failed(exception), fsm.onEvent(State.S1, Event.E1, false))
-    }
-
     @Test(expected = StackOverflowError::class)
     fun `test throwable in action is not caught`() {
         val exception = StackOverflowError("foo")