Metabor\Statemachine\Util\StateCollectionMerger

Complexity

Total Complexity

32

Size/Duplication

Total Lines	225
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

81%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getStateNamePrefix()	0	4	1
A	setStateNamePrefix()	0	4	1
A	getTargetCollection()	0	4	1
A	createState()	0	4	1
A	addTransition()	0	8	2
A	createCondition()	0	14	3
A	createTransition()	0	16	2
A	mergeMetadata()	0	17	5
A	addState()	0	8	2
A	findOrCreateState()	0	12	2
A	mergeState()	0	23	4
A	mergeStateCollection()	0	7	2
A	merge()	0	14	5

<?php

namespace Metabor\Statemachine\Util;

use Metabor\Statemachine\State;
use Metabor\Statemachine\StateCollection;
use Metabor\Statemachine\Transition;
use MetaborStd\MergeableInterface;
use MetaborStd\MetadataInterface;
use MetaborStd\Statemachine\ConditionInterface;
use MetaborStd\WeightedInterface;
use MetaborStd\Statemachine\StateCollectionInterface;
use MetaborStd\Statemachine\StateInterface;
use MetaborStd\Statemachine\TransitionInterface;

/**
 * @author Oliver Tischlinger
 */
class StateCollectionMerger implements MergeableInterface
{
    /**
     * @var StateCollectionInterface
     */
    private $targetCollection;

    /**
     * @var string
     */
    private $stateNamePrefix;

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

    /**
     * @return string
     */
    public function getStateNamePrefix()
    {
        return $this->stateNamePrefix;
    }

    /**
     * @param string $stateNamePrefix
     */
    public function setStateNamePrefix($stateNamePrefix)
    {
        $this->stateNamePrefix = $stateNamePrefix;
    }

    /**
     * @return \MetaborStd\Statemachine\StateCollectionInterface
     */
    public function getTargetCollection()
    {
        return $this->targetCollection;
    }

    /**
     * @param string $name
     *
     * @return \MetaborStd\Statemachine\StateInterface
     */
    protected function createState($name)
    {
        return new State($name);
    }

    /**
     * @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 TransitionInterface $sourceTransition
     * @return ConditionInterface
     */
    protected function createCondition(TransitionInterface $sourceTransition)
    {
        if ($sourceTransition->getConditionName()) {
            if ($sourceTransition instanceof Transition) {
                $condition = $sourceTransition->getCondition();
            } else {
                throw new \InvalidArgumentException('Overwrite this method to implement a different type!');
            }
        } else {
            $condition = null;
        }

        return $condition;
    }

    /**
     * @param TransitionInterface $sourceTransition
     *
     * @throws \InvalidArgumentException
     *
     * @return \Metabor\Statemachine\Transition
     */
    protected function createTransition(TransitionInterface $sourceTransition)
    {
        $targetStateName = $sourceTransition->getTargetState()->getName();
        $targetState = $this->findOrCreateState($targetStateName);
        $this->mergeMetadata($sourceTransition->getTargetState(), $targetState);
        $eventName = $sourceTransition->getEventName();

        $condition = $this->createCondition($sourceTransition);
        
        $transition = new Transition($targetState, $eventName, $condition);
        if ($sourceTransition instanceof WeightedInterface) {
            $transition->setWeight($sourceTransition->getWeight());
        }

        return $transition;
    }

    /**
     * @param object $source
     * @param object $target
     *
     * @throws \RuntimeException
     */
    protected function mergeMetadata($source, $target)
    {
        if ($source instanceof \ArrayAccess) {
            if ($target instanceof \ArrayAccess) {
                if ($source instanceof MetadataInterface) {
                    $metadata = $source->getMetadata();
                    foreach ($metadata as $offset => $value) {
                        $target->offsetSet($offset, $value);
                    }
                } else {
                    throw new \RuntimeException('Source had to make all metadata available!');
                }
            } else {
                throw new \RuntimeException('Source metadata can not be merged!');
            }
        }
    }

    /**
     * @param StateInterface $state
     *
     * @throws \InvalidArgumentException
     */
    protected function addState(StateInterface $state)
    {
        if ($this->targetCollection instanceof StateCollection) {
            $this->targetCollection->addState($state);
        } else {
            throw new \InvalidArgumentException('TargetCollection has to be a StateCollection. Overwrite this method to implement a different type!');
        }
    }

    /**
     * @param string $name
     *
     * @return \MetaborStd\Statemachine\StateInterface
     */
    protected function findOrCreateState($name)
    {
        $name = $this->stateNamePrefix . $name;
        if ($this->targetCollection->hasState($name)) {
            $targetState = $this->targetCollection->getState($name);
        } else {
            $targetState = $this->createState($name);
            $this->addState($targetState);
        }

        return $targetState;
    }

    /**
     * @param StateInterface $sourceState
     *
     * @throws \InvalidArgumentException
     */
    protected function mergeState(StateInterface $sourceState)
    {
        $name = $sourceState->getName();
        $targetState = $this->findOrCreateState($name);
        $this->mergeMetadata($sourceState, $targetState);

        /* @var $transition TransitionInterface */
        foreach ($sourceState->getTransitions() as $sourceTransition) {
            $targetTransition = $this->createTransition($sourceTransition);
            $this->addTransition($targetState, $targetTransition);
        }

        foreach ($sourceState->getEventNames() as $eventName) {
            $sourceEvent = $sourceState->getEvent($eventName);
            $targetEvent = $targetState->getEvent($eventName);

            $this->mergeMetadata($sourceEvent, $targetEvent);

            foreach ($sourceEvent->getObservers() as $observer) {
                $targetEvent->attach($observer);
            }
        }
    }

    /**
     */
    protected function mergeStateCollection(StateCollectionInterface $source)
    {
        /* @var $sourceState StateInterface */
        foreach ($source->getStates() as $sourceState) {
            $this->mergeState($sourceState);
        }
    }

    /**
     * @see \MetaborStd\MergeableInterface::merge()
     */
    public function merge($source)
    {
        if ($source instanceof StateCollectionInterface) {
            $this->mergeStateCollection($source);
        } elseif ($source instanceof StateInterface) {
            $this->mergeState($source);
        } elseif ($source instanceof \Traversable) {
            foreach ($source as $value) {
                $this->merge($value);
            }
        } else {
            throw new \InvalidArgumentException('Source can not be merged!');
        }
    }
}