Zend1::getDescendants() - Code Metrics - Inspection of "UPDATE - repository description" - bartko-s/stefano-tree - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( f2ef3e...a98c98 )

by Bartko
created 2018-07-18 19:45 UTC
Zend1::getDescendants() B

↳ Parent: Zend1
Complexity

Conditions	8
Paths	33
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	34
CRAP Score	8
Importance

Changes
Metric	Value
dl	0
loc	55
ccs	34
cts	34
cp	1
rs	7.7373
c	0
b	0
f	0
cc	8
nc	33
nop	4
crap	8
How to fix Long Method

<?php

declare(strict_types=1);

namespace StefanoTree\NestedSet\Adapter;

use StefanoTree\NestedSet\NodeInfo;
use StefanoTree\NestedSet\Options;
use Zend_Db_Adapter_Abstract as ZendDbAdapter;
use Zend_Db_Select as ZendDbSelect;

class Zend1 extends AdapterAbstract implements AdapterInterface
{
    protected $dbAdapter;

    public function __construct(Options $options, ZendDbAdapter $dbAdapter)
    {
        $this->setOptions($options);
        $this->setDbAdapter($dbAdapter);
    }

    /**
     * @param ZendDbAdapter $dbAdapter
     */
    protected function setDbAdapter(ZendDbAdapter $dbAdapter): void
    {
        $this->dbAdapter = $dbAdapter;
    }

    /**
     * @return ZendDbAdapter
     */
    public function getDbAdapter(): ZendDbAdapter
    {
        return $this->dbAdapter;
    }

    /**
     * {@inheritdoc}
     *
     * @return ZendDbSelect
     */
    public function getBlankDbSelect(): ZendDbSelect
    {
        return $this->getDbAdapter()
            ->select()
            ->from($this->getOptions()->getTableName());
    }

    /**
     * Return default db select. Always new instance.
     *
     * @return ZendDbSelect
     */
    public function getDefaultDbSelect(): ZendDbSelect
    {
        return $this->getDbSelectBuilder()();
    }

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

        $dbAdapter = $this->getDbAdapter();

        $select = $this->getBlankDbSelect()
            ->reset(\Zend_Db_Select::COLUMNS)
            ->columns(array('i' => $options->getIdColumnName(true)))
            ->forUpdate(true);

        $dbAdapter->fetchAll($select);
    }

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

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

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

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

        $dbAdapter = $this->getDbAdapter();

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

        $where = array(
            $dbAdapter->quoteIdentifier($options->getIdColumnName()).' = ?' => $nodeId,
        );
        $dbAdapter->update($options->getTableName(), $data, $where);
    }

    /**
     * {@inheritdoc}
     */
    public function insert(NodeInfo $nodeInfo, array $data)
    {
        $options = $this->getOptions();
        $dbAdapter = $this->getDbAdapter();

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

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

        if (array_key_exists($options->getIdColumnName(), $data)) {
            return $data[$options->getIdColumnName()];
        } else {
            if ('' != $options->getSequenceName()) {
                $lastGeneratedValue = $dbAdapter->lastSequenceId($options->getSequenceName());
            } else {
                $lastGeneratedValue = $dbAdapter->lastInsertId();
            }

            return $lastGeneratedValue;
        }
    }

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

        $dbAdapter = $this->getDbAdapter();

        $where = array(
            $dbAdapter->quoteIdentifier($options->getIdColumnName()).' = ?' => $nodeId,
        );

        $dbAdapter->delete($options->getTableName(), $where);
    }

    /**
     * {@inheritdoc}
     */
    public function moveLeftIndexes($fromIndex, $shift, $scope = null): void
    {
        $options = $this->getOptions();

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

        $dbAdapter = $this->getDbAdapter();
        $sql = 'UPDATE '.$dbAdapter->quoteIdentifier($options->getTableName())
            .' SET '.$dbAdapter->quoteIdentifier($options->getLeftColumnName())
            .' = '.$dbAdapter->quoteIdentifier($options->getLeftColumnName()).' + :shift'
            .' WHERE '.$dbAdapter->quoteIdentifier($options->getLeftColumnName()).' > :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 .= ' AND '.$dbAdapter->quoteIdentifier($options->getScopeColumnName()).' = '.$dbAdapter->quote($scope);
        }

        $binds = array(
            ':shift' => $shift,
            ':fromIndex' => $fromIndex,
        );
        $dbAdapter->prepare($sql)->execute($binds);
    }

    /**
     * {@inheritdoc}
     */
    public function moveRightIndexes($fromIndex, $shift, $scope = null): void
    {
        $options = $this->getOptions();

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

        $dbAdapter = $this->getDbAdapter();

        $sql = 'UPDATE '.$dbAdapter->quoteIdentifier($options->getTableName())
            .' SET '.$dbAdapter->quoteIdentifier($options->getRightColumnName())
            .' = '.$dbAdapter->quoteIdentifier($options->getRightColumnName()).' + :shift'
            .' WHERE '.$dbAdapter->quoteIdentifier($options->getRightColumnName()).' > :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 .= ' AND '.$dbAdapter->quoteIdentifier($options->getScopeColumnName()).' = '.$dbAdapter->quote($scope);
        }

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

        $dbAdapter->prepare($sql)->execute($binds);
    }

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

        $dbAdapter = $this->getDbAdapter();

        $bind = array(
            $options->getParentIdColumnName() => $newParentId,
        );

        $where = array(
            $dbAdapter->quoteIdentifier($options->getIdColumnName()).' = ?' => $nodeId,
        );
        $dbAdapter->update($options->getTableName(), $bind, $where);
    }

    /**
     * {@inheritdoc}
     */
    public function updateLevels(int $leftIndexFrom, int $rightIndexTo, int $shift, $scope = null): void
    {
        $options = $this->getOptions();

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

        $dbAdapter = $this->getDbAdapter();

        $sql = 'UPDATE '.$dbAdapter->quoteIdentifier($options->getTableName())
            .' SET '.$dbAdapter->quoteIdentifier($options->getLevelColumnName())
            .' = '.$dbAdapter->quoteIdentifier($options->getLevelColumnName()).' + :shift'
            .' WHERE '.$dbAdapter->quoteIdentifier($options->getLeftColumnName())
            .' >= :leftFrom'.' AND '.$dbAdapter->quoteIdentifier($options->getRightColumnName())
            .' <= :rightTo';

        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 .= ' AND '.$dbAdapter->quoteIdentifier($options->getScopeColumnName()).' = '.$dbAdapter->quote($scope);
        }

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

        $dbAdapter->prepare($sql)->execute($binds);
    }

    /**
     * {@inheritdoc}
     */
    public function moveBranch(int $leftIndexFrom, int $rightIndexTo, int $shift, $scope = null): void
    {
        if (0 == $shift) {
            return;
        }

        $options = $this->getOptions();

        $dbAdapter = $this->getDbAdapter();

        $sql = 'UPDATE '.$dbAdapter->quoteIdentifier($options->getTableName())
            .' SET '.$dbAdapter->quoteIdentifier($options->getLeftColumnName())
            .' = '.$dbAdapter->quoteIdentifier($options->getLeftColumnName()).' + :shift, '
            .$dbAdapter->quoteIdentifier($options->getRightColumnName())
            .' = '.$dbAdapter->quoteIdentifier($options->getRightColumnName()).' + :shift'
            .' WHERE '.$dbAdapter->quoteIdentifier($options->getLeftColumnName()).' >= :leftFrom'
            .' AND '.$dbAdapter->quoteIdentifier($options->getRightColumnName()).' <= :rightTo';

        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 .= ' AND '.$dbAdapter->quoteIdentifier($options->getScopeColumnName()).' = '.$dbAdapter->quote($scope);
        }

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

        $dbAdapter->prepare($sql)->execute($binds);
    }

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

        $dbAdapter = $this->getDbAdapter();

        $select = $this->getBlankDbSelect()
            ->where($options->getParentIdColumnName(true).' IS NULL')
            ->order($options->getIdColumnName(true));

        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
            $select->where($options->getScopeColumnName(true).' = ?', $scope);
        }

        return $dbAdapter->fetchAll($select);
    }

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

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

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

        $nodeId = (int) $nodeId;

        $dbAdapter = $this->getDbAdapter();

        $select = $this->getDefaultDbSelect()
            ->where($options->getIdColumnName(true).' = ?', $nodeId);

        $row = $dbAdapter->fetchRow($select);

        return $row ? $row : null;
    }

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

        $dbAdapter = $this->getDbAdapter();

        $select = $this->getBlankDbSelect()
            ->where($options->getIdColumnName(true).' = ?', $nodeId);

        $row = $dbAdapter->fetchRow($select);

        $data = $row ? $row : null;

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

        return $result;
    }

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

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

        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
            $columns[] = $options->getScopeColumnName();
        }

        $select = $this->getBlankDbSelect();
        $select->reset(\Zend_Db_Select::COLUMNS);
        $select->columns($columns);
        $select->order($options->getLeftColumnName(true));
        $select->where($options->getParentIdColumnName(true).' = ?', $parentNodeId);

        $data = $dbAdapter->fetchAll($select);

        $result = array();

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

        return $result;
    }

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

        $bind = array(
            $options->getRightColumnName() => $nodeInfo->getRight(),
            $options->getLeftColumnName() => $nodeInfo->getLeft(),
            $options->getLevelColumnName() => $nodeInfo->getLevel(),
        );

        $where = array(
            $dbAdapter->quoteIdentifier($options->getIdColumnName()).' = ?' => $nodeInfo->getId(),
        );

        $dbAdapter->update($options->getTableName(), $bind, $where);
    }

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

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

        $dbAdapter = $this->getDbAdapter();

        $select = $this->getDefaultDbSelect();

        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
            $select->where($options->getScopeColumnName(true).' = ?', $nodeInfo->getScope());
        }

        $select->where(
            $dbAdapter->quoteIdentifier($options->getLeftColumnName(true)).' <= ?', $nodeInfo->getLeft()
        )->where(
            $dbAdapter->quoteIdentifier($options->getRightColumnName(true)).' >= ?', $nodeInfo->getRight()
        )->order($options->getLeftColumnName(true).' ASC');

        if (0 < $startLevel) {
            $select->where(
                $dbAdapter->quoteIdentifier($options->getLevelColumnName(true)).' >= ?', $startLevel
            );
        }

        if (0 < $excludeLastNLevels) {
            $select->where(
                $dbAdapter->quoteIdentifier($options->getLevelColumnName(true)).' <= ?', $nodeInfo->getLevel() - $excludeLastNLevels
            );
        }

        $result = $dbAdapter->fetchAll($select);

        return $result;
    }

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

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

        $dbAdapter = $this->getDbAdapter();
        $select = $this->getDefaultDbSelect();
        $select->order($options->getLeftColumnName(true).' ASC');

        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
            $select->where($options->getScopeColumnName(true).' = ?', $nodeInfo->getScope());
        }

        if (0 != $startLevel) {
            $level = $nodeInfo->getLevel() + $startLevel;
            $select->where(
                $dbAdapter->quoteIdentifier($options->getLevelColumnName(true)).' >= ?', $level
            );
        }

        if (null != $levels) {

            $endLevel = $nodeInfo->getLevel() + $startLevel + abs($levels);
            $select->where(
                $dbAdapter->quoteIdentifier($options->getLevelColumnName(true)).' < ?', $endLevel
            );
        }

        if (null != $excludeBranch && null != ($excludeNodeInfo = $this->getNodeInfo($excludeBranch))) {
            $where = sprintf(
                '(%s OR %s) AND (%s OR %s)',
                $this->getWhereBetween($options->getLeftColumnName(true), $nodeInfo->getLeft(), $excludeNodeInfo->getLeft() - 1),
                $this->getWhereBetween($options->getLeftColumnName(true),
                    $excludeNodeInfo->getRight() + 1, $nodeInfo->getRight()),
                $this->getWhereBetween($options->getRightColumnName(true),
                    $excludeNodeInfo->getRight() + 1, $nodeInfo->getRight()),
                $this->getWhereBetween($options->getRightColumnName(true),
                    $nodeInfo->getLeft(), $excludeNodeInfo->getLeft() - 1)
            );
            $select->where($where);
        } else {
            $select->where(
                $dbAdapter->quoteIdentifier($options->getLeftColumnName(true)).' >= ?', $nodeInfo->getLeft()
            );
            $select->where(
                $dbAdapter->quoteIdentifier($options->getRightColumnName(true)).' <= ?', $nodeInfo->getRight()
            );
        }

        $resultArray = $dbAdapter->fetchAll($select);

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

    protected function getWhereBetween($column, $first, $second)
    {
        $dbAdapter = $this->getDbAdapter();
        $quotedColumn = $dbAdapter->quoteIdentifier($column);
        $quotedFirst = $dbAdapter->quote($first);
        $quotedSecond = $dbAdapter->quote($second);

        return sprintf('(%s BETWEEN %s AND %s)', $quotedColumn, $quotedFirst, $quotedSecond);
    }
}

1		<?php
2
3		declare(strict_types=1);
4
5		namespace StefanoTree\NestedSet\Adapter;
6
7		use StefanoTree\NestedSet\NodeInfo;
8		use StefanoTree\NestedSet\Options;
9		use Zend_Db_Adapter_Abstract as ZendDbAdapter;
10		use Zend_Db_Select as ZendDbSelect;
11
12		class Zend1 extends AdapterAbstract implements AdapterInterface
13		{
14		protected $dbAdapter;
15
16	56	public function __construct(Options $options, ZendDbAdapter $dbAdapter)
17		{
18	56	$this->setOptions($options);
19	56	$this->setDbAdapter($dbAdapter);
20	56	}
21
22		/**
23		* @param ZendDbAdapter $dbAdapter
24		*/
25	56	protected function setDbAdapter(ZendDbAdapter $dbAdapter): void
26		{
27	56	$this->dbAdapter = $dbAdapter;
28	56	}
29
30		/**
31		* @return ZendDbAdapter
32		*/
33	53	public function getDbAdapter(): ZendDbAdapter
34		{
35	53	return $this->dbAdapter;
36		}
37
38		/**
39		* {@inheritdoc}
40		*
bartko-s / stefano-tree

Push — master ( f2ef3e...a98c98 )

Zend1::getDescendants() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
