TreeRepository::getRightColumn() - Code Metrics - Inspection of "Merge pull request #443 from LaravelRUS/analysis-z..." - LaravelRUS/SleepingOwlAdmin - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Branch — development (184ec4)

by butschster

created 2017-02-11 08:52 UTC

TreeRepository::getRightColumn() A

↳ Parent: TreeRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	5
nc	1
nop	1
dl	0
loc	9
ccs	0
cts	8
cp	0
crap	2
rs	9.6666
c	0
b	0
f	0

<?php

namespace SleepingOwl\Admin\Repository;

use Exception;
use Illuminate\Support\Collection;
use SleepingOwl\Admin\Contracts\TreeRepositoryInterface;

class TreeRepository extends BaseRepository implements TreeRepositoryInterface
{
    /**
     * Extrepat/Baum tree type
     * https://github.com/etrepat/baum.
     */
    const TreeTypeBaum = 0;

    /**
     * Lasychaser/Laravel-nestedset tree type
     * https://github.com/lazychaser/laravel-nestedset.
     */
    const TreeTypeKalnoy = 1;

    /**
     * Simple tree type (with `parent_id` and `order` fields).
     */
    const TreeTypeSimple = 2;

    /**
     * Tree type.
     * @var int
     */
    protected $type;

    /**
     * Parent field name.
     * @var string
     */
    protected $parentField = 'parent_id';

    /**
     * Order field name.
     * @var string
     */
    protected $orderField = 'order';

    /**
     * Root parent id value.
     * @var null
     */
    protected $rootParentId = null;

    /**
     * @param string $class
     *
     * @return $this
     */
    public function setClass($class)
    {
        parent::setClass($class);

        $this->detectType();

        return $this;
    }

    /**
     * Get tree structure.
     *
     * @param \Illuminate\Database\Eloquent\Collection $collection
     *
     * @return mixed
     */
    public function getTree(\Illuminate\Database\Eloquent\Collection $collection)
    {
        switch ($this->getType()) {
            case static::TreeTypeBaum:
                return $collection->toHierarchy();
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case static::TreeTypeKalnoy:
                return $collection->toTree();
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}

            case static::TreeTypeSimple:
                return $this->createSimpleTree();
                break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
        }
    }

    /**
     * Get or set tree type.
     *
     * @return int
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * @param int $type
     *
     * @return $this
     */
    public function setType($type)
    {
        $this->type = $type;

        return $this;
    }

    /**
     * @param int $type
     *
     * @return bool
     */
    public function isType($type)
    {
        return $this->type == $type;
    }

    /**
     * Get parent field name.
     *
     * @return string
     */
    public function getParentField()
    {
        return $this->parentField;
    }

    /**
     * @param string $parentField
     *
     * @return $this
     */
    public function setParentField($parentField)
    {
        $this->parentField = $parentField;

        return $this;
    }

    /**
     * Get order field name.
     *
     * @return string
     */
    public function getOrderField()
    {
        return $this->orderField;
    }

    /**
     * @param string $orderField
     *
     * @return $this
     */
    public function setOrderField($orderField)
    {
        $this->orderField = $orderField;

        return $this;
    }

    /**
     * Get or set parent field name.
     *
     * @return string
     */
    public function getRootParentId()
    {
        return $this->rootParentId;
    }

    /**
     * @param string $rootParentId
     *
     * @return $this
     */
    public function setRootParentId($rootParentId)
    {
        $this->rootParentId = $rootParentId;


        return $this;
    }

    /**
     * Reorder tree by $data value.
     *
     * @param $data
     */
    public function reorder(array $data)
    {
        if ($this->isType(static::TreeTypeSimple)) {
            $this->recursiveReorderSimple($data, $this->getRootParentId());
        } else {
            $left = 1;
            foreach ($data as $root) {
                $left = $this->recursiveReorder($root, null, $left);
            }
        }
    }

    /**
     * Move tree node in nested-set tree type.
     *
     * @param $id
     * @param $parentId
     * @param $left
     * @param $right
     */
    protected function move($id, $parentId, $left, $right)
    {
        $instance = $this->find($id);
        $attributes = $instance->getAttributes();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $attributes[$this->getLeftColumn($instance)] = $left;
        $attributes[$this->getRightColumn($instance)] = $right;
        $attributes[$this->getParentColumn($instance)] = $parentId;
        $instance->setRawAttributes($attributes);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $instance->save();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
    }

    /**
     * Get left column name.
     *
     * @param $instance
     *
     * @return mixed
     * @throws Exception
     */
    protected function getLeftColumn($instance)
    {
        $methods = [
            'getLeftColumnName',
            'getLftName',
        ];

        return $this->callMethods($instance, $methods);
    }

    /**
     * Get right column name.
     *
     * @param $instance
     *
     * @return mixed
     * @throws Exception
     */
    protected function getRightColumn($instance)
    {
        $methods = [
            'getRightColumnName',
            'getRgtName',
        ];

        return $this->callMethods($instance, $methods);
    }

    /**
     * Get parent column name.
     *
     * @param $instance
     *
     * @return mixed
     * @throws Exception
     */
    protected function getParentColumn($instance)
    {
        $methods = [
            'getParentColumnName',
            'getParentIdName',
        ];

        return $this->callMethods($instance, $methods);
    }

    /**
     * Detect tree type.
     * @return $this
     */
    protected function detectType()
    {
        $model = $this->getModel();

        // Check for package baum/baum
        if ($model instanceof \Baum\Node) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            return $this->setType(static::TreeTypeBaum);
        }

        // Check for package kalnoy/nestedset
        if (class_exists('Kalnoy\Nestedset\Node') and $model instanceof \Kalnoy\Nestedset\Node) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            return $this->setType(static::TreeTypeKalnoy);
        } elseif (function_exists('trait_uses_recursive') and $traits = trait_uses_recursive($model) and in_array('Kalnoy\Nestedset\NodeTrait', $traits)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
            return $this->setType(static::TreeTypeKalnoy);
        } elseif ($traits = class_uses($model) and in_array('Kalnoy\Nestedset\NodeTrait', $traits)) {
// Logical operators have lower precedence:
$f = false or true;

// is executed like this:
($f = false) or true;


// Boolean operators have higher precedence:
$f = false || true;

// is executed like this:
$f = (false || true);
            return $this->setType(static::TreeTypeKalnoy);
        }

        return $this->setType(static::TreeTypeSimple);
    }

    /**
     * Call several methods and get first result.
     *
     * @param $instance
     * @param $methods
     *
     * @return mixed
     * @throws Exception
     */
    protected function callMethods($instance, $methods)
    {
        foreach ($methods as $method) {
            if (method_exists($instance, $method)) {
                return $instance->$method();
            }
        }

        throw new Exception('Tree type not supported');
    }

    /**
     * Recursive reorder nested-set tree type.
     *
     * @param $root
     * @param $parentId
     * @param $left
     *
     * @return mixed
     */
    protected function recursiveReorder($root, $parentId, $left)
    {
        $right = $left + 1;
        $children = array_get($root, 'children', []);
        foreach ($children as $child) {
            $right = $this->recursiveReorder($child, $root['id'], $right);
        }
        $this->move($root['id'], $parentId, $left, $right);
        $left = $right + 1;

        return $left;
    }

    /**
     * Recursive reoder simple tree type.
     *
     * @param $data
     * @param $parentId
     */
    protected function recursiveReorderSimple(array $data, $parentId)
    {
        foreach ($data as $order => $item) {
            $id = $item['id'];

            $instance = $this->find($id);
            $instance->{$this->getParentField()} = $parentId;
            $instance->{$this->getOrderField()} = $order;
            $instance->save();
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

            if (isset($item['children'])) {
                $this->recursiveReorderSimple($item['children'], $id);
            }
        }
    }

    /**
     * Get children for simple tree type structure.
     *
     * @param $collection
     * @param $id
     *
     * @return Collection
     */
    protected function getChildren($collection, $id)
    {
        $parentField = $this->getParentField();
        $result = [];
        foreach ($collection as $instance) {
            if ((int) $instance->$parentField != $id) {
                continue;
            }

            $instance->setRelation('children', $this->getChildren($collection, $instance->getKey()));
            $result[] = $instance;
        }

        return new Collection($result);
    }

    /**
     * Create simple tree type structure.
     * @return static
     */
    protected function createSimpleTree()
    {
        $collection = $this

            ->getQuery()
            ->orderBy($this->getParentField(), 'asc')
            ->orderBy($this->getOrderField(), 'asc')
            ->get();

        return $this->getChildren(
            $collection,
            $this->getRootParentId()
        );
    }
}


GitHub Access Token became invalid

Branch — development (184ec4)

TreeRepository::getRightColumn() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Available Fixes

LaravelRUS / SleepingOwlAdmin

GitHub Access Token became invalid

Branch — development (184ec4)

TreeRepository::getRightColumn() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Available Fixes

1. Missing dependencies

2. Missing use statement

1. Missing dependencies

2. Missing use statement

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Logical Operators are used for Control-Flow

Available Fixes

Duplication Side-by-Side

Filter issues like