LightFsm\StateMachine

Complexity

Total Complexity

27

Size/Duplication

Total Lines	171
Duplicated Lines	7.02 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	configure()	0	4	1
A	fire()	0	18	4
A	getCurrentState()	0	4	1
A	isInState()	0	6	1
D	toDotGraph()	12	37	10
A	isSubState()	0	18	4
A	getState()	0	8	2
A	transition()	0	12	2

<?php

namespace LightFsm;

class StateMachine 
{
    /** @var StateConfiguration */
    private $currentState;

    /** @var StateConfiguration[] */
    private $states = [];

    /** @var callable|null */
    private $changeCallback;

    /**
     * @param string|int|callable $initialState
     * @param callable|null       $changeCallback f($newState, $event, $oldState, $isSubState, $data)
     */
    public function __construct($initialState, $changeCallback = null)
    {
        $state = is_callable($initialState) ? call_user_func($initialState) : $initialState;
        $this->states[$state] = $this->currentState = new StateConfiguration($state);
        $this->changeCallback = $changeCallback;
    }

    /**
     * @param string|int $state
     *
     * @return StateConfiguration
     */
    public function configure($state)
    {
        return $this->getState($state);
    }

    /**
     * @param string|int $event
     * @param mixed      $data
     */
    public function fire($event, $data = null)
    {
        $transition = $this->currentState->getTransition($event);
        if (null === $transition) {
            return;
        }

        if ($transition->getGuardCallback()) {
            $ok = call_user_func($transition->getGuardCallback(), $data);
            if (!$ok) {
                return;
            }
        }

        $nextState = $this->getState($transition->getNextState());

        $this->transition($this->currentState, $event, $nextState, $data);
    }

    /**
     * @return int|string
     */
    public function getCurrentState()
    {
        return $this->currentState->getState();
    }

    /**
     * @param string|int $state
     *
     * @return bool
     */
    public function isInState($state)
    {
        $parentState = $this->getState($state);

        return $this->isSubState($this->currentState, $parentState);
    }

    public function toDotGraph()
    {
        $result = "digraph {\n";
        $listeners = '';
        foreach ($this->states as $state) {
            foreach ($state->getAllEntryCallbacks() as $name=>$callback) {

This code seems to be duplicated across your project.

                if (is_int($name)) {
                    $name = 'listener';
                }
                $listeners .= sprintf("    \"%s\" -> \"%s\" [label=\"On Entry\"];\n", $state->getState(), $name);
            }
            foreach ($state->getAllExitCallbacks() as $name=>$callback) {

This code seems to be duplicated across your project.

                if (is_int($name)) {
                    $name = 'listener';
                }
                $listeners .= sprintf("    \"%s\" -> \"%s\" [label=\"On Exit\"];\n", $state->getState(), $name);
            }

            foreach ($state->getAllTransitions() as $transition) {
                if ($transition->getGuardCallback()) {
                    $guardName = $transition->getGuardName() ?: 'condition';
                    $result .= sprintf("    \"%s\" -> \"%s\" [label=\"%s [%s]\"];\n", $state->getState(), $transition->getNextState(), $transition->getEvent(), $guardName);
                } else {
                    $result .= sprintf("    \"%s\" -> \"%s\" [label=\"%s\"];\n", $state->getState(), $transition->getNextState(), $transition->getEvent());
                }
            }
        }

        if ($listeners) {
            $result .= "    node [shape=box];\n";
            $result .= $listeners;
        }

        $result .= "}\n";

        return $result;
    }

    /**
     * @param StateConfiguration $child
     * @param StateConfiguration $parent
     *
     * @return bool
     */
    private function isSubState(StateConfiguration $child, StateConfiguration $parent)
    {
        $state = $child;

        while ($state) {
            if ($state->getState() === $parent->getState()) {
                return true;
            }

            if ($state->getParentState()) {
                $state = $this->getState($state->getParentState());
            } else {
                $state = null;
            }
        }

        return false;
    }

    /**
     * @param string|int $state
     *
     * @return StateConfiguration
     */
    private function getState($state)
    {
        if (false === isset($this->states[$state])) {
            $this->states[$state] = new StateConfiguration($state);
        }

        return $this->states[$state];
    }

    /**
     * @param StateConfiguration $previousState
     * @param string|int         $event
     * @param StateConfiguration $nextState
     * @param mixed              $data
     */
    private function transition(StateConfiguration $previousState, $event, StateConfiguration $nextState, $data)
    {
        $isSubState = $this->isSubState($this->currentState, $nextState);

        $previousState->triggerExit($isSubState, $data);
        $this->currentState = $nextState;
        $nextState->triggerEntry($isSubState, $data);

        if ($this->changeCallback) {
            call_user_func($this->changeCallback, $nextState->getState(), $event, $previousState->getState(), $isSubState, $data);
        }
    }
}