Umbrellio\LTree\Collections\LTreeCollection

Complexity

Total Complexity

14

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	withLeaves()	0	5	1
A	toTree()	0	21	4
A	excludeLeaves()	0	6	3
A	loadMissingNodes()	0	7	2
A	appendAncestors()	0	16	2
A	hasMissingNodes()	0	12	2

<?php

declare(strict_types=1);

namespace Umbrellio\LTree\Collections;

use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Umbrellio\LTree\Helpers\LTreeBuilder;
use Umbrellio\LTree\Helpers\LTreeNode;
use Umbrellio\LTree\Interfaces\HasLTreeRelations;
use Umbrellio\LTree\Interfaces\LTreeInterface;
use Umbrellio\LTree\Interfaces\ModelInterface;
use Umbrellio\LTree\Traits\LTreeModelTrait;

/**
 * @method LTreeInterface|ModelInterface first()
 * @property LTreeInterface[]|ModelInterface[]|HasLTreeRelations[] $items
 */
class LTreeCollection extends Collection
{
    private $withLeaves = true;

    public function toTree(bool $usingSort = true, bool $loadMissing = true): LTreeNode
    {
        if (!$model = $this->first()) {
            return new LTreeNode();
        }

        if ($loadMissing) {
            $this->loadMissingNodes($model);
        }

        if (!$this->withLeaves) {
            $this->excludeLeaves();
        }

        $builder = new LTreeBuilder(
            $model->getLtreePathColumn(),
            $model->getKeyName(),
            $model->getLtreeParentColumn()
        );

        return $builder->build($collection ?? $this, $usingSort);

The variable $collection seems to never exist and therefore isset should always be false.

    }

    public function withLeaves(bool $state = true): self
    {
        $this->withLeaves = $state;

        return $this;
    }

    private function loadMissingNodes($model): self
    {
        if ($this->hasMissingNodes($model)) {
            $this->appendAncestors($model);
        }

        return $this;
    }

    private function excludeLeaves(): void
    {
        foreach ($this->items as $key => $item) {
            /** @var LTreeModelTrait $item */
            if ($item->ltreeChildren->isEmpty()) {
                $this->forget($key);
            }
        }
    }

    /**
     * @param LTreeInterface|ModelInterface $model
     */
    private function hasMissingNodes($model): bool
    {
        $paths = collect();

        foreach ($this->items as $item) {
            $paths = $paths->merge($item->getLtreePath());
        }

        return $paths
            ->unique()
            ->diff($this->pluck($model->getKeyName()))

The method getKeyName() does not exist on Umbrellio\LTree\Interfaces\LTreeInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Umbrellio\LTree\Interfaces\LTreeInterface.

            ->isNotEmpty();
    }

    /**
     * @param LTreeInterface|ModelInterface $model
     */
    private function appendAncestors($model): void
    {
        $paths = $this
            ->pluck($model->getLtreePathColumn())

The method getLtreePathColumn() does not exist on Umbrellio\LTree\Interfaces\ModelInterface. Since it exists in all sub-types, consider adding an abstract or default implementation to Umbrellio\LTree\Interfaces\ModelInterface.

            ->toArray();
        $ids = $this
            ->pluck($model->getKeyName())
            ->toArray();

        /** @var Model $model */
        $parents = $model::parentsOf($paths)

The method Illuminate\Database\Eloquent\Model::parentsOf() is not static, but was called statically.

            ->whereKeyNot($ids)

The method whereKeyNot() does not exist on Illuminate\Database\Eloquent\Builder.

            ->get();

        foreach ($parents as $item) {
            $this->add($item);
        }
    }
}