StefanoTree\NestedSet

Complexity

Total Complexity

50

Size/Duplication

Total Lines	402
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	14

Test Coverage

Coverage

93.51%

Importance

Changes	12
Bugs	4	Features	1

24 Methods

Rating	Name	Duplication	Size	Complexity
A	factory()	0	15	4
A	__construct()	0	4	1
A	getAdapter()	0	4	1
A	getRootNodeId()	0	4	1
A	isRoot()	0	8	2
A	updateNode()	0	5	1
B	addNode()	0	52	4
B	getAddStrategy()	0	17	5
A	addNodePlacementBottom()	0	4	1
A	addNodePlacementTop()	0	4	1
A	addNodePlacementChildBottom()	0	4	1
A	addNodePlacementChildTop()	0	4	1
A	moveNodePlacementBottom()	0	4	1
A	moveNodePlacementTop()	0	4	1
A	moveNodePlacementChildBottom()	0	4	1
A	moveNodePlacementChildTop()	0	4	1
B	getMoveStrategy()	0	17	5
A	getPath()	0	5	1
A	getNode()	0	5	1
A	getDescendants()	0	5	1
A	getChildren()	0	4	1
C	moveNode()	0	77	8
B	deleteBranch()	0	42	4
B	clear()	0	24	2

<?php
namespace StefanoTree;

use StefanoTree\NestedSet\Adapter\Zend1DbAdapter;
use StefanoTree\NestedSet\NodeInfo;
use Exception;
use StefanoTree\Exception\InvalidArgumentException;
use StefanoTree\NestedSet\AddStrategy;
use StefanoTree\NestedSet\AddStrategy\AddStrategyInterface;
use StefanoTree\NestedSet\MoveStrategy;
use StefanoTree\NestedSet\MoveStrategy\MoveStrategyInterface;
use StefanoTree\NestedSet\Adapter\AdapterInterface;
use StefanoTree\NestedSet\Options;
use StefanoTree\NestedSet\Adapter\Doctrine2DBALAdapter;
use StefanoTree\NestedSet\Adapter\Zend2DbAdapter;
use StefanoDb\Adapter\ExtendedAdapterInterface;
use Doctrine\DBAL\Connection as DoctrineConnection;
use Zend_Db_Adapter_Abstract;

class NestedSet
    implements TreeInterface

The implements keyword must be on the same line as the class name

{
    private $adapter;

    /**
     * @param Options $options
     * @param object $dbAdapter
     * @return TreeInterface
     * @throws InvalidArgumentException
     */
    public static function factory(Options $options, $dbAdapter)
    {
        if ($dbAdapter instanceof ExtendedAdapterInterface) {
            $adapter = new Zend2DbAdapter($options, $dbAdapter);

$dbAdapter of type object<StefanoDb\Adapter\ExtendedAdapterInterface> is not a sub-type of object<StefanoDb\Adapter\Adapter>. It seems like you assume a concrete implementation of the interface StefanoDb\Adapter\ExtendedAdapterInterface to be always present.

        } elseif ($dbAdapter instanceof DoctrineConnection) {
            $adapter = new Doctrine2DBALAdapter($options, $dbAdapter);
        } elseif ($dbAdapter instanceof Zend_Db_Adapter_Abstract) {
            $adapter = new Zend1DbAdapter($options, $dbAdapter);
        } else {
            throw new InvalidArgumentException('Db adapter "' . get_class($dbAdapter)
                . '" is not supported');
        }

        return new self($adapter);
    }

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

    /**
     * @return AdapterInterface
     */
    public function getAdapter()
    {
        return $this->adapter;
    }

    /**
     * @return int
     */
    private function getRootNodeId()
    {
        return 1;
    }

    /**
     * Test if node is root node
     *
     * @param int $nodeId
     * @return boolean
     */
    private function isRoot($nodeId)
    {
        if ($this->getRootNodeId() == $nodeId) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * @param int $nodeId
     * @param array $data
     */
    public function updateNode($nodeId, $data)
    {
        $this->getAdapter()
             ->update($nodeId, $data);
    }

    /**
     * @param int $targetNodeId
     * @param string $placement
     * @param array $data
     * @return int|false Id of new created node. False if node has not been created
     * @throws Exception
     */
    protected function addNode($targetNodeId, $placement, $data = array())
    {
        $adapter = $this->getAdapter();

        $adapter->beginTransaction();
        try {
            $adapter->lockTable();

            $targetNode = $adapter->getNodeInfo($targetNodeId);

            if (null == $targetNode) {
                $adapter->commitTransaction();
                $adapter->unlockTable();

                return false;
            }

            $addStrategy = $this->getAddStrategy($targetNode, $placement);

            if (false == $addStrategy->canAddNewNode($this->getRootNodeId())) {
                $adapter->commitTransaction();
                $adapter->unlockTable();

                return false;
            }

            //make hole
            $moveFromIndex = $addStrategy->moveIndexesFromIndex($targetNode);

The call to Bottom::moveIndexesFromIndex() has too many arguments starting with $targetNode.

The call to Top::moveIndexesFromIndex() has too many arguments starting with $targetNode.

The call to ChildBottom::moveIndexesFromIndex() has too many arguments starting with $targetNode.

The call to ChildTop::moveIndexesFromIndex() has too many arguments starting with $targetNode.

            $adapter->moveLeftIndexes($moveFromIndex, 2);
            $adapter->moveRightIndexes($moveFromIndex, 2);

            //insert new node
            $newNodeInfo = new NodeInfo(
                null,
                $addStrategy->newParentId(),
                $addStrategy->newLevel(),
                $addStrategy->newLeftIndex(),
                $addStrategy->newRightIndex()
            );
            $lastGeneratedValue = $adapter->insert($newNodeInfo, $data);

            $adapter->commitTransaction();
            $adapter->unlockTable();
        } catch (Exception $e) {
            $adapter->rollbackTransaction();
            $adapter->unlockTable();

            throw $e;
        }

        return $lastGeneratedValue;
    }

    /**
     * @param NodeInfo $targetNode
     * @param string $placement
     * @return AddStrategyInterface
     * @throws InvalidArgumentException
     */
    private function getAddStrategy(NodeInfo $targetNode, $placement)
    {
        switch ($placement) {
            case self::PLACEMENT_BOTTOM:
                return new AddStrategy\Bottom($targetNode);
            case self::PLACEMENT_TOP:
                return new AddStrategy\Top($targetNode);
            case self::PLACEMENT_CHILD_BOTTOM:
                return new AddStrategy\ChildBottom($targetNode);
            case self::PLACEMENT_CHILD_TOP:
                return new AddStrategy\ChildTop($targetNode);
        // @codeCoverageIgnoreStart
            default:
                throw new InvalidArgumentException('Unknown placement "' . $placement . '"');
        }
        // @codeCoverageIgnoreEnd
    }

    public function addNodePlacementBottom($targetNodeId, $data = array())
    {
        return $this->addNode($targetNodeId, self::PLACEMENT_BOTTOM, $data);
    }

    public function addNodePlacementTop($targetNodeId, $data = array())
    {
        return $this->addNode($targetNodeId, self::PLACEMENT_TOP, $data);
    }

    public function addNodePlacementChildBottom($targetNodeId, $data = array())
    {
        return $this->addNode($targetNodeId, self::PLACEMENT_CHILD_BOTTOM, $data);
    }

    public function addNodePlacementChildTop($targetNodeId, $data = array())
    {
        return $this->addNode($targetNodeId, self::PLACEMENT_CHILD_TOP, $data);
    }

    /**
     * @param int $sourceNodeId
     * @param int $targetNodeId
     * @param string $placement
     * @return boolean
     * @throws Exception
     * @throws InvalidArgumentException
     */
    protected function moveNode($sourceNodeId, $targetNodeId, $placement)
    {
        $adapter = $this->getAdapter();

        //source node and target node are equal
        if ($sourceNodeId == $targetNodeId) {
            return false;
        }

        $adapter->beginTransaction();
        try {
            $adapter->lockTable();

            $sourceNodeInfo = $adapter->getNodeInfo($sourceNodeId);
            $targetNodeInfo = $adapter->getNodeInfo($targetNodeId);

            //source node or target node does not exist
            if (!$sourceNodeInfo || !$targetNodeInfo) {
                $adapter->commitTransaction();
                $adapter->unlockTable();

                return false;
            }

            $moveStrategy = $this->getMoveStrategy($sourceNodeInfo, $targetNodeInfo, $placement);

            if (!$moveStrategy->canMoveBranch($this->getRootNodeId())) {
                $adapter->commitTransaction();
                $adapter->unlockTable();

                return false;
            }

            if ($moveStrategy->isSourceNodeAtRequiredPosition()) {
                $adapter->commitTransaction();
                $adapter->unlockTable();

                return true;
            }

            //update parent id
            $newParentId = $moveStrategy->getNewParentId();
            if ($sourceNodeInfo->getParentId() != $newParentId) {
                $adapter->updateParentId($sourceNodeId, $newParentId);
            }

            //update levels
            $adapter->updateLevels($sourceNodeInfo->getLeft(), $sourceNodeInfo->getRight(),
                    $moveStrategy->getLevelShift());

            //make hole
            $adapter->moveLeftIndexes($moveStrategy->makeHoleFromIndex(),
                        $moveStrategy->getIndexShift());
            $adapter->moveRightIndexes($moveStrategy->makeHoleFromIndex(),
                        $moveStrategy->getIndexShift());

            //move branch to the hole
            $adapter->moveBranch($moveStrategy->getHoleLeftIndex(),
                $moveStrategy->getHoleRightIndex(), $moveStrategy->getSourceNodeIndexShift());

            //patch hole
            $adapter->moveLeftIndexes($moveStrategy->fixHoleFromIndex(),
                        ($moveStrategy->getIndexShift() * -1));
            $adapter->moveRightIndexes($moveStrategy->fixHoleFromIndex(),
                        ($moveStrategy->getIndexShift() * -1));

            $adapter->commitTransaction();
            $adapter->unlockTable();
        } catch (Exception $e) {
            $adapter->rollbackTransaction();
            $adapter->unlockTable();

            throw $e;
        }

        return true;
    }

    public function moveNodePlacementBottom($sourceNodeId, $targetNodeId)
    {
        return $this->moveNode($sourceNodeId, $targetNodeId, self::PLACEMENT_BOTTOM);
    }

    public function moveNodePlacementTop($sourceNodeId, $targetNodeId)
    {
        return $this->moveNode($sourceNodeId, $targetNodeId, self::PLACEMENT_TOP);
    }

    public function moveNodePlacementChildBottom($sourceNodeId, $targetNodeId)
    {
        return $this->moveNode($sourceNodeId, $targetNodeId, self::PLACEMENT_CHILD_BOTTOM);
    }

    public function moveNodePlacementChildTop($sourceNodeId, $targetNodeId)
    {
        return $this->moveNode($sourceNodeId, $targetNodeId, self::PLACEMENT_CHILD_TOP);
    }

    /**
     * @param NodeInfo $sourceNode
     * @param NodeInfo $targetNode
     * @param string $placement
     * @return MoveStrategyInterface
     * @throws InvalidArgumentException
     */
    private function getMoveStrategy(NodeInfo $sourceNode, NodeInfo $targetNode, $placement)
    {
        switch ($placement) {
            case self::PLACEMENT_BOTTOM:
                return new MoveStrategy\Bottom($sourceNode, $targetNode);
            case self::PLACEMENT_TOP:
                return new MoveStrategy\Top($sourceNode, $targetNode);
            case self::PLACEMENT_CHILD_BOTTOM:
                return new MoveStrategy\ChildBottom($sourceNode, $targetNode);
            case self::PLACEMENT_CHILD_TOP:
                return new MoveStrategy\ChildTop($sourceNode, $targetNode);
        // @codeCoverageIgnoreStart
            default:
                throw new InvalidArgumentException('Unknown placement "' . $placement . '"');
        }
        // @codeCoverageIgnoreEnd
    }

    public function deleteBranch($nodeId)
    {
        if ($this->isRoot($nodeId)) {
            return false;
        }

        $adapter = $this->getAdapter();

        $adapter->beginTransaction();
        try {
            $adapter->lockTable();

            // node does not exist
            if (!$nodeInfo = $adapter->getNodeInfo($nodeId)) {
                $adapter->commitTransaction();
                $adapter->unlockTable();

                return false;
            }

            // delete branch
            $leftIndex = $nodeInfo->getLeft();
            $rightIndex = $nodeInfo->getRight();
            $adapter->delete($leftIndex, $rightIndex);

            //patch hole
            $moveFromIndex = $nodeInfo->getLeft();
            $shift = $nodeInfo->getLeft() - $nodeInfo->getRight() - 1;
            $adapter->moveLeftIndexes($moveFromIndex, $shift);
            $adapter->moveRightIndexes($moveFromIndex, $shift);

            $adapter->commitTransaction();
            $adapter->unlockTable();
        } catch (Exception $e) {
            $adapter->rollbackTransaction();
            $adapter->unlockTable();

            throw $e;
        }

        return true;
    }

    public function getPath($nodeId, $startLevel = 0, $excludeLastNode = false)
    {
        return $this->getAdapter()
                    ->getPath($nodeId, $startLevel, $excludeLastNode);
    }

    public function clear(array $data = array())
    {
        $adapter = $this->getAdapter();

        $adapter->beginTransaction();
        try {
            $adapter->lockTable();

            $adapter->deleteAll($this->getRootNodeId());

            $nodeInfo = new NodeInfo(null, 0, 0, 1, 2);
            $adapter->update($this->getRootNodeId(), $data, $nodeInfo);

            $adapter->commitTransaction();
            $adapter->unlockTable();
        } catch (Exception $e) {
            $adapter->rollbackTransaction();
            $adapter->unlockTable();

            throw $e;
        }

        return $this;
    }

    public function getNode($nodeId)
    {
        return $this->getAdapter()
                    ->getNode($nodeId);
    }

    public function getDescendants($nodeId = 1, $startLevel = 0, $levels = null, $excludeBranch = null)
    {
        return $this->getAdapter()
                    ->getDescendants($nodeId, $startLevel, $levels, $excludeBranch);
    }

    public function getChildren($nodeId)
    {
        return $this->getDescendants($nodeId, 1, 1);
    }
}