StateMachine::can() - Code Metrics - Inspection of "New: transition can be proven" - jagarsoft/php-state-machine - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b8b5dc...ebd7e1 )

by Javier

created 2022-02-07 21:49 UTC

StateMachine::can() A

↳ Parent: StateMachine

Complexity

Conditions	2
Paths	2

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	6
nc	2
nop	1
dl	0
loc	9
ccs	6
cts	6
cp	1
crap	2
rs	10
c	0
b	0
f	0

<?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;
        }
    }
}


1		<?php
2
3		namespace jagarsoft\StateMachine;
4
5		use jagarsoft\StateMachine\Stubs\StateMachineBuilder;
6
7		class StateMachine {
8		private const NEXT_STATE = 0;
9		private const EXEC_ACTION = 1;
10
11		protected $sm = [];
12		protected $currentState = null;
13		protected $currentEvent = null;
14		protected $nextState = null;
15
16		private $cancelTransition = false;
17		private $transitionInProgress = false;
18		private $eventsQueued = [];
19
20	27	public function __construct(StateMachineBuilder $smb = null)
21		{
22	27	if( $smb != null )
23	1	$sm = $smb->__invoke();
24
25	27	if( ! empty($sm) ){
26		// StateEnum::CURRENT_STATE => [ EventEnum::ON_EVENT => [ StateEnum::NEXT_STATE_2, ActionClosureOrFunction ] ],
27	1	foreach ($sm as $state => $transition){
28	1	$this->addState($state);
29	1	foreach ($transition as $onEvent => $nextStateAndAction) {
30	1	if( array_key_exists(self::EXEC_ACTION, $nextStateAndAction) ) {
31		$this->addTransition($state, $onEvent, $nextStateAndAction[self::NEXT_STATE], $nextStateAndAction[self::EXEC_ACTION]);
32		} else {
33	1	$this->addTransition($state, $onEvent, $nextStateAndAction[self::NEXT_STATE]);
34		}
35		}
36		}
37		}
38	27	}
39
40	19	public function addState($state)
41		{
42	19	$this->argumentIsValidOrFail($state);
43
44	17	$this->setCurrentStateIfThisIsInitialState($state);
45
46	17	$this->sm[$state] = [];
47
48	17	return $this;
49		}
50
51	19	public function addTransition($currentState, $currentEvent, $nextState, \Closure $execAction = null )
52		{
53	19	$this->argumentIsValidOrFail($currentState);
54	19	$this->argumentIsValidOrFail($currentEvent);
55	19	$this->argumentIsValidOrFail($nextState);
56
57	19	$this->setCurrentStateIfThisIsInitialState($currentState);
58
59	19	$this->sm[$currentState][$currentEvent] = [
60	19	self::NEXT_STATE => $nextState,
61	19	self::EXEC_ACTION => $execAction
62		];
63	19	return $this;
64		}
65
66	4	public function addCommonTransition($currentEvent, $nextState, \Closure $execAction = null )
67		{
68	4	$this->argumentIsValidOrFail($currentEvent);
69	4	$this->argumentIsValidOrFail($nextState);
70
71	4	$states = array_keys($this->sm);
72	4	foreach ($states as $state) {
73	4	$this->addTransition($state, $currentEvent, $nextState, $execAction);
74		}
75
76	4	return $this;
77		}
78
79		/**
80		* @param $event
81		*/
82	15	public function fireEvent($event)
83		{
84	15	$this->argumentIsValidOrFail($event);
85
86	15	if( $this->transitionInProgress ){
87	2	array_push($this->eventsQueued, $event);
88	2	return $this;
89		}
90	15	$this->transitionInProgress = true;
91
92	15	$this->eventMustExistOrFail($event);
93
94	14	$transition = $this->sm[$this->currentState][$event];
95
96	14	$this->nextState = $transition[self::NEXT_STATE];
97
98	14	$this->stateMustExistOrFail($this->nextState);
99
100	13	$this->currentEvent = $event;
101
102	13	$action = $transition[self::EXEC_ACTION];
103	13	if( $action ){
104	11	($action)($this);
105		}
106
107	13	if( $this->cancelTransition ){
108	5	$this->cancelTransition = false;
109		} else {
110	9	$this->currentState = $transition[self::NEXT_STATE];
111		}
112
113	13	$this->transitionInProgress = false;
114	13	$event = array_shift($this->eventsQueued);
115	13	if( $event != null ){
116	2	$this->fireEvent($event);
117		}
118
119	13	return $this;
120		}
121
122	1	public function can($event)
123		{
124		try{
125	1	$this->eventMustExistOrFail($event);
126	1	$can = true;
127	1	} catch(\InvalidArgumentException $e){
128	1	$can = false;
129		}
130	1	return $can;
131		}
132
133	5	public function cancelTransition()
134		{
135	5	$this->cancelTransition = true;
136	5	}
137
138	9	public function getCurrentState()
139		{
140	9	return $this->currentState;
141		}
142
143	4	public function getCurrentEvent()
144		{
145	4	return $this->currentEvent;
146		}
147
148	1	public function getNextState()
149		{
150	1	return $this->nextState;
151		}
152
153	1	public function getMachineToArray()
154		{
155	1	return $this->sm;
156		}
157
158	26	private function argumentIsValidOrFail($arg): void
159		{
160	26	$this->argumentIsNotNullOrFail($arg);
161	25	$this->argumentIsNotBlankOrFail($arg);
162	24	}
163
164	26	private function argumentIsNotNullOrFail($arg): void
165		{
166	26	if( $arg === null )
167	4	throw new \InvalidArgumentException("Null is not an valid argument");
168	25	}
169
170	25	private function argumentIsNotBlankOrFail($arg): void
171		{
172	25	if( trim($arg) === "" )
173	2	throw new \InvalidArgumentException("Blank is not an valid argument");
174	24	}
175
176	16	private function eventMustExistOrFail($event)
177		{
178	16	if( !( isset($this->sm[$this->currentState][$event]) ) )
179	2	throw new \InvalidArgumentException("Unexpected event {$event} on {$this->currentState} state");
180	15	}
181
182	14	private function stateMustExistOrFail($state)
183		{
184	14	if( ! isset($this->sm[$state]) )
185	1	throw new \InvalidArgumentException("Event '{$this->currentEvent}' fired an unexpected '{$state}' state");
186	13	}
187
188	24	private function setCurrentStateIfThisIsInitialState($state): void
189		{
190	24	if( $this->currentState == null){
191	24	$this->currentState = $state;
192		}
193	24	}
194		}
195

jagarsoft / php-state-machine

Push — master ( b8b5dc...ebd7e1 )

StateMachine::can() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like