Umbrellio\LTree\Relations\AbstractBelongsToTree

Complexity

Total Complexity

19

Size/Duplication

Total Lines	142
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	getParentKey()	0	3	1
A	getEagerModelKeys()	0	13	3
A	getResults()	0	5	2
A	match()	0	17	5
A	addConstraints()	0	10	3
A	initRelation()	0	7	2
A	getLTreeRelated()	0	6	1
A	addEagerConstraints()	0	31	1

<?php

declare(strict_types=1);

namespace Umbrellio\LTree\Relations;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query\JoinClause;
use Umbrellio\LTree\Interfaces\LTreeModelInterface;
use Umbrellio\LTree\Traits\LTreeModelTrait;

abstract class AbstractBelongsToTree extends Relation
{
    protected $throughRelationName;
    private $foreignKey;
    private $ownerKey;

    public function __construct(
        Builder $query,
        Model $child,
        string $throughRelationName,
        string $foreignKey,
        string $ownerKey
    ) {
        $this->throughRelationName = $throughRelationName;
        $this->foreignKey = $foreignKey;
        $this->ownerKey = $ownerKey;

        parent::__construct($query, $child);
    }

    public function addConstraints(): void
    {
        if (static::$constraints) {
            /** @var Model $relation */
            $relation = $this->parent->{$this->throughRelationName};

            if ($relation) {

$relation is of type Illuminate\Database\Eloquent\Model, thus it always evaluated to true.

                $this->query = $this
                    ->modifyQuery($relation->newQuery(), $relation)

The method newQuery() does not exist on Illuminate\Database\Eloquent\Model.

                    ->orderBy($this->getLTreeRelated()->getLtreePathColumn());
            }
        }
    }

    public function addEagerConstraints(array $models): void
    {
        $key = $this->related->getTable() . '.' . $this->ownerKey;

The method getTable() does not exist on Illuminate\Database\Eloquent\Model. It seems like you code against a sub-type of Illuminate\Database\Eloquent\Model such as Illuminate\Database\Eloquent\Relations\Pivot.

        $whereIn = $this->whereInMethod($this->related, $this->ownerKey);

        $this->query->{$whereIn}($key, $this->getEagerModelKeys($models));

        $table = $this
            ->getModel()

The method getModel() does not exist on Umbrellio\LTree\Relations\AbstractBelongsToTree. Since you implemented __call, consider adding a @method annotation.

            ->getTable();
        $alias = sprintf('%s_depends', $table);

        $related = $this->getLTreeRelated();

        $this->query->join(

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

            sprintf('%s as %s', $table, $alias),
            function (JoinClause $query) use ($alias, $table, $related) {
                $query->whereRaw(sprintf(
                    '%1$s.%2$s %4$s %3$s.%2$s',
                    $alias,
                    $related->getLtreePathColumn(),
                    $table,
                    $this->getOperator()
                ));
            }
        );

        $this->query->orderBy($related->getLtreePathColumn());

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

        $this->query->selectRaw(sprintf('%s.*, %s.%s as relation_id', $alias, $table, $this->ownerKey));

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

    }

    public function match(array $models, Collection $results, $relation)
    {
        $dictionary = [];

        foreach ($results as $result) {
            $dictionary[$result->relation_id][] = $result;
        }

        foreach ($models as $model) {
            foreach ($dictionary as $related => $value) {
                if ($model->getAttribute($this->foreignKey) === $related) {
                    $model->setRelation($relation, $this->related->newCollection($value));

The method newCollection() does not exist on Illuminate\Database\Eloquent\Model. It seems like you code against a sub-type of Illuminate\Database\Eloquent\Model such as Umbrellio\LTree\tests\_data\Models\CategoryStub or Umbrellio\LTree\tests\_data\Models\ProductStub or Illuminate\Notifications\DatabaseNotification.

                }
            }
        }

        return $models;
    }

    public function getResults()
    {
        return $this->getParentKey() !== null
            ? $this->query->get()
            : $this->related->newCollection();
    }


    /**
     * Initialize the relation on a set of models.
     *
     * @param string $relation
     * @return array
     */
    public function initRelation(array $models, $relation)
    {
        foreach ($models as $model) {
            $model->setRelation($relation, $this->related->newCollection());
        }

        return $models;
    }

    /**
     * @param Builder|LTreeModelTrait $query
     */
    abstract protected function modifyQuery($query, Model $model): Builder;

    abstract protected function getOperator(): string;

    protected function getEagerModelKeys(array $models)
    {
        $keys = [];

        foreach ($models as $model) {
            if (($value = $model->{$this->foreignKey}) !== null) {
                $keys[] = $value;
            }
        }

        sort($keys);

        return array_values(array_unique($keys));
    }

    private function getLTreeRelated(): LTreeModelInterface
    {
        return $this
            ->parent
            ->{$this->throughRelationName}()
            ->related;
    }

    private function getParentKey()
    {
        return $this->parent->{$this->foreignKey};
    }
}