StateMachine - Code Metrics - Inspection of "Merge pull request #115 from realshadow/master" - yohang/Finite - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dc53d4...128e93 )

by Yohan

created 2016-04-18 10:55 UTC

StateMachine B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	384
Duplicated Lines	0 %

Coupling/Cohesion

Dependencies

Test Coverage

Coverage

89.03%

Importance

Changes	27
Bugs	6	Features	7

Metric	Value
wmc	50
c	27
b	6
f	7
cbo	13
dl	0
loc	384
ccs	138
cts	155
cp	0.8903
rs	8.6206

22 Methods

Rating	Name	Size	Complexity
A	getTransitions()	4	1
A	getStates()	4	1
A	setObject()	4	1
A	getObject()	4	1
A	getCurrentState()	4	1
A	setDispatcher()	4	1
A	getDispatcher()	4	1
A	setStateAccessor()	4	1
A	__construct()	9	3
B	initialize()	26	4
B	apply()	24	2
B	can()	17	5
A	addState()	8	2
D	addTransition()	37	10
A	getTransition()	13	2
A	getState()	15	2
A	findInitialState()	14	3
A	hasStateAccessor()	4	1
A	setGraph()	4	1
A	getGraph()	4	1
B	findStateWithProperty()	24	4
A	dispatchTransitionEvent()	8	2

How to fix Complexity

<?php

namespace Finite\StateMachine;

use Finite\Event\FiniteEvents;
use Finite\Event\StateMachineEvent;
use Finite\Event\TransitionEvent;
use Finite\Exception;
use Finite\State\Accessor\PropertyPathStateAccessor;
use Finite\State\Accessor\StateAccessorInterface;
use Finite\State\State;
use Finite\State\StateInterface;
use Finite\Transition\Transition;
use Finite\Transition\TransitionInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

/**
 * The Finite State Machine.
 *
 * @author Yohan Giarelli <[email protected]>
 */
class StateMachine implements StateMachineInterface

{
    /**
     * The stateful object.
     *
     * @var object
     */
    protected $object;

    /**
     * The available states.
     *
     * @var array
     */
    protected $states = array();

    /**
     * The available transitions.
     *
     * @var array
     */
    protected $transitions = array();

    /**
     * The current state.
     *
     * @var StateInterface
     */
    protected $currentState;

    /**
     * @var EventDispatcherInterface
     */
    protected $dispatcher;

    /**
     * @var StateAccessorInterface
     */
    protected $stateAccessor;

    /**
     * @var string
     */
    protected $graph;

    /**
     * @param object                   $object
     * @param EventDispatcherInterface $dispatcher
     * @param StateAccessorInterface   $stateAccessor
     */
    public function __construct(
        $object = null,
        EventDispatcherInterface $dispatcher = null,
        StateAccessorInterface $stateAccessor = null
    ) {
        $this->object = $object;
        $this->dispatcher = $dispatcher ?: new EventDispatcher();
        $this->stateAccessor = $stateAccessor ?: new PropertyPathStateAccessor();
    }

    /**
     * {@inheritdoc}
     */
    public function initialize()
    {
        if (null === $this->object) {
            throw new Exception\ObjectException('No object bound to the State Machine');
        }

        try {
            $initialState = $this->stateAccessor->getState($this->object);
        } catch (Exception\NoSuchPropertyException $e) {
            throw new Exception\ObjectException(sprintf(
               'StateMachine can\'t be initialized because the defined property_path of object "%s" does not exist.',
                get_class($this->object)
            ), $e->getCode(), $e);
        }

        if (null === $initialState) {
            $initialState = $this->findInitialState();
            $this->stateAccessor->setState($this->object, $initialState);

            $this->dispatcher->dispatch(FiniteEvents::SET_INITIAL_STATE, new StateMachineEvent($this));
        }

        $this->currentState = $this->getState($initialState);

        $this->dispatcher->dispatch(FiniteEvents::INITIALIZE, new StateMachineEvent($this));
    }

    /**
     * {@inheritdoc}
     *
     * @throws Exception\StateException
     */
    public function apply($transitionName, array $parameters = array())
    {
        $transition = $this->getTransition($transitionName);
        $event = new TransitionEvent($this->getCurrentState(), $transition, $this, $parameters);
        if (!$this->can($transition, $parameters)) {
            throw new Exception\StateException(sprintf(
                'The "%s" transition can not be applied to the "%s" state of object "%s" with graph "%s".',
                $transition->getName(),
                $this->currentState->getName(),
                get_class($this->getObject()),
                $this->getGraph()
            ));
        }

        $this->dispatchTransitionEvent($transition, $event, FiniteEvents::PRE_TRANSITION);

        $returnValue = $transition->process($this);
        $this->stateAccessor->setState($this->object, $transition->getState());
        $this->currentState = $this->getState($transition->getState());

        $this->dispatchTransitionEvent($transition, $event, FiniteEvents::POST_TRANSITION);

        return $returnValue;
    }

    /**
     * {@inheritdoc}
     */
    public function can($transition, array $parameters = array())
    {
        $transition = $transition instanceof TransitionInterface ? $transition : $this->getTransition($transition);

        if (null !== $transition->getGuard() && !call_user_func($transition->getGuard(), $this)) {
            return false;
        }

        if (!in_array($transition->getName(), $this->getCurrentState()->getTransitions())) {
            return false;
        }

        $event = new TransitionEvent($this->getCurrentState(), $transition, $this, $parameters);
        $this->dispatchTransitionEvent($transition, $event, FiniteEvents::TEST_TRANSITION);

        return !$event->isRejected();
    }

    /**
     * {@inheritdoc}
     */
    public function addState($state)
    {
        if (!$state instanceof StateInterface) {
            $state = new State($state);
        }

        $this->states[$state->getName()] = $state;
    }

    /**
     * {@inheritdoc}
     */
    public function addTransition($transition, $initialState = null, $finalState = null)
    {
        if ((null === $initialState || null === $finalState) && !$transition instanceof TransitionInterface) {
            throw new \InvalidArgumentException(
                'You must provide a TransitionInterface instance or the $transition, '.
                '$initialState and $finalState parameters'
            );
        }
        // If transition isn't a TransitionInterface instance, we create one from the states date
        if (!$transition instanceof TransitionInterface) {
            try {
                $transition = $this->getTransition($transition);
            } catch (Exception\TransitionException $e) {
                $transition = new Transition($transition, $initialState, $finalState);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            }
        }

        $this->transitions[$transition->getName()] = $transition;

        // We add missings states to the State Machine
        try {
            $this->getState($transition->getState());
        } catch (Exception\StateException $e) {
            $this->addState($transition->getState());
        }
        foreach ($transition->getInitialStates() as $state) {
            try {
                $this->getState($state);
            } catch (Exception\StateException $e) {
                $this->addState($state);
            }
            $state = $this->getState($state);
            if ($state instanceof State) {
                $state->addTransition($transition);
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getTransition($name)
    {
        if (!isset($this->transitions[$name])) {
            throw new Exception\TransitionException(sprintf(
                'Unable to find a transition called "%s" on object "%s" with graph "%s".',
                $name,
                get_class($this->getObject()),
                $this->getGraph()
            ));
        }

        return $this->transitions[$name];
    }

    /**
     * {@inheritdoc}
     */
    public function getState($name)
    {
        $name = (string) $name;

        if (!isset($this->states[$name])) {
            throw new Exception\StateException(sprintf(
                'Unable to find a state called "%s" on object "%s" with graph "%s".',
                $name,
                get_class($this->getObject()),
                $this->getGraph()
            ));
        }

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

    /**
     * {@inheritdoc}
     */
    public function getTransitions()
    {
        return array_keys($this->transitions);
    }

    /**
     * {@inheritdoc}
     */
    public function getStates()
    {
        return array_keys($this->states);
    }

    /**
     * {@inheritdoc}
     */
    public function setObject($object)
    {
        $this->object = $object;
    }

    /**
     * {@inheritdoc}
     */
    public function getObject()
    {
        return $this->object;
    }

    /**
     * {@inheritdoc}
     */
    public function getCurrentState()
    {
        return $this->currentState;
    }

    /**
     * Find and return the Initial state if exists.
     *
     * @return string
     *
     * @throws Exception\StateException
     */
    protected function findInitialState()
    {
        foreach ($this->states as $state) {
            if (State::TYPE_INITIAL === $state->getType()) {
                return $state->getName();
            }
        }

        throw new Exception\StateException(sprintf(
            'No initial state found on object "%s" with graph "%s".',
            get_class($this->getObject()),
            $this->getGraph()
        ));
    }

    /**
     * @param EventDispatcherInterface $dispatcher
     */
    public function setDispatcher(EventDispatcherInterface $dispatcher)
    {
        $this->dispatcher = $dispatcher;
    }

    /**
     * @return EventDispatcherInterface
     */
    public function getDispatcher()
    {
        return $this->dispatcher;
    }

    /**
     * @param StateAccessorInterface $stateAccessor
     */
    public function setStateAccessor(StateAccessorInterface $stateAccessor)
    {
        $this->stateAccessor = $stateAccessor;
    }

    /**
     * {@inheritdoc}
     */
    public function hasStateAccessor()
    {
        return null !== $this->stateAccessor;
    }

    /**
     * {@inheritdoc}
     */
    public function setGraph($graph)
    {
        $this->graph = $graph;
    }

    /**
     * {@inheritdoc}
     */
    public function getGraph()
    {
        return $this->graph;
    }

    /**
     * {@inheritDoc}
     */
    public function findStateWithProperty($property, $value = null)
    {
        return array_keys(
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
            array_map(
                function (State $state) {
                    return $state->getName();
                },
                array_filter(
                    $this->states,
                    function (State $state) use ($property, $value) {
                        if (!$state->has($property)) {
                            return false;
                        }

                        if (null !== $value && $state->get($property) !== $value) {
                            return false;
                        }

                        return true;
                    }
                )
            )
        );
    }

    /**
     * Dispatches event for the transition
     *
     * @param TransitionInterface $transition
     * @param TransitionEvent $event
     * @param type $transitionState
     */
    private function dispatchTransitionEvent(TransitionInterface $transition, TransitionEvent $event, $transitionState)
    {
        $this->dispatcher->dispatch($transitionState, $event);
        $this->dispatcher->dispatch($transitionState.'.'.$transition->getName(), $event);
        if (null !== $this->getGraph()) {
            $this->dispatcher->dispatch($transitionState.'.'.$this->getGraph().'.'.$transition->getName(), $event);
        }
    }
}


1		<?php
2
3		namespace Finite\StateMachine;
4
5		use Finite\Event\FiniteEvents;
6		use Finite\Event\StateMachineEvent;
7		use Finite\Event\TransitionEvent;
8		use Finite\Exception;
9		use Finite\State\Accessor\PropertyPathStateAccessor;
10		use Finite\State\Accessor\StateAccessorInterface;
11		use Finite\State\State;
12		use Finite\State\StateInterface;
13		use Finite\Transition\Transition;
14		use Finite\Transition\TransitionInterface;
15		use Symfony\Component\EventDispatcher\EventDispatcher;
16		use Symfony\Component\EventDispatcher\EventDispatcherInterface;
17
18		/**
19		* The Finite State Machine.
20		*
21		* @author Yohan Giarelli <[email protected]>
22		*/
23		class StateMachine implements StateMachineInterface
		0 ignored issues – show Complexity introduced 2016-04-01 09:45 UTC by Report Bug Copy Issue Report This class has a complexity of 50 which exceeds the configured maximum of 50. The class complexity is the sum of the complexity of all methods. A very high value is usually an indication that your class does not follow the single reponsibility principle and does more than one job. Some resources for further reading: Single Reponsibility Principle Open/Closed Principle You can also find more detailed suggestions for refactoring in the “Code” section of your repository. Loading history... Complexity introduced 2016-04-01 09:45 UTC by Report Bug Copy Issue Report The class StateMachine has a coupling between objects value of 20. Consider to reduce the number of dependencies under 13. Loading history...
24		{
25		/**
26		* The stateful object.
27		*
28		* @var object
29		*/
30		protected $object;
31
32		/**
33		* The available states.
34		*
35		* @var array
36		*/
37		protected $states = array();
38
39		/**
40		* The available transitions.
41		*
42		* @var array
43		*/
44		protected $transitions = array();
45
46		/**
47		* The current state.
48		*
49		* @var StateInterface
50		*/
51		protected $currentState;
52
53		/**
54		* @var EventDispatcherInterface
55		*/
56		protected $dispatcher;
57
58		/**
59		* @var StateAccessorInterface
60		*/
61		protected $stateAccessor;
62
63		/**
64		* @var string
65		*/
66		protected $graph;
67
68		/**
69		* @param object $object
70		* @param EventDispatcherInterface $dispatcher
71		* @param StateAccessorInterface $stateAccessor
72		*/
73	215	public function __construct(
74		$object = null,
75		EventDispatcherInterface $dispatcher = null,
76		StateAccessorInterface $stateAccessor = null
77		) {
78	215	$this->object = $object;
79	215	$this->dispatcher = $dispatcher ?: new EventDispatcher();
80	215	$this->stateAccessor = $stateAccessor ?: new PropertyPathStateAccessor();
81	215	}
82
83		/**
84		* {@inheritdoc}
85		*/
86	160	public function initialize()
87		{
88	160	if (null === $this->object) {
89		throw new Exception\ObjectException('No object bound to the State Machine');
90		}
91
92		try {
93	160	$initialState = $this->stateAccessor->getState($this->object);
94	128	} catch (Exception\NoSuchPropertyException $e) {
95		throw new Exception\ObjectException(sprintf(
96		'StateMachine can\'t be initialized because the defined property_path of object "%s" does not exist.',
97		get_class($this->object)
98		), $e->getCode(), $e);
99		}
100
101	160	if (null === $initialState) {
102	20	$initialState = $this->findInitialState();
103	20	$this->stateAccessor->setState($this->object, $initialState);
104
105	20	$this->dispatcher->dispatch(FiniteEvents::SET_INITIAL_STATE, new StateMachineEvent($this));
106	16	}
107
108	160	$this->currentState = $this->getState($initialState);
109
110	160	$this->dispatcher->dispatch(FiniteEvents::INITIALIZE, new StateMachineEvent($this));
111	160	}
112
113		/**
114		* {@inheritdoc}
115		*
116		* @throws Exception\StateException
117		*/
118	20	public function apply($transitionName, array $parameters = array())
119		{
120	20	$transition = $this->getTransition($transitionName);
121	20	$event = new TransitionEvent($this->getCurrentState(), $transition, $this, $parameters);
122	20	if (!$this->can($transition, $parameters)) {
123	5	throw new Exception\StateException(sprintf(
124	5	'The "%s" transition can not be applied to the "%s" state of object "%s" with graph "%s".',
125	5	$transition->getName(),
126	5	$this->currentState->getName(),
127	5	get_class($this->getObject()),
128	5	$this->getGraph()
129	4	));
130		}
131
132	20	$this->dispatchTransitionEvent($transition, $event, FiniteEvents::PRE_TRANSITION);
133
134	20	$returnValue = $transition->process($this);
135	20	$this->stateAccessor->setState($this->object, $transition->getState());
136	20	$this->currentState = $this->getState($transition->getState());
137
138	20	$this->dispatchTransitionEvent($transition, $event, FiniteEvents::POST_TRANSITION);
139
140	20	return $returnValue;
141		}
142
143		/**
144		* {@inheritdoc}
145		*/
146	55	public function can($transition, array $parameters = array())
147		{
148	55	$transition = $transition instanceof TransitionInterface ? $transition : $this->getTransition($transition);
149
150	55	if (null !== $transition->getGuard() && !call_user_func($transition->getGuard(), $this)) {
151	5	return false;
152		}
153
154	50	if (!in_array($transition->getName(), $this->getCurrentState()->getTransitions())) {
155	30	return false;
156		}
157
158	50	$event = new TransitionEvent($this->getCurrentState(), $transition, $this, $parameters);
159	50	$this->dispatchTransitionEvent($transition, $event, FiniteEvents::TEST_TRANSITION);
160
161	50	return !$event->isRejected();
162		}
163
164		/**
165		* {@inheritdoc}
166		*/
167	180	public function addState($state)
168		{
169	180	if (!$state instanceof StateInterface) {
170	175	$state = new State($state);
171	140	}
172
173	180	$this->states[$state->getName()] = $state;
174	180	}
175
176		/**
177		* {@inheritdoc}
178		*/
179	175	public function addTransition($transition, $initialState = null, $finalState = null)
180		{
181	175	if ((null === $initialState \|\| null === $finalState) && !$transition instanceof TransitionInterface) {
182		throw new \InvalidArgumentException(
183		'You must provide a TransitionInterface instance or the $transition, '.
184		'$initialState and $finalState parameters'
185		);
186		}
187		// If transition isn't a TransitionInterface instance, we create one from the states date
188	175	if (!$transition instanceof TransitionInterface) {
189		try {
190	155	$transition = $this->getTransition($transition);
191	155	} catch (Exception\TransitionException $e) {
192	155	$transition = new Transition($transition, $initialState, $finalState);
		0 ignored issues – show Documentation introduced 2015-11-30 09:01 UTC by Report Bug Copy Issue Report `$transition` is of type `object<Finite\Transition\TransitionInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
193		}
194	124	}
195
196	175	$this->transitions[$transition->getName()] = $transition;
197
198		// We add missings states to the State Machine
199		try {
200	175	$this->getState($transition->getState());
201	158	} catch (Exception\StateException $e) {
202	90	$this->addState($transition->getState());
203		}
204	175	foreach ($transition->getInitialStates() as $state) {
205		try {
206	175	$this->getState($state);
207	147	} catch (Exception\StateException $e) {
208	35	$this->addState($state);
209		}
210	175	$state = $this->getState($state);
211	175	if ($state instanceof State) {
212	175	$state->addTransition($transition);
213	140	}
214	140	}
215	175	}
216
217		/**
218		* {@inheritdoc}
219		*/
220	160	public function getTransition($name)
221		{
222	160	if (!isset($this->transitions[$name])) {
223	155	throw new Exception\TransitionException(sprintf(
224	155	'Unable to find a transition called "%s" on object "%s" with graph "%s".',
225	124	$name,
226	155	get_class($this->getObject()),
227	155	$this->getGraph()
228	124	));
229		}
230
231	55	return $this->transitions[$name];
232		}
233
234		/**
235		* {@inheritdoc}
236		*/
237	180	public function getState($name)
238		{
239	180	$name = (string) $name;
240
241	180	if (!isset($this->states[$name])) {
242	95	throw new Exception\StateException(sprintf(
243	95	'Unable to find a state called "%s" on object "%s" with graph "%s".',
244	76	$name,
245	95	get_class($this->getObject()),
246	95	$this->getGraph()
247	76	));
248		}
249
250	180	return $this->states[$name];
251		}
252
253		/**
254		* {@inheritdoc}
255		*/
256	5	public function getTransitions()
257		{
258	5	return array_keys($this->transitions);
259		}
260
261		/**
262		* {@inheritdoc}
263		*/
264	5	public function getStates()
265		{
266	5	return array_keys($this->states);
267		}
268
269		/**
270		* {@inheritdoc}
271		*/
272	150	public function setObject($object)
273		{
274	150	$this->object = $object;
275	150	}
276
277		/**
278		* {@inheritdoc}
279		*/
280	175	public function getObject()
281		{
282	175	return $this->object;
283		}
284
285		/**
286		* {@inheritdoc}
287		*/
288	115	public function getCurrentState()
289		{
290	115	return $this->currentState;
291		}
292
293		/**
294		* Find and return the Initial state if exists.
295		*
296		* @return string
297		*
298		* @throws Exception\StateException
299		*/
300	20	protected function findInitialState()
301		{
302	20	foreach ($this->states as $state) {
303	20	if (State::TYPE_INITIAL === $state->getType()) {
304	20	return $state->getName();
305		}
306		}
307
308		throw new Exception\StateException(sprintf(
309		'No initial state found on object "%s" with graph "%s".',
310		get_class($this->getObject()),
311		$this->getGraph()
312		));
313		}
314
315		/**
316		* @param EventDispatcherInterface $dispatcher
317		*/
318		public function setDispatcher(EventDispatcherInterface $dispatcher)
319		{
320		$this->dispatcher = $dispatcher;
321		}
322
323		/**
324		* @return EventDispatcherInterface
325		*/
326	5	public function getDispatcher()
327		{
328	5	return $this->dispatcher;
329		}
330
331		/**
332		* @param StateAccessorInterface $stateAccessor
333		*/
334	10	public function setStateAccessor(StateAccessorInterface $stateAccessor)
335		{
336	10	$this->stateAccessor = $stateAccessor;
337	10	}
338
339		/**
340		* {@inheritdoc}
341		*/
342	15	public function hasStateAccessor()
343		{
344	15	return null !== $this->stateAccessor;
345	15	}
346
347		/**
348		* {@inheritdoc}
349		*/
350	175	public function setGraph($graph)
351		{
352	175	$this->graph = $graph;
353		}
354
355		/**
356		* {@inheritdoc}
357		*/
358	10	public function getGraph()
359		{
360	10	return $this->graph;
361	8	}
362
363	10	/**
364	10	* {@inheritDoc}
365	8	*/
366	10	public function findStateWithProperty($property, $value = null)
367	10	{
368	10	return array_keys(
		0 ignored issues – show Bug Best Practice introduced 2015-12-02 16:52 UTC by Report Bug Copy Issue Report The return type of `return array_keys(array_... return true; })));` (`array<integer\|string>`) is incompatible with the return type declared by the interface `Finite\StateMachine\Stat...::findStateWithProperty` of type `boolean`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
369	10	array_map(
370		function (State $state) {
371		return $state->getName();
372	10	},
373	5	array_filter(
374		$this->states,
375		function (State $state) use ($property, $value) {
376	10	if (!$state->has($property)) {
377	2	return false;
378	8	}
379	8
380	8	if (null !== $value && $state->get($property) !== $value) {
381		return false;
382		}
383
384		return true;
385		}
386		)
387		)
388		);
389		}
390	50
391		/**
392	50	* Dispatches event for the transition
393	50	*
394	50	* @param TransitionInterface $transition
395	10	* @param TransitionEvent $event
396	8	* @param type $transitionState
397	50	*/
398		private function dispatchTransitionEvent(TransitionInterface $transition, TransitionEvent $event, $transitionState)
399		{
400		$this->dispatcher->dispatch($transitionState, $event);
401		$this->dispatcher->dispatch($transitionState.'.'.$transition->getName(), $event);
402		if (null !== $this->getGraph()) {
403		$this->dispatcher->dispatch($transitionState.'.'.$this->getGraph().'.'.$transition->getName(), $event);
404		}
405		}
406		}
407

yohang / Finite

Push — master ( dc53d4...128e93 )

StateMachine B

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

22 Methods

How to fix Complexity

Complex Class

Duplication Side-by-Side

Filter issues like