Doctrine2DBAL::moveRightIndexes() - Code Metrics - Inspection of "throw ValidationException instead return value" - bartko-s/stefano-tree - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — develop ( c08e7b...416a58 )

by Bartko
created 2017-10-13 16:27 UTC
Doctrine2DBAL::moveRightIndexes() B

↳ Parent: Doctrine2DBAL
Complexity

Conditions	3
Paths	3
Size

Total Lines	27
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	15
CRAP Score	3.0021
Importance

Changes
Metric	Value
dl	0
loc	27
ccs	15
cts	16
cp	0.9375
rs	8.8571
c	0
b	0
f	0
cc	3
eloc	16
nc	3
nop	3
crap	3.0021
<?php

declare(strict_types=1);

namespace StefanoTree\NestedSet\Adapter;

use Doctrine\DBAL\Connection as DbConnection;
use Doctrine\DBAL\Query\QueryBuilder;
use StefanoTree\NestedSet\NodeInfo;
use StefanoTree\NestedSet\Options;

class Doctrine2DBAL extends AdapterAbstract implements AdapterInterface
{
    private $connection;

    private $defaultDbSelect;

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

    /**
     * @param DbConnection $dbAdapter
     */
    protected function setConnection(DbConnection $dbAdapter): void
    {
        $this->connection = $dbAdapter;
    }

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

    /**
     * Return base db select without any join, etc.
     *
     * @return QueryBuilder
     */
    public function getBlankDbSelect(): QueryBuilder
    {
        $queryBuilder = $this->getConnection()
                             ->createQueryBuilder();

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

        return $queryBuilder;
    }

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

    /**
     * Return clone of default db select.
     *
     * @return QueryBuilder
     */
    public function getDefaultDbSelect(): QueryBuilder
    {
        if (null === $this->defaultDbSelect) {
            $this->defaultDbSelect = $this->getBlankDbSelect();
        }

        $dbSelect = clone $this->defaultDbSelect;

        return $dbSelect;
    }

    /**
     * {@inheritdoc}
     */
    public function lockTree(): void
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        $sql = $this->getBlankDbSelect();
        $sql->select($options->getIdColumnName().' AS i');

        $sql = $sql->getSQL().' FOR UPDATE';

        $connection->executeQuery($sql);
    }

    /**
     * {@inheritdoc}
     */
    public function beginTransaction(): void
    {
        $this->getConnection()
             ->beginTransaction();
    }

    /**
     * {@inheritdoc}
     */
    public function commitTransaction(): void
    {
        $this->getConnection()
             ->commit();
    }

    /**
     * {@inheritdoc}
     */
    public function rollbackTransaction(): void
    {
        $this->getConnection()
             ->rollBack();
    }

    /**
     * {@inheritdoc}
     */
    public function update($nodeId, array $data): void
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        $data = $this->cleanData($data);

        $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->getSQL(), $data);
    }

    /**
     * {@inheritdoc}
     */
    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();

        if ($options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $data[$options->getScopeColumnName()] = $nodeInfo->getScope();
        }

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

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

    /**
     * {@inheritdoc}
     */
    public function delete($nodeId): void
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

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

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

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

    /**
     * {@inheritdoc}
     */
    public function moveLeftIndexes($fromIndex, $shift, $scope = null): void
    {
        $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,
        );

        if ($options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $sql->andWhere($options->getScopeColumnName().' = :scope');
            $params[':scope'] = $scope;
        }

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

    /**
     * {@inheritdoc}
     */
    public function moveRightIndexes($fromIndex, $shift, $scope = null): void
    {
        $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,
        );

        if ($options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $sql->andWhere($options->getScopeColumnName().' = :scope');
            $params[':scope'] = $scope;
        }

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

    /**
     * {@inheritdoc}
     */
    public function updateParentId($nodeId, $newParentId): void
    {
        $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->getSQL(), $params);
    }

    /**
     * {@inheritdoc}
     */
    public function updateLevels(int $leftIndexFrom, int $rightIndexTo, int $shift, $scope = null): void
    {
        $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,
        );

        if ($options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $sql->andWhere($options->getScopeColumnName().' = :scope');
            $params[':scope'] = $scope;
        }

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

    /**
     * {@inheritdoc}
     */
    public function moveBranch(int $leftIndexFrom, int $rightIndexTo, int $shift, $scope = null): void
    {
        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,
        );

        if ($options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $sql->andWhere($options->getScopeColumnName().' = :scope');
            $params[':scope'] = $scope;
        }

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

    /**
     * {@inheritdoc}
     */
    public function getRoots($scope = null): array
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        $sql = $this->getBlankDbSelect();
        $sql->where($options->getParentIdColumnName().' IS NULL');
        $sql->orderBy($options->getIdColumnName());

        $params = array();

        if (null != $scope && $options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $sql->where($options->getScopeColumnName().' = :scope');
            $params[':scope'] = $scope;
        }

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

        $node = $stmt->fetchAll();

        return $node;
    }

    /**
     * {@inheritdoc}
     */
    public function getRoot($scope = null): array
    {
        $roots = $this->getRoots($scope);

        return ($roots) ? $roots[0] : array();
    }

    /**
     * {@inheritdoc}
     */
    public function getNode($nodeId): ?array
    {
        $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->getSQL(), $params);

        $node = $stmt->fetch();

        return is_array($node) ? $node : null;
    }

    /**
     * {@inheritdoc}
     */
    public function getNodeInfo($nodeId): ?NodeInfo
    {
        $options = $this->getOptions();

        $nodeId = (int) $nodeId;

        $connection = $this->getConnection();

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

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

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

        $node = $stmt->fetch();

        $data = is_array($node) ? $node : null;

        $result = ($data) ? $this->_buildNodeInfoObject($data) : null;

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function getChildrenNodeInfo($parentNodeId): array
    {
        $connection = $this->getConnection();
        $options = $this->getOptions();

        $queryBuilder = $connection->createQueryBuilder();

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

        $sql = $queryBuilder->select($columns)
                            ->from($options->getTableName())
                            ->where($options->getParentIdColumnName().' = :parentId')
                            ->orderBy($options->getLeftColumnName(), 'ASC');

        $params = array(
            'parentId' => $parentNodeId,
        );

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

        $data = $stmt->fetchAll();

        $result = array();

        foreach ($data as $nodeData) {
            $result[] = $this->_buildNodeInfoObject($nodeData);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function updateNodeMetadata(NodeInfo $nodeInfo): void
    {
        $options = $this->getOptions();

        $connection = $this->getConnection();

        $sql = $connection->createQueryBuilder();
        $sql->update($options->getTableName())
            ->set($options->getRightColumnName(), $nodeInfo->getRight())
            ->set($options->getLeftColumnName(), $nodeInfo->getLeft())
            ->set($options->getLevelColumnName(), $nodeInfo->getLevel())
            ->where($options->getIdColumnName().' = :nodeId');

        $params = array(
            ':nodeId' => $nodeInfo->getId(),
        );

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

    /**
     * {@inheritdoc}
     */
    public function getPath($nodeId, int $startLevel = 0, bool $excludeLastNode = false): array
    {
        $options = $this->getOptions();

        $startLevel = (int) $startLevel;

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

        $connection = $this->getConnection();

        $sql = $this->getDefaultDbSelect();
        $params = array();

        if ($options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $sql->andWhere($options->getScopeColumnName().' = :scope');
            $params['scope'] = $nodeInfo->getScope();
        }

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

        $params['leftIndex'] = $nodeInfo->getLeft();
        $params['rightIndex'] = $nodeInfo->getRight();

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

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

        if (true == $excludeLastNode) {

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

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

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

        $result = $stmt->fetchAll();

        return (is_array($result)) ? $result : array();
    }

    /**
     * {@inheritdoc}
     */
    public function getDescendants($nodeId, int $startLevel = 0, ?int $levels = null, ?int $excludeBranch = null): array
    {
        $options = $this->getOptions();

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

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

        $params = array();

        if ($options->getScopeColumnName()) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $sql->andWhere($options->getScopeColumnName().' = :scope');
            $params['scope'] = $nodeInfo->getScope();
        }

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

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

        if (null != $levels) {

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

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

            $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->getSQL(), $params);

        $result = $stmt->fetchAll();

        return (0 < count($result)) ? $result : array();
    }
}

1		<?php
2
3		declare(strict_types=1);
4
5		namespace StefanoTree\NestedSet\Adapter;
6
7		use Doctrine\DBAL\Connection as DbConnection;
8		use Doctrine\DBAL\Query\QueryBuilder;
9		use StefanoTree\NestedSet\NodeInfo;
10		use StefanoTree\NestedSet\Options;
11
12		class Doctrine2DBAL extends AdapterAbstract implements AdapterInterface
13		{
14		private $connection;
15
16		private $defaultDbSelect;
17
18		/**
19		* @param Options $options
20		* @param DbConnection $connection
21		*/
22	50	public function __construct(Options $options, DbConnection $connection)
23		{
24	50	$this->setOptions($options);
25	50	$this->setConnection($connection);
26	50	}
27
28		/**
29		* @param DbConnection $dbAdapter
30		*/
31	50	protected function setConnection(DbConnection $dbAdapter): void
32		{
33	50	$this->connection = $dbAdapter;
34	50	}
35
36		/**
37		* @return DbConnection
38		*/
39	47	private function getConnection(): DbConnection
40		{
bartko-s / stefano-tree

Push — develop ( c08e7b...416a58 )

Doctrine2DBAL::moveRightIndexes() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
