jagarsoft\StateMachine\StateMachine

Complexity

Total Complexity

33

Size/Duplication

Total Lines	185
Duplicated Lines	0 %

Test Coverage

Coverage

98.94%

Importance

Changes	2
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	addState()	0	9	1
A	addTransition()	0	13	1
A	__construct()	0	14	6
A	addCommonTransition()	0	11	2
A	fireEvent()	0	38	5
A	getMachineToArray()	0	3	1
A	eventMustExistOrFail()	0	4	2
A	argumentIsNotNullOrFail()	0	4	2
A	argumentIsValidOrFail()	0	4	1
A	setCurrentStateIfThisIsInitialState()	0	4	2
A	can()	0	9	2
A	getCurrentState()	0	3	1
A	stateMustExistOrFail()	0	4	2
A	argumentIsNotBlankOrFail()	0	4	2
A	getNextState()	0	3	1
A	getCurrentEvent()	0	3	1
A	cancelTransition()	0	3	1

<?php

namespace jagarsoft\StateMachine;

use jagarsoft\StateMachine\Stubs\StateMachineBuilder;

class StateMachine {
    private const NEXT_STATE = 0;
    private const EXEC_ACTION = 1;
    
    protected $sm = [];
    protected $currentState = null;
    protected $currentEvent = null;
    protected $nextState = null;

    private $cancelTransition = false;
    private $transitionInProgress = false;
    private $eventsQueued = [];

    public function __construct(StateMachineBuilder $smb = null)
    {
        if(  $smb != null )
            $sm = $smb->__invoke();

        if( ! empty($sm) ){
            // StateEnum::CURRENT_STATE => [ EventEnum::ON_EVENT => [ StateEnum::NEXT_STATE_2, ActionClosureOrFunction ]  ],
            foreach ($sm as $state => $transition){
                $this->addState($state);
                foreach ($transition as $onEvent => $nextStateAndAction) {
                    if( array_key_exists(self::EXEC_ACTION, $nextStateAndAction) ) {
                        $this->addTransition($state, $onEvent, $nextStateAndAction[self::NEXT_STATE], $nextStateAndAction[self::EXEC_ACTION]);
                    } else {
                        $this->addTransition($state, $onEvent, $nextStateAndAction[self::NEXT_STATE]);
                    }
                }
            }
        }
    }

    public function addState($state)
    {
        $this->argumentIsValidOrFail($state);

        $this->setCurrentStateIfThisIsInitialState($state);

        $this->sm[$state] = [];

        return $this;
    }

    public function addTransition($currentState, $currentEvent, $nextState, \Closure $execAction = null )
    {
        $this->argumentIsValidOrFail($currentState);
        $this->argumentIsValidOrFail($currentEvent);
        $this->argumentIsValidOrFail($nextState);

        $this->setCurrentStateIfThisIsInitialState($currentState);

        $this->sm[$currentState][$currentEvent] = [
                                                self::NEXT_STATE => $nextState,
                                                self::EXEC_ACTION => $execAction
                                            ];
        return $this;
    }

    public function addCommonTransition($currentEvent, $nextState, \Closure $execAction = null )
    {
        $this->argumentIsValidOrFail($currentEvent);
        $this->argumentIsValidOrFail($nextState);

        $states = array_keys($this->sm);
        foreach ($states as $state) {
            $this->addTransition($state, $currentEvent, $nextState, $execAction);
        }

        return $this;
    }

    /**
     * @param $event
     */
    public function fireEvent($event)
    {
        $this->argumentIsValidOrFail($event);

        if( $this->transitionInProgress ){
            array_push($this->eventsQueued, $event);
            return $this;
        }
        $this->transitionInProgress = true;

        $this->eventMustExistOrFail($event);

        $transition = $this->sm[$this->currentState][$event];

        $this->nextState = $transition[self::NEXT_STATE];

        $this->stateMustExistOrFail($this->nextState);

        $this->currentEvent = $event;

        $action = $transition[self::EXEC_ACTION];
        if( $action ){
            ($action)($this);
        }

        if( $this->cancelTransition ){
            $this->cancelTransition = false;
        } else {
            $this->currentState = $transition[self::NEXT_STATE];
        }

        $this->transitionInProgress = false;
        $event = array_shift($this->eventsQueued);
        if(  $event != null ){
            $this->fireEvent($event);
        }

        return $this;
    }

    public function can($event)
    {
        try{
            $this->eventMustExistOrFail($event);
            $can = true;
        } catch(\InvalidArgumentException $e){
            $can = false;
        }
        return $can;
    }

    public function cancelTransition()
    {
        $this->cancelTransition = true;
    }

    public function getCurrentState()
    {
        return $this->currentState;
    }

    public function getCurrentEvent()
    {
        return $this->currentEvent;
    }

    public function getNextState()
    {
        return $this->nextState;
    }

    public function getMachineToArray()
    {
        return $this->sm;
    }

    private function argumentIsValidOrFail($arg): void
    {
        $this->argumentIsNotNullOrFail($arg);
        $this->argumentIsNotBlankOrFail($arg);
    }

    private function argumentIsNotNullOrFail($arg): void
    {
        if( $arg === null )
            throw new \InvalidArgumentException("Null is not an valid argument");
    }

    private function argumentIsNotBlankOrFail($arg): void
    {
        if( trim($arg) === "" )
            throw new \InvalidArgumentException("Blank is not an valid argument");
    }

    private function eventMustExistOrFail($event)
    {
        if( !( isset($this->sm[$this->currentState][$event]) ) )
            throw new \InvalidArgumentException("Unexpected event {$event} on {$this->currentState} state");
    }

    private function stateMustExistOrFail($state)
    {
        if( ! isset($this->sm[$state]) )
            throw new \InvalidArgumentException("Event '{$this->currentEvent}' fired an unexpected '{$state}' state");
    }

    private function setCurrentStateIfThisIsInitialState($state): void
    {
        if( $this->currentState == null){
            $this->currentState = $state;
        }
    }
}