StefanoTree\NestedSet\Adapter\Doctrine2DBALAdapter

Complexity

Total Complexity

47

Size/Duplication

Total Lines	488
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

95.71%

Importance

Changes	5
Bugs	3	Features	1

25 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	getOptions()	0	4	1
A	getConnection()	0	4	1
A	cleanData()	0	14	1
A	setDefaultDbSelect()	0	4	1
A	getDefaultDbSelect()	0	18	2
A	getLockSqlBuilder()	0	13	2
A	lockTable()	0	13	2
A	unlockTable()	0	10	2
A	beginTransaction()	0	5	1
A	commitTransaction()	0	5	1
A	rollbackTransaction()	0	5	1
B	update()	0	28	3
A	insert()	0	15	1
A	delete()	0	18	1
A	deleteAll()	0	15	1
A	moveLeftIndexes()	0	22	2
A	moveRightIndexes()	0	22	2
A	updateParentId()	0	18	1
B	updateLevels()	0	24	2
B	moveBranch()	0	25	2
B	getNode()	0	24	2
A	getNodeInfo()	0	19	2
B	getPath()	0	43	5
C	getDescendants()	0	51	7

<?php
namespace StefanoTree\NestedSet\Adapter;

use Doctrine\DBAL\Connection as DbConnection;
use Doctrine\DBAL\Query\QueryBuilder;
use StefanoTree\NestedSet\NodeInfo;
use StefanoTree\NestedSet\Options;
use StefanoLockTable\Factory as LockSqlBuilderFactory;
use StefanoLockTable\Adapter\AdapterInterface as LockSqlBuilderInterface;

class Doctrine2DBALAdapter
    implements AdapterInterface

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

{
    private $options;

    private $connection;

    private $defaultDbSelect;

    private $lockSqlBuilder;

    /**
     * @param Options $options
     * @param DbConnection $connection
     */
    public function __construct(Options $options, DbConnection $connection)
    {
        $this->options = $options;
        $this->connection = $connection;
    }

    /**
     * @return Options
     */
    private function getOptions()
    {
        return $this->options;
    }

    /**
     * @return DbConnection
     */
    private function getConnection()
    {
        return $this->connection;
    }


    /**
     * Data cannot contain keys like idColumnName, levelColumnName, ...
     *
     * @param array $data
     * @return array
     */
    private function cleanData(array $data)
    {
        $options = $this->getOptions();

        $disallowedDataKeys = array(
            $options->getIdColumnName(),
            $options->getLeftColumnName(),
            $options->getRightColumnName(),
            $options->getLevelColumnName(),
            $options->getParentIdColumnName(),
        );

        return array_diff_key($data, array_flip($disallowedDataKeys));
    }

    /**
     * @param QueryBuilder $dbSelect
     * @return void
     */
    public function setDefaultDbSelect(QueryBuilder $dbSelect)
    {
        $this->defaultDbSelect = $dbSelect;
    }

    /**
     * Return clone of default db select
     * @return QueryBuilder
     */
    public function getDefaultDbSelect()
    {
        $options = $this->getOptions();

        if (null == $this->defaultDbSelect) {
            $queryBuilder = $this->getConnection()
                                 ->createQueryBuilder();

            $queryBuilder->select('*')
                         ->from($options->getTableName(), null);

            $this->defaultDbSelect = $queryBuilder;
        }

        $dbSelect = clone $this->defaultDbSelect;

        return $dbSelect;
    }

    /**
     * @return LockSqlBuilderInterface
     */
    private function getLockSqlBuilder()
    {
        if (null == $this->lockSqlBuilder) {
            $vendorName = $this->getConnection()
                               ->getDatabasePlatform()
                               ->getName();

            $factory = new LockSqlBuilderFactory();
            $this->lockSqlBuilder = $factory->createAdapter($vendorName);
        }

        return $this->lockSqlBuilder;
    }

    public function lockTable()
    {
        $tableName = $this->getOptions()
                          ->getTableName();

        $sql = $this->getLockSqlBuilder()
                    ->getLockSqlString($tableName);

        if (null != $sql) {

It seems like you are loosely comparing $sql of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $this->getConnection()
                 ->executeQuery($sql);
        }
    }

    public function unlockTable()
    {
        $sql = $this->getLockSqlBuilder()
                    ->getUnlockSqlString();

        if (null != $sql) {

It seems like you are loosely comparing $sql of type string|null against null; this is ambiguous if the string can be empty. Consider using a strict comparison !== instead.

            $this->getConnection()
                 ->executeQuery($sql);
        }
    }

    public function beginTransaction()
    {
        $this->getConnection()
             ->beginTransaction();
    }

    public function commitTransaction()
    {
        $this->getConnection()
             ->commit();
    }

    public function rollbackTransaction()
    {
        $this->getConnection()
             ->rollBack();
    }

    public function update($nodeId, array $data, NodeInfo $nodeInfo = null)
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        if (null == $nodeInfo) {
            $data = $this->cleanData($data);
        } else {
            $data[$options->getParentIdColumnName()] = $nodeInfo->getParentId();
            $data[$options->getLevelColumnName()]    = $nodeInfo->getLevel();
            $data[$options->getLeftColumnName()]     = $nodeInfo->getLeft();
            $data[$options->getRightColumnName()]    = $nodeInfo->getRight();
        }

        $sql = $connection->createQueryBuilder();

        $sql->update($options->getTableName(), null)
            ->where($options->getIdColumnName() . ' = :' . $options->getIdColumnName());

        foreach ($data as $key => $value) {
            $sql->set($connection->quoteIdentifier($key), ':' . $key);
        }

        $data[$options->getIdColumnName()] = $nodeId;

        $connection->executeUpdate($sql, $data);
    }

    public function insert(NodeInfo $nodeInfo, array $data)
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        $data[$options->getParentIdColumnName()] = $nodeInfo->getParentId();
        $data[$options->getLevelColumnName()]    = $nodeInfo->getLevel();
        $data[$options->getLeftColumnName()]     = $nodeInfo->getLeft();
        $data[$options->getRightColumnName()]    = $nodeInfo->getRight();

        $connection->insert($options->getTableName(), $data);

        return $connection->lastInsertId($options->getSequenceName());
    }

    public function delete($leftIndex, $rightIndex)
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->delete($options->getTableName())
            ->where($options->getLeftColumnName() . ' >= :leftIndex'
                . ' AND ' . $options->getRightColumnName() . ' <= :rightIndex');

        $params = array(
            ':leftIndex' => $leftIndex,
            ':rightIndex' => $rightIndex,
        );

        $connection->executeQuery($sql, $params);
    }

    public function deleteAll($expectNodeId)
    {
        $options = $this->getOptions();
        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->delete($options->getTableName())
            ->where($options->getIdColumnName() . ' != :nodeId');

        $params = array(
            ':nodeId' => $expectNodeId,
        );

        $connection->executeQuery($sql, $params);
    }

    public function moveLeftIndexes($fromIndex, $shift)
    {
        $options = $this->getOptions();

        if (0 == $shift) {
            return;
        }

        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->update($options->getTableName())
            ->set($options->getLeftColumnName(), $options->getLeftColumnName() . ' + :shift')
            ->where($options->getLeftColumnName() . ' > :fromIndex');

        $params = array(
            ':shift' => $shift,
            ':fromIndex' => $fromIndex,
        );

        $connection->executeUpdate($sql, $params);
    }

    public function moveRightIndexes($fromIndex, $shift)
    {
        $options = $this->getOptions();

        if (0 == $shift) {
            return;
        }

        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->update($options->getTableName())
            ->set($options->getRightColumnName(), $options->getRightColumnName() . ' + :shift')
            ->where($options->getRightColumnName() . ' > :fromIndex');

        $params = array(
            ':shift' => $shift,
            ':fromIndex' => $fromIndex,
        );

        $connection->executeUpdate($sql, $params);
    }

    public function updateParentId($nodeId, $newParentId)
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->update($options->getTableName())
            ->set($options->getParentIdColumnName(), ':parentId')
            ->where($options->getIdColumnName() . ' = :nodeId');

        $params = array(
            ':parentId' => $newParentId,
            ':nodeId' => $nodeId,
        );

        $connection->executeUpdate($sql, $params);
    }

    public function updateLevels($leftIndexFrom, $rightIndexTo, $shift)
    {
        $options = $this->getOptions();

        if (0 == $shift) {
            return;
        }

        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->update($options->getTableName())
            ->set($options->getLevelColumnName(), $options->getLevelColumnName() . ' + :shift')
            ->where($options->getLeftColumnName() . ' >= :leftFrom'
                    . ' AND ' . $options->getRightColumnName() . ' <= :rightTo');

        $params = array(
            ':shift' => $shift,
            ':leftFrom' => $leftIndexFrom,
            ':rightTo' => $rightIndexTo,
        );

        $connection->executeUpdate($sql, $params);
    }

    public function moveBranch($leftIndexFrom, $rightIndexTo, $shift)
    {
        if (0 == $shift) {
            return;
        }

        $options = $this->getOptions();

        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->update($options->getTableName())
            ->set($options->getLeftColumnName(), $options->getLeftColumnName() . ' + :shift')
            ->set($options->getRightColumnName(), $options->getRightColumnName() . ' + :shift')
            ->where($options->getLeftColumnName() . ' >= :leftFrom'
                . ' AND ' . $options->getRightColumnName() . ' <= :rightTo');

        $params = array(
            ':shift' => $shift,
            ':leftFrom' => $leftIndexFrom,
            ':rightTo' => $rightIndexTo,
        );

        $connection->executeUpdate($sql, $params);
    }

    public function getNode($nodeId)
    {
        $options = $this->getOptions();

        $nodeId = (int) $nodeId;

        $connection = $this->getConnection();


        $sql = $this->getDefaultDbSelect();
        $sql->where($options->getIdColumnName() . ' = :' . $options->getIdColumnName());

        $params = array(
            $options->getIdColumnName() => $nodeId,
        );

        $stmt = $connection->executeQuery($sql, $params);

        $node = $stmt->fetch();

        if (is_array($node)) {
            return $node;
        }
    }

    public function getNodeInfo($nodeId)
    {
        $options = $this->getOptions();
        $result = $this->getNode($nodeId);

        if (null == $result) {
            $result = null;
        } else {
            $id        = $result[$options->getIdColumnName()];
            $parentId  = $result[$options->getParentIdColumnName()];
            $level     = $result[$options->getLevelColumnName()];
            $left      = $result[$options->getLeftColumnName()];
            $right     = $result[$options->getRightColumnName()];

            $result = new NodeInfo($id, $parentId, $level, $left, $right);
        }

        return $result;
    }

    public function getPath($nodeId, $startLevel = 0, $excludeLastNode = false)
    {
        $options = $this->getOptions();

        $startLevel = (int) $startLevel;

        // node does not exist
        if (!$nodeInfo = $this->getNodeInfo($nodeId)) {
            return;
        }

        $connection = $this->getConnection();

        $sql = $this->getDefaultDbSelect();
        $sql->where($options->getLeftColumnName() . ' <= :leftIndex')
            ->andWhere($options->getRightColumnName() . ' >= :rightIndex')
            ->orderBy($options->getLeftColumnName(), 'ASC');

        $params = array(
            'leftIndex' => $nodeInfo->getLeft(),
            'rightIndex' => $nodeInfo->getRight(),
        );

        if (0 < $startLevel) {
            $sql->andWhere($options->getLevelColumnName() . ' >= :startLevel');

            $params['startLevel'] = $startLevel;
        }

        if (true == $excludeLastNode) {

It seems like you are loosely comparing two booleans. Considering using the strict comparison === instead.

            $sql->andWhere($options->getLevelColumnName() . ' < :level');

            $params['level'] = $nodeInfo->getLevel();
        }

        $stmt = $connection->executeQuery($sql, $params);

        $result = $stmt->fetchAll();

        if (is_array($result)) {
            return $result;
        }
    }

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

        if (!$nodeInfo = $this->getNodeInfo($nodeId)) {
            return;
        }

        $connection = $this->getConnection();
        $sql = $this->getDefaultDbSelect();
        $sql->orderBy($options->getLeftColumnName(), 'ASC');

        $params = array();

        if (0 != $startLevel) {
            $sql->andWhere($options->getLevelColumnName() . ' >= :startLevel');

            $params['startLevel'] = $nodeInfo->getLevel() + (int) $startLevel;
        }

        if (null != $levels) {

It seems like you are loosely comparing $levels of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

            $sql->andWhere($options->getLevelColumnName() . '< :endLevel');
            $params['endLevel'] = $nodeInfo->getLevel() + (int) $startLevel + abs($levels);
        }

        if (null != $excludeBranch && null != ($excludeNodeInfo = $this->getNodeInfo($excludeBranch))) {

It seems like you are loosely comparing $excludeBranch of type integer|null against null; this is ambiguous if the integer can be zero. Consider using a strict comparison !== instead.

            $sql->andWhere('(' . $options->getLeftColumnName() . ' BETWEEN :left AND :exLeftMinusOne'
                    . ') OR (' . $options->getLeftColumnName() . ' BETWEEN :exRightPlusOne AND :right)')
                ->andWhere('(' . $options->getRightColumnName() . ' BETWEEN :exRightPlusOne AND :right'
                    . ') OR (' . $options->getRightColumnName() . ' BETWEEN :left AND :exLeftMinusOne)');

            $params['left']           = $nodeInfo->getLeft();
            $params['exLeftMinusOne'] = $excludeNodeInfo->getLeft() - 1;
            $params['exRightPlusOne'] = $excludeNodeInfo->getRight() + 1;
            $params['right']          = $nodeInfo->getRight();
        } else {
            $sql->andWhere($options->getLeftColumnName() . ' >= :left')
                ->andWhere($options->getRightColumnName() . ' <= :right');

            $params['left']  = $nodeInfo->getLeft();
            $params['right'] = $nodeInfo->getRight();
        }

        $stmt = $connection->executeQuery($sql, $params);

        $result = $stmt->fetchAll();

        if (0 < count($result)) {
            return $result;
        }
    }
}