LTreeCollection::hasMissingNodes() - Code Metrics - umbrellio/laravel-ltree - Measure and Improve Code Quality continuously with Scrutinizer

LTreeCollection::hasMissingNodes() A
last analyzed 2024-05-16 10:28 UTC

↳ Parent: LTreeCollection

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes

Metric	Value
eloc	7
c	0
b	0
f	0
dl	0
loc	12
ccs	8
cts	8
cp	1
rs	10
cc	2
nc	2
nop	1
crap	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);

    }

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

        return $this;
    }

    public 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() && $item->getLtreeParentId()) {
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
                $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()))
            ->diff($this->pluck($model->/** @scrutinizer ignore-call */ getKeyName()))
            ->isNotEmpty();
    }

    /**
     * @param LTreeInterface|ModelInterface $model
     */
    private function appendAncestors($model): void
    {
        $paths = $this
            ->pluck($model->getLtreePathColumn())
            ->pluck($model->/** @scrutinizer ignore-call */ getLtreePathColumn())
            ->toArray();
        $ids = $this
            ->pluck($model->getKeyName())
            ->toArray();

        /** @var Model $model */
        $parents = $model::parentsOf($paths)
        $parents = $model::/** @scrutinizer ignore-call */ parentsOf($paths)
            ->whereKeyNot($ids)
            ->/** @scrutinizer ignore-call */ whereKeyNot($ids)
            ->get();

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


umbrellio / laravel-ltree

LTreeCollection::hasMissingNodes() A last analyzed 2024-05-16 10:28 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

LTreeCollection::hasMissingNodes() A
last analyzed 2024-05-16 10:28 UTC