Encima\Albero\SetBuilder

Complexity

Total Complexity

18

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	rebuild()	0	19	4
A	__construct()	0	3	1
A	getNextBound()	0	9	2
A	qualify()	0	3	1
A	children()	0	17	2
A	scopedKey()	0	12	3
A	roots()	0	8	1
A	scopedAttributes()	0	13	2
A	rebuildBounds()	0	14	2

<?php

namespace Encima\Albero;

use Illuminate\Database\Eloquent\Model;
use Encima\Albero\Extensions\Eloquent\Collection;

class SetBuilder
{
    /** @var \Illuminate\Database\Eloquent\Model */
    protected $node = null;

    protected array $bounds = [];

    public function __construct(Model $node)
    {
        $this->node = $node;
    }

    /**
     * Perform the re-calculation of the left and right indexes of the whole
     * nested set tree structure.
     *
     * @param  bool $force
     * @return void
     */
    public function rebuild(bool $force = false): void
    {
        $alreadyValid = forward_static_call([get_class($this->node), 'isValidNestedSet']);

        // Do not rebuild a valid Nested Set tree structure
        if (!$force && $alreadyValid) {
            return;
        }

        // Rebuild lefts and rights for each root node and its children (recursively).
        // We go by setting left (and keep track of the current left bound), then
        // search for each children and recursively set the left index (while
        // incrementing that index). When going back up the recursive chain we start
        // setting the right indexes and saving the nodes...
        $self = $this;

        $this->node->getConnection()->transaction(function () use ($self) {
            foreach ($self->roots() as $root) {
                $self->rebuildBounds($root, 0);
            }
        });
    }

    /**
     * Return all root nodes for the current database table appropiately sorted.
     *
     * @return Illuminate\Database\Eloquent\Collection

The type Encima\Albero\Illuminate\Database\Eloquent\Collection was not found. Did you mean Illuminate\Database\Eloquent\Collection? If so, make sure to prefix the type with \.

     */
    public function roots(): Collection
    {
        return $this->node->newQuery()
            ->whereNull($this->node->getQualifiedParentColumnName())
            ->orderBy($this->node->getQualifiedLeftColumnName())
            ->orderBy($this->node->getQualifiedRightColumnName())
            ->orderBy($this->node->getQualifiedKeyName())
            ->get();
    }

    /**
     * Recompute left and right index bounds for the specified node and its
     * children (recursive call). Fill the depth column too.
     */
    public function rebuildBounds(Model $node, int $depth = 0)
    {
        $k = $this->scopedKey($node);

        $node->setAttribute($node->getLeftColumnName(), $this->getNextBound($k));

It seems like $node->getLeftColumnName() can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $key of Illuminate\Database\Eloquent\Model::setAttribute() does only seem to accept string, maybe add an additional type check?

        $node->setAttribute($node->getDepthColumnName(), $depth);

        foreach ($this->children($node) as $child) {
            $this->rebuildBounds($child, $depth + 1);
        }

        $node->setAttribute($node->getRightColumnName(), $this->getNextBound($k));

        $node->save();
    }

    /**
     * Return all children for the specified node.
     *
     * @param   Baum\Node $node

The type Encima\Albero\Baum\Node was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return  Illuminate\Database\Eloquent\Collection
     */
    public function children(Model $node): Collection
    {
        $query = $this->node->newQuery();

        $query->where($this->node->getQualifiedParentColumnName(), '=', $node->getKey());

        // We must also add the scoped column values to the query to compute valid
        // left and right indexes.
        foreach ($this->scopedAttributes($node) as $fld => $value) {
            $query->where($this->qualify($fld), '=', $value);
        }

        $query->orderBy($this->node->getQualifiedLeftColumnName());
        $query->orderBy($this->node->getQualifiedRightColumnName());
        $query->orderBy($this->node->getQualifiedKeyName());

        return $query->get();
    }

    /**
     * Return an array of the scoped attributes of the supplied node.
     *
     * @param   Baum\Node $node
     * @return  array
     */
    protected function scopedAttributes(Model $node): array
    {
        $keys = $this->node->getScopedColumns();

        if (count($keys) == 0) {

It seems like $keys can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $var of count() does only seem to accept Countable|array, maybe add an additional type check?

            return [];
        }

        $values = array_map(function ($column) use ($node) {
            return $node->getAttribute($column);
        }, $keys);

It seems like $keys can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $arr1 of array_map() does only seem to accept array, maybe add an additional type check?

        return array_combine($keys, $values);

It seems like $keys can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $keys of array_combine() does only seem to accept array, maybe add an additional type check?

    }

    /**
     * Return a string-key for the current scoped attributes. Used for index
     * computing when a scope is defined (acsts as an scope identifier).
     *
     * @param   Baum\Node $node
     * @return  string
     */
    protected function scopedKey(Model $node): string
    {
        $attributes = $this->scopedAttributes($node);

        $output = [];

        foreach ($attributes as $fld => $value) {
            $output[] = $this->qualify($fld).'='.(is_null($value) ? 'NULL' : $value);
        }

        // NOTE: Maybe an md5 or something would be better. Should be unique though.
        return implode(',', $output);
    }

    /**
     * Return next index bound value for the given key (current scope identifier)
     *
     * @param   string  $key
     * @return  integer
     */
    protected function getNextBound(string $key): int
    {
        if (false === array_key_exists($key, $this->bounds)) {
            $this->bounds[$key] = 0;
        }

        $this->bounds[$key] = $this->bounds[$key] + 1;

        return $this->bounds[$key];
    }

    /**
     * Get the fully qualified value for the specified column.
     *
     * @return string
     */
    protected function qualify(string $column): string
    {
        return $this->node->getTable().'.'.$column;
    }
}