precise state machine visualizations

[kgignatyev]

Hi, I like your library a lot, but it falls a bit short on state machine visualization, which is understandable, because it is based on runtime based sm interrogation, and if/else statemets are impossible to trace.
Did you consider using approach employed by this SML? (now defunct unfortunately) :
https://github.com/open-jumpco/kfsm-viz
It also took the idea from SMC project (which we are using currently): a SM definition lives in a separate special file which has predictable and limited (kotlin) syntax, and all the work is delegated to a companion instance. This way a full state diagram can be visualized, including tricky if/else conditions.
Thoughts?

[nsk90]

Hello! Yes, those if/else statements are blockers for current visualization. Code parsing approach may handle such cases, but it seems that it may be broken also easily by user helper functions, typealiases, etc (any syntax change or complication).

I thought about adding ability to provide meta data for current approach, so it can help with if/else statements. But it sort of code duplication. And may lead to mistakes.

I cannot see reliable solution now.
Maybe combination of those two approaches is a solution? But it is not clear how it should be implemented.

[kgignatyev]

yeah, for now I am planning to use hand written FSM template (mustache) to allow highlighting of current states, but this can easily get out of sync with actual FSM (and yes, code duplication is evil).
Code parsing errors potentially can be reduced with using delegation, basically try to force all the tricky logic to a mandatory companion object, maybe try using some sort of annotations ( maybe in comments?) to help with visualization. It looks like only state definitions need to be parsed, and could be limited to when and if/else statements https://nsk90.github.io/kstatemachine/#guarded-transitions

        when (getCondition()) {
            0 -> targetState(greenState)
            1 -> targetState(yellowState)
            2 -> stay()
            else -> noTransition()
        }

or replace code with a builder pattern, so state can be build like this
on( functionRef, 'description ', targetState(greenState) )
so the statement above might look like this

data class ConditionalTransitionDef (
val condition:()-> Boolean,
val descr:String,
val block: () -> Unit
)

interface Conditional {
fun on( condition:()-> Boolean, descr:String, block: () -> Unit)
}

class TestSvc : Conditional{

val transitions = mutableListOf<ConditionalTransitionDef>()

override fun on( condition:()-> Boolean, descr:String,  block: () -> Unit) {
    transitions.add(ConditionalTransitionDef(condition, descr, block))
}


companion object {
    fun cond():Int {
        return Random(0).nextInt(10)
    }
    
    fun checkForZero():Boolean {
        return 0 == cond()
    }

    fun checkForOne():Boolean {
        return 1 == cond()
    }
    fun test() {
        val testSvc = TestSvc()
        testSvc.on( this::checkForZero, "check For Zero") {
            println("transition call for  zero")
        }
        testSvc.on( this::checkForOne, "check For 1") {
            println("transition call for 1")
        }
    }
}

}