Core\Form\Hydrator\Strategy\TreeSelectStrategy

Complexity

Total Complexity

23

Size/Duplication

Total Lines	194
Duplicated Lines	7.73 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setAttachedLeafs()	0	6	1
A	getAttachedLeafs()	0	4	1
A	setTreeRoot()	0	6	1
A	getTreeRoot()	0	4	1
A	setAllowSelectMultipleItems()	0	6	1
A	allowSelectMultipleItems()	0	6	2
B	extract()	0	22	5
B	hydrate()	0	22	4
A	getItemValue()	15	15	2
B	findLeaf()	0	18	5

<?php
/**
 * YAWIK
 *
 * @filesource
 * @license MIT
 * @copyright  2013 - 2016 Cross Solution <http://cross-solution.de>
 */
  
/** */
namespace Core\Form\Hydrator\Strategy;

use Core\Entity\Tree\AbstractLeafs;
use Core\Entity\Tree\NodeInterface;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Zend\Hydrator\Strategy\StrategyInterface;

/**
 * Hydrator strategy for TreeSelect form element.
 * 
 * @author Mathias Gelhausen <gelhausen@cross-solution.de>
 * @since 0.29
 */
class TreeSelectStrategy implements StrategyInterface
{

    /**
     * The selected leafs.
     *
     * @var AbstractLeafs
     */
    private $attachedLeafs;

    /**
     * The root node.
     *
     * @var NodeInterface
     */
    private $treeRoot;

    /**
     * Flag wether multiple selections are allowed.
     *
     * @var bool|callable
     */
    private $allowSelectMultipleItems = false;

    /**
     * Set the selected leafs.
     *
     * @param AbstractLeafs $attachedLeafs
     *
     * @return self
     */
    public function setAttachedLeafs(AbstractLeafs $attachedLeafs)
    {
        $this->attachedLeafs = $attachedLeafs;

        return $this;
    }

    /**
     * Get the selected leafs.
     *
     * @return AbstractLeafs
     */
    public function getAttachedLeafs()
    {
        return $this->attachedLeafs;
    }

    /**
     * Set the root node.
     *
     * @param NodeInterface $treeRoot
     *
     * @return self
     */
    public function setTreeRoot(NodeInterface $treeRoot)
    {
        $this->treeRoot = $treeRoot;

        return $this;
    }

    /**
     * Get the root node.
     *
     * @return NodeInterface
     */
    public function getTreeRoot()
    {
        return $this->treeRoot;
    }

    /**
     * Set the allow multiple selections flag.
     *
     * @param Callable|bool $flagOrCallback When a Callable is passed, it must return bool.
     *
     * @return self
     */
    public function setAllowSelectMultipleItems($flagOrCallback)
    {
        $this->allowSelectMultipleItems = $flagOrCallback;

        return $this;
    }

    /**
     * Are multiple selections allowed?
     *
     * @return bool
     */
    public function allowSelectMultipleItems()

function allowSelectMultipleItems() does not seem to conform to the naming convention (^(?:is|has|should|may|supports)).

    {
        $flagOrCallback = $this->allowSelectMultipleItems;

        return is_callable($flagOrCallback) ? (bool) $flagOrCallback() : (bool) $flagOrCallback;
    }

    public function extract($value)
    {
        if (!$value instanceOf AbstractLeafs) {
            throw new \InvalidArgumentException('$value must be an instance of ' . AbstractLeafs::class);
        }
        /* @var AbstractLeafs $value
         * @var NodeInterface $item */

        $this->setAttachedLeafs($value);

        if (!$this->allowSelectMultipleItems()) {
            $item = $value->getItems()->first();
            return $item ? $this->getItemValue($item) : null;
        }

        $data = [];
        foreach ($value->getItems() as $item) {
            $data[] = $this->getItemValue($item);
        }

        return $data;
    }

    public function hydrate($value)
    {
        $root = $this->getTreeRoot();
        $object = $this->getAttachedLeafs();
        $items = new ArrayCollection();

        if (!$this->allowSelectMultipleItems()) {
            $value = [$value];
        }

        foreach ($value as $itemValue) {
            $leaf = $this->findLeaf($root, $itemValue);

Are you sure the assignment to $leaf is correct as $this->findLeaf($root, $itemValue) (which targets Core\Form\Hydrator\Strategy\TreeSelectStrategy::findLeaf()) seems to always return null.

            if ($leaf) {
                $items->add($leaf);
            }
        }

        $object->setItems($items);

        return $object;
    }

    /**
     * Get item value for use in the option tag.
     *
     * @param NodeInterface $item
     *
     * @return string item value prepended with all parent values except root node.
     */
    private function getItemValue(NodeInterface $item)

This method seems to be duplicated in your project.

    {
        $parts = [ $item->getValue() ];

        while ($item = $item->getParent()) {
            $parts[] = $item->getValue();
        }

        array_pop($parts); // No root node.

        $parts = array_reverse($parts);
        $value = join('-', $parts);

        return $value;
    }

    /**
     * Find a leaf with a concrete value in the tree.
     *
     * @param NodeInterface $leaf
     * @param string        $value
     *
     * @return NodeInterface|null
     */
    private function findLeaf(NodeInterface $leaf, $value)
    {
        $parts = is_array($value) ? $value : explode('-', $value);
        $value = array_shift($parts);

        /* @var NodeInterface $item */
        foreach ($leaf->getChildren() as $item) {
            if ($item->getValue() == $value) {
                if (count($parts)) {
                    return $this->findLeaf($item, $parts);

$parts is of type array, but the function expects a string.

                }

                return $item;
            }
        }

        return null;
    }
}