DoS\ResourceBundle\Twig\Extension\TransitionHelper

Complexity

Total Complexity

38

Size/Duplication

Total Lines	328
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes	5
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	setFactory()	0	4	1
A	setTranslator()	0	4	1
A	getTranslationState()	0	4	1
A	getTranslationTransition()	0	4	1
A	getTransition()	0	4	1
A	isState()	0	4	1
C	__construct()	0	26	8
A	getFunctions()	0	12	1
A	getTranslation()	0	8	2
A	getTransitionColor()	0	7	2
A	isNegativeColor()	0	8	2
A	isPositiveColor()	0	8	2
A	getState()	0	8	2
A	getStateColor()	0	11	3
A	getConstant()	0	6	1
A	getTransitions()	0	13	3
B	getPosibleTransitions()	0	33	6

<?php

namespace DoS\ResourceBundle\Twig\Extension;

use DoS\ResourceBundle\Model\StatableInterface;
use SM\Factory\Factory;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\Translation\TranslatorInterface;

abstract class TransitionHelper extends \Twig_Extension
{
    /**
     * @var array
     */
    protected $options = array(
        'state' => array(
            'translation' => null,
            'default_color' => 'black',
            'negative_colors' => array('red'),
            'positive_colors' => array('green'),
        ),
        'transition' => array(
            'translation' => null,
            'default_color' => 'black',
            'negative_colors' => array('red'),
            'positive_colors' => array('green'),
        ),
    );

    /**
     * @var array
     */
    protected $colors = array();

    /**
     * @var array
     */
    protected $negativeColors = array();

    /**
     * @var array
     */
    protected $positiveColors = array();

    /**
     * @var Factory
     */
    protected $factory;

    /**
     * @var TranslatorInterface
     */
    protected $translator;

    /**
     * @param array $options
     */
    public function __construct(array $options = array())
    {
        $this->options = array_replace_recursive($this->options, $options);

        foreach ($this->options as $type => $options) {
            if (!empty($options['colors'])) {
                foreach ($options['colors'] as $color => $states) {
                    if (!is_array($states)) {
                        $states = (array) $states;
                    }

                    foreach ($states as $state) {
                        $this->colors[$type][$state] = $color;
                    }
                }
            }

            if (!empty($options['negative_colors'])) {
                $this->negativeColors[$type] = $options['negative_colors'];
            }

            if (!empty($options['positive_colors'])) {
                $this->positiveColors[$type] = $options['positive_colors'];
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getFunctions()
    {
        return array(
            new \Twig_SimpleFunction('ts_is', array($this, 'isState')),

The class Twig_SimpleFunction has been deprecated with message: to be removed in 3.0

            new \Twig_SimpleFunction('ts_state', array($this, 'getState')),

The class Twig_SimpleFunction has been deprecated with message: to be removed in 3.0

            new \Twig_SimpleFunction('ts_color', array($this, 'getStateColor')),

The class Twig_SimpleFunction has been deprecated with message: to be removed in 3.0

            new \Twig_SimpleFunction('ts_color_t', array($this, 'getTransitionColor')),

The class Twig_SimpleFunction has been deprecated with message: to be removed in 3.0

            new \Twig_SimpleFunction('ts_transitions', array($this, 'getPosibleTransitions')),

The class Twig_SimpleFunction has been deprecated with message: to be removed in 3.0

            new \Twig_SimpleFunction('ts_trans_s', array($this, 'getTranslationState')),

The class Twig_SimpleFunction has been deprecated with message: to be removed in 3.0

            new \Twig_SimpleFunction('ts_trans_t', array($this, 'getTranslationTransition')),

The class Twig_SimpleFunction has been deprecated with message: to be removed in 3.0

        );
    }

    /**
     * @param Factory $factory
     */
    public function setFactory(Factory $factory)
    {
        $this->factory = $factory;
    }

    /**
     * @param TranslatorInterface $translator
     */
    public function setTranslator(TranslatorInterface $translator)
    {
        $this->translator = $translator;
    }

    /**
     * @param string|StatableInterface $key
     * @param string $type
     * @return string
     */
    public function getTranslation($key, $type = 'state')
    {
        if (strtolower($type) === 'state') {
            return $this->translator->trans($this->getState($key));
        }

        return $this->translator->trans($this->getTransition($key));

It seems like $key defined by parameter $key on line 122 can also be of type object<DoS\ResourceBundle\Model\StatableInterface>; however, DoS\ResourceBundle\Twig\Extension\TransitionHelper::getTransition() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * @param string|StatableInterface $keyOrObject
     *
     * @return string
     */
    public function getTranslationState($keyOrObject)
    {
        return $this->getTranslation($keyOrObject, 'state');
    }

    /**
     * @param $key
     *
     * @return string
     */
    public function getTranslationTransition($key)
    {
        return $this->getTranslation($key, 'transition');
    }

    /**
     * Get transition translator key.
     *
     * @param string $transition
     *
     * @return string
     */
    public function getTransition($transition)
    {
        return $this->options['transition']['translation'].'.'.$transition;
    }

    /**
     * Get transition color.
     *
     * @param string $transition
     *
     * @return string
     */
    public function getTransitionColor($transition)
    {
        return empty($this->colors['transition'][$transition])
            ? $this->options['transition']['default_color']
            : $this->colors['transition'][$transition]
        ;
    }

    /**
     * Check color is negative?
     *
     * @param $color
     * @param $type
     *
     * @return bool
     */
    public function isNegativeColor($color, $type)
    {
        if (empty($this->negativeColors[$type])) {
            return false;
        }

        return in_array($color, $this->negativeColors[$type]);
    }

    /**
     * Check color is positive?
     *
     * @param $color
     * @param $type
     *
     * @return bool
     */
    public function isPositiveColor($color, $type)
    {
        if (empty($this->positiveColors[$type])) {
            return false;
        }

        return in_array($color, $this->positiveColors[$type]);
    }

    /**
     * Get state translator key.
     *
     * @param string|object $state
     *
     * @return string
     */
    public function getState($state)
    {
        if ($state instanceof StatableInterface) {
            $state = $state->getState();
        }

        return $this->options['state']['translation'].'.'.$state;
    }

    /**
     * Get state color.
     *
     * @param string|object $state
     *
     * @return string
     */
    public function getStateColor($state)
    {
        if ($state instanceof StatableInterface) {
            $state = $state->getState();
        }

        return empty($this->colors['state'][$state])
            ? $this->options['state']['default_color']
            : $this->colors['state'][$state]
        ;
    }

    /**
     * @param string $class Class name
     * @param string $name  Constant name
     *
     * @return mixed
     */
    protected function getConstant($class, $name)
    {
        $cls = new \ReflectionClass($class);

        return $cls->getConstant($name);
    }

    /**
     * @param $class
     * @param string $prefix
     *
     * @return array
     * @deprecated implement StatableInterface in client class.
     */
    protected function getTransitions($class, $prefix = 'TS')
    {
        $cls = new \ReflectionClass($class);

        $transitions = array();
        foreach ($cls->getConstants() as $const => $value) {
            if (preg_match(sprintf('/^%s_.*/', $prefix), $const)) {
                $transitions[$const] = $value;
            }
        }

        return $transitions;
    }

    /**
     * Get all of posible transitions.
     *
     * @param StatableInterface $object
     * @param string $objectIdentifier
     *
     * @return array|null
     *
     * @throws \SM\SMException
     */
    public function getPosibleTransitions(StatableInterface $object =  null, $objectIdentifier = 'id')
    {
        if (empty($object)) {
            return;
        }

        $sm = $this->factory->get($object, $object->getStateGraph());

        if (empty($sm)) {
            return;
        }

        $tasks = array();
        $accessor = PropertyAccess::createPropertyAccessor();

        foreach ($object->getStateTransitions() as $transition) {
            if ($sm->can($transition)) {

                $color = $this->getTransitionColor($transition);
                $tasks[] = array(
                    'id' => $accessor->getValue($object, $objectIdentifier),
                    'name' => $transition,
                    'color' => $color,
                    'graph' => $object->getStateGraph(),
                    'label' => $this->getTransition($transition),
                    'negative' => $this->isNegativeColor($color, 'transition'),
                    'positive' => $this->isPositiveColor($color, 'transition'),
                );
            }
        }

        return empty($tasks) ? null : $tasks;
    }

    /**
     * Compare state.
     *
     * @param array|string $stateCompare State(s) to compare
     * @param StatableInterface $object
     *
     * @return bool
     */
    public function isState($stateCompare, StatableInterface $object)
    {
        return in_array(strtolower($object->getState()), (array) $stateCompare);
    }
}