Metabor\Statemachine\Util\SetupHelper

Complexity

Total Complexity

22

Size/Duplication

Total Lines	168
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

66.06%

Importance

Changes	4
Bugs	0	Features	2

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	createNewState()	0	4	1
A	findOrCreateState()	0	12	3
B	findTransition()	0	13	6
A	addTransition()	0	8	2
A	createNewTransition()	0	4	1
A	findOrCreateTransition()	0	12	2
A	createNewEvent()	0	8	2
A	findOrCreateEvent()	0	9	2
A	addCommand()	0	4	1
A	addCommandAndSelfTransition()	0	5	1

<?php

namespace Metabor\Statemachine\Util;

use Metabor\Statemachine\State;
use Metabor\Statemachine\StateCollection;
use Metabor\Statemachine\Transition;
use MetaborStd\Event\EventInterface;
use MetaborStd\Statemachine\ConditionInterface;
use MetaborStd\Statemachine\StateCollectionInterface;
use MetaborStd\Statemachine\StateInterface;
use MetaborStd\Statemachine\TransitionInterface;

/**
 * @author Oliver Tischlinger
 */
class SetupHelper
{
    /**
     * @var StateCollectionInterface
     */
    protected $stateCollection;

    /**
     * @param StateCollectionInterface $stateCollection
     */
    public function __construct(StateCollectionInterface $stateCollection)
    {
        $this->stateCollection = $stateCollection;
    }

    /**
     * @param string $name
     * @return StateInterface
     */
    protected function createNewState($name)
    {
        return new State($name);
    }

    /**
     * @param $name
     *
     * @return \MetaborStd\Statemachine\StateInterface
     *
     * @throws \Exception
     */
    public function findOrCreateState($name)
    {
        if (!$this->stateCollection->hasState($name)) {
            if ($this->stateCollection instanceof StateCollection) {
                $this->stateCollection->addState($this->createNewState($name));
            } else {
                throw new \InvalidArgumentException('Overwrite this method to implement a different type!');
            }
        }

        return $this->stateCollection->getState($name);
    }

    /**
     * @param StateInterface     $sourceState
     * @param StateInterface     $targetState
     * @param string             $eventName
     * @param ConditionInterface $condition
     *
     * @return TransitionInterface
     */
    protected function findTransition(StateInterface $sourceState, StateInterface $targetState, $eventName = null, ConditionInterface $condition = null)
    {
        $conditionName = $condition ? $condition->getName() : null;
        /* @var $transition TransitionInterface */
        foreach ($sourceState->getTransitions() as $transition) {
            $hasSameTargetState = ($transition->getTargetState() === $targetState);
            $hasSameCondition = ($transition->getConditionName() == $conditionName);
            $hasSameEvent = ($transition->getEventName() == $eventName);
            if ($hasSameTargetState && $hasSameCondition && $hasSameEvent) {
                return $transition;
            }
        }
    }

    /**
     * @param StateInterface      $sourceState
     * @param TransitionInterface $sourceTransition
     *
     * @throws \InvalidArgumentException
     */
    protected function addTransition(StateInterface $sourceState, TransitionInterface $sourceTransition)
    {
        if ($sourceState instanceof State) {
            $sourceState->addTransition($sourceTransition);
        } else {
            throw new \InvalidArgumentException('Overwrite this method to implement a different type!');
        }
    }

    /**
     * @param StateInterface     $sourceState
     * @param StateInterface     $targetState
     * @param string             $eventName
     * @param ConditionInterface $condition
     *
     * @return TransitionInterface
     */
    public function createNewTransition(StateInterface $sourceState, StateInterface $targetState, $eventName = null, ConditionInterface $condition = null)

The parameter $sourceState is not used and could be removed.

    {
        return new Transition($targetState, $eventName, $condition);
    }

    /**
     * @param string             $sourceStateName
     * @param string             $targetStateName
     * @param string             $eventName
     * @param ConditionInterface $condition
     *
     * @return TransitionInterface
     */
    public function findOrCreateTransition($sourceStateName, $targetStateName, $eventName = null, ConditionInterface $condition = null)
    {
        $sourceState = $this->findOrCreateState($sourceStateName);
        $targetState = $this->findOrCreateState($targetStateName);
        $transition = $this->findTransition($sourceState, $targetState, $eventName, $condition);
        if (!$transition) {
            $transition = $this->createNewTransition($sourceState, $targetState, $eventName, $condition);
            $this->addTransition($sourceState, $transition);
        }

        return $transition;
    }

    /**
     * @param StateInterface     $sourceState
     * @param string             $eventName
     *
     * @return EventInterface
     */
    public function createNewEvent(StateInterface $sourceState, $eventName)
    {
        if ($sourceState instanceof State) {
            return $sourceState->getEvent($eventName);
        } else {
            throw new \InvalidArgumentException('Overwrite this method to implement a different type!');
        }
    }

    /**
     * @param string $sourceStateName
     * @param string $eventName
     * @return EventInterface
     */
    public function findOrCreateEvent($sourceStateName, $eventName)
    {
        $sourceState = $this->findOrCreateState($sourceStateName);
        if ($sourceState->hasEvent($eventName)) {
            return $sourceState->getEvent($eventName);
        } else {
            return $this->createNewEvent($sourceState, $eventName);
        }
    }

    /**
     * If there is no Transition from the SourceState with this Event use addCommandAndSelfTransition().
     *
     * @param $sourceStateName
     * @param string  $eventName
     * @param \SplObserver $command
     */
    public function addCommand($sourceStateName, $eventName, \SplObserver $command)
    {
        $this->findOrCreateEvent($sourceStateName, $eventName)->attach($command);
    }

    /**
     * @param $sourceStateName
     * @param string  $eventName
     * @param \SplObserver $command
     */
    public function addCommandAndSelfTransition($sourceStateName, $eventName, \SplObserver $command)
    {
        $this->addCommand($sourceStateName, $eventName, $command);
        $this->findOrCreateTransition($sourceStateName, $sourceStateName, $eventName);
    }
}