StateMachine::argumentMustBeClosureOrFail() - Code Metrics - Inspection of "Fix arg to addTransation as Closure|array" - jagarsoft/php-state-machine - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cf9b22...f8edaa )

by Javier

created 2022-02-26 21:09 UTC

StateMachine::argumentMustBeClosureOrFail() A

↳ Parent: StateMachine

Complexity

Conditions	2
Paths	2

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2

Importance

Changes

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

<?php

namespace jagarsoft\StateMachine;

use jagarsoft\StateMachine\StateMachineBuilder;

class StateMachine
{
    public const NEXT_STATE = 0;
    public const EXEC_ACTION = 'EXEC_ACTION';
    public const EXEC_GUARD = 'EXEC_GUARD';
    public const EXEC_BEFORE = 'EXEC_BEFORE';
    public const EXEC_AFTER = 'EXEC_AFTER';

    protected array $sm = [];
    protected $currentState = null;
    protected $currentEvent = null;
    protected $nextState = null;

    protected bool $cancelTransition = false;
    protected bool $transitionInProgress = false;
    protected array $eventsQueued = [];

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


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

    public function to()
    {
        // TODO: pending of implementation
        /*
        if( $this->smb == null )
            return;

        $this->smb->to($this->getMachineToArray());
        */
    }

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

        $this->setCurrentStateIfThisIsInitialState($state);

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

        return $this;
    }

    public function addTransition($currentState, $currentEvent, $nextState, /*\Closure|array*/ $execAction = null): self
    {
        $this->argumentIsValidOrFail($currentState);
        $this->argumentIsValidOrFail($currentEvent);
        $this->argumentIsValidOrFail($nextState);

        $this->setCurrentStateIfThisIsInitialState($currentState);

        if( $execAction === null ){
            $this->sm[$currentState][$currentEvent] = [ self::NEXT_STATE => $nextState ];
        } elseif (is_array($execAction)) {
            $this->sm[$currentState][$currentEvent] = [ self::NEXT_STATE => $nextState ];
            $arrayActions = $execAction;
            foreach ($arrayActions as $exec_action => $action) {
                if( in_array($exec_action, [self::EXEC_ACTION, self::EXEC_GUARD, self::EXEC_BEFORE, self::EXEC_AFTER], true) ){
                    if( $action === null )
                        continue;
                    $this->argumentMustBeClosureOrFail($action);
                }
                $this->sm[$currentState][$currentEvent][$exec_action] = $action;
            }
        } elseif($execAction instanceof \Closure) {
            $this->sm[$currentState][$currentEvent] = [
                                                        self::NEXT_STATE => $nextState,
                                                        self::EXEC_ACTION => $execAction
                                                    ];
        } else {
            $this->argumentMustBeClosureOrFail(null);
        }
        return $this;
    }

    public function addCommonTransition($currentEvent, $nextState, /*\Closure|array*/ $execAction = null): self
    {
        $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
     * @return StateMachine
     * @noinspection PhpArrayPushWithOneElementInspection
     */
    public function fireEvent($event): self
    {
        $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->currentEvent = $event;

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

        $wasGuarded = $this->execGuard($transition);

        if (!$wasGuarded) {
            $this->execAction(self::EXEC_BEFORE, $transition);
            $this->execAction(self::EXEC_ACTION, $transition);
            $this->execAction(self::EXEC_AFTER, $transition);
        }

        if ($this->cancelTransition || $wasGuarded) {
            $this->cancelTransition = false;
        } else {
            $this->currentState = $this->nextState;
        }

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

        return $this;
    }

    private function execGuard($transition): bool
    {
        $wasGuarded = false;
        if( array_key_exists(self::EXEC_GUARD, $transition) ){
            $guard = $transition[self::EXEC_GUARD];
            if ($guard) {
                if (($guard)($this) === false)
                    $wasGuarded = true;
            }
        }
        return $wasGuarded;
    }

    private function execAction($actionIndex, $transition): void
    {
        if (array_key_exists($actionIndex, $transition)) {
            $action = $transition[$actionIndex];
            if ($action) {
                ($action)($this);
            }
        }
    }

    public function can($event): bool
    {
        $this->argumentIsValidOrFail($event);

        try{
            $this->eventMustExistOrFail($event);
        } catch(\InvalidArgumentException $e){
            return false;
        }

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

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

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

        $wasGuarded = ! $this->execGuard($transition);

        $this->nextState = $nextState;
        $this->currentEvent = $currentEvent;

        return $wasGuarded;
    }

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

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

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

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

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

    /**
     * All possible transitions from current state.
     *
     * @return array
     */
    /*public function getPossibleTransitions(){
        // TODO: pending to implementation
    }*/

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

    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 to unadded '{$state}' state");
    }

    private function argumentMustBeClosureOrFail($action): void
    {
        if( !($action instanceof \Closure) )
            throw new \InvalidArgumentException('execAction argument must be Closure or array');
    }
}


1		<?php
2
3		namespace jagarsoft\StateMachine;
4
5		use jagarsoft\StateMachine\StateMachineBuilder;
6
7		class StateMachine
8		{
9		public const NEXT_STATE = 0;
10		public const EXEC_ACTION = 'EXEC_ACTION';
11		public const EXEC_GUARD = 'EXEC_GUARD';
12		public const EXEC_BEFORE = 'EXEC_BEFORE';
13		public const EXEC_AFTER = 'EXEC_AFTER';
14
15		protected array $sm = [];
16		protected $currentState = null;
17		protected $currentEvent = null;
18		protected $nextState = null;
19
20		protected bool $cancelTransition = false;
21		protected bool $transitionInProgress = false;
22		protected array $eventsQueued = [];
23
24	36	public function __construct(StateMachineBuilder $smb = null)
25		{
26	36	if ($smb != null)
27	2	$this->smb = $smb->from();
		0 ignored issues – show Bug Best Practice introduced 2022-02-21 00:35 UTC by Report Bug Copy Issue Report The property `smb` does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly. Loading history...
28
29	36	if (!empty($this->smb)) {
30		// StateEnum::CURRENT_STATE => [ EventEnum::ON_EVENT => [ NEXT_STATE, ClosureOrFunctionsArray ] ],
31	2	foreach ($this->smb as $state => $transition) {
32	2	$this->addState($state);
33	2	foreach ($transition as $onEvent => $nextStateAndAction) {
34	2	$this->addTransition($state, $onEvent,
35	2	$nextStateAndAction[self::NEXT_STATE],
36		$nextStateAndAction);
37		}
38		}
39		}
40	36	}
41
42		public function to()
43		{
44		// TODO: pending of implementation
45		/*
46		if( $this->smb == null )
47		return;
48
49		$this->smb->to($this->getMachineToArray());
50		*/
51		}
52
53	27	public function addState($state): self
54		{
55	27	$this->argumentIsValidOrFail($state);
56
57	25	$this->setCurrentStateIfThisIsInitialState($state);
58
59	25	$this->sm[$state] = [];
60
61	25	return $this;
62		}
63
64	27	public function addTransition($currentState, $currentEvent, $nextState, /\Closure\|array/ $execAction = null): self
65		{
66	27	$this->argumentIsValidOrFail($currentState);
67	27	$this->argumentIsValidOrFail($currentEvent);
68	27	$this->argumentIsValidOrFail($nextState);
69
70	27	$this->setCurrentStateIfThisIsInitialState($currentState);
71
72	27	if( $execAction === null ){
73	10	$this->sm[$currentState][$currentEvent] = [ self::NEXT_STATE => $nextState ];
74	19	} elseif (is_array($execAction)) {
75	4	$this->sm[$currentState][$currentEvent] = [ self::NEXT_STATE => $nextState ];
76	4	$arrayActions = $execAction;
77	4	foreach ($arrayActions as $exec_action => $action) {
78	4	if( in_array($exec_action, [self::EXEC_ACTION, self::EXEC_GUARD, self::EXEC_BEFORE, self::EXEC_AFTER], true) ){
79	3	if( $action === null )
80	1	continue;
81	3	$this->argumentMustBeClosureOrFail($action);
82		}
83	4	$this->sm[$currentState][$currentEvent][$exec_action] = $action;
84		}
85	15	} elseif($execAction instanceof \Closure) {
86	14	$this->sm[$currentState][$currentEvent] = [
87	14	self::NEXT_STATE => $nextState,
88	14	self::EXEC_ACTION => $execAction
89		];
90		} else {
91	1	$this->argumentMustBeClosureOrFail(null);
92		}
93	26	return $this;
94		}
95
96	5	public function addCommonTransition($currentEvent, $nextState, /\Closure\|array/ $execAction = null): self
97		{
98	5	$this->argumentIsValidOrFail($currentEvent);
99	5	$this->argumentIsValidOrFail($nextState);
100
101	5	$states = array_keys($this->sm);
102	5	foreach ($states as $state) {
103	5	$this->addTransition($state, $currentEvent, $nextState, $execAction);
104		}
105
106	5	return $this;
107		}
108
109		/**
110		* @param $event
111		* @return StateMachine
112		* @noinspection PhpArrayPushWithOneElementInspection
113		*/
114	21	public function fireEvent($event): self
115		{
116	21	$this->argumentIsValidOrFail($event);
117
118	21	if ($this->transitionInProgress) {
119	2	array_push($this->eventsQueued, $event);
120	2	return $this;
121		}
122	21	$this->transitionInProgress = true;
123
124	21	$this->eventMustExistOrFail($event);
125
126	20	$transition = $this->sm[$this->currentState][$event];
127
128	20	$this->nextState = $transition[self::NEXT_STATE];
129	20	$this->currentEvent = $event;
130
131	20	$this->stateMustExistOrFail($this->nextState);
132
133	19	$wasGuarded = $this->execGuard($transition);
134
135	19	if (!$wasGuarded) {
136	18	$this->execAction(self::EXEC_BEFORE, $transition);
137	18	$this->execAction(self::EXEC_ACTION, $transition);
138	17	$this->execAction(self::EXEC_AFTER, $transition);
139		}
140
141	18	if ($this->cancelTransition \|\| $wasGuarded) {
142	6	$this->cancelTransition = false;
143		} else {
144	13	$this->currentState = $this->nextState;
145		}
146
147	18	$this->transitionInProgress = false;
148	18	$event = array_shift($this->eventsQueued);
149	18	if ($event != null) {
150	2	$this->fireEvent($event);
151		}
152
153	18	return $this;
154		}
155
156	20	private function execGuard($transition): bool
157		{
158	20	$wasGuarded = false;
159	20	if( array_key_exists(self::EXEC_GUARD, $transition) ){
160	2	$guard = $transition[self::EXEC_GUARD];
161	2	if ($guard) {
162	2	if (($guard)($this) === false)
163	2	$wasGuarded = true;
164		}
165		}
166	20	return $wasGuarded;
167		}
168
169	18	private function execAction($actionIndex, $transition): void
170		{
171	18	if (array_key_exists($actionIndex, $transition)) {
172	16	$action = $transition[$actionIndex];
173	16	if ($action) {
174	16	($action)($this);
175		}
176		}
177	18	}
178
179	4	public function can($event): bool
180		{
181	4	$this->argumentIsValidOrFail($event);
182
183		try{
184	3	$this->eventMustExistOrFail($event);
185	1	} catch(\InvalidArgumentException $e){
186	1	return false;
187		}
188
189	3	$transition = $this->sm[$this->currentState][$event];
190
191	3	$nextState = $this->nextState;
192	3	$currentEvent = $this->currentEvent;
193	3	$this->nextState = $transition[self::NEXT_STATE];
194	3	$this->currentEvent = $event;
195
196	3	$this->stateMustExistOrFail($this->nextState);
197
198	2	$wasGuarded = ! $this->execGuard($transition);
199
200	2	$this->nextState = $nextState;
201	2	$this->currentEvent = $currentEvent;
202
203	2	return $wasGuarded;
204		}
205
206	5	public function cancelTransition(): void
207		{
208	5	$this->cancelTransition = true;
209	5	}
210
211	10	public function getCurrentState()
212		{
213	10	return $this->currentState;
214		}
215
216	4	public function getCurrentEvent()
217		{
218	4	return $this->currentEvent;
219		}
220
221	1	public function getNextState()
222		{
223	1	return $this->nextState;
224		}
225
226	2	public function getMachineToArray(): array
227		{
228	2	return $this->sm;
229		}
230
231		/**
232		* All possible transitions from current state.
233		*
234		* @return array
235		*/
236		/*public function getPossibleTransitions(){
237		// TODO: pending to implementation
238		}*/
239
240	33	private function setCurrentStateIfThisIsInitialState($state): void
241		{
242	33	if( $this->currentState == null)
243	33	$this->currentState = $state;
244	33	}
245
246	35	private function argumentIsValidOrFail($arg): void
247		{
248	35	$this->argumentIsNotNullOrFail($arg);
249	34	$this->argumentIsNotBlankOrFail($arg);
250	33	}
251
252	35	private function argumentIsNotNullOrFail($arg): void
253		{
254	35	if( $arg === null )
255	5	throw new \InvalidArgumentException("Null is not an valid argument");
256	34	}
257
258	34	private function argumentIsNotBlankOrFail($arg): void
259		{
260	34	if( trim($arg) === "" )
261	3	throw new \InvalidArgumentException("Blank is not an valid argument");
262	33	}
263
264	23	private function eventMustExistOrFail($event)
265		{
266	23	if( !( isset($this->sm[$this->currentState][$event]) ) )
267	2	throw new \InvalidArgumentException("Unexpected event '{$event}' on '{$this->currentState}' state");
268	22	}
269
270	22	private function stateMustExistOrFail($state)
271		{
272	22	if( ! isset($this->sm[$state]) )
273	2	throw new \InvalidArgumentException("Event '{$this->currentEvent}' fired to unadded '{$state}' state");
274	20	}
275
276	4	private function argumentMustBeClosureOrFail($action): void
277		{
278	4	if( !($action instanceof \Closure) )
279	1	throw new \InvalidArgumentException('execAction argument must be Closure or array');
280	3	}
281		}
282

jagarsoft / php-state-machine

Push — master ( cf9b22...f8edaa )

StateMachine::argumentMustBeClosureOrFail() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like