Staudenmeir\LaravelAdjacencyList\Eloquent\HasRecursiveRelationshipScopes

Complexity

Total Complexity

22

Size/Duplication

Total Lines	302
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	scopeBreadthFirst()	0	3	1
A	scopeHasChildren()	0	7	1
A	scopeWhereDepth()	0	5	1
A	scopeTree()	0	7	1
A	scopeIsLeaf()	0	7	1
A	scopeIsRoot()	0	3	1
A	scopeHasParent()	0	3	1
A	scopeTreeOf()	0	3	1
A	getInitialQuery()	0	24	2
A	scopeDepthFirst()	0	5	1
A	scopeWithRelationshipExpression()	0	16	2
A	addRecursiveQueryJoinsAndConstraints()	0	23	2
A	getRecursiveQuery()	0	57	5
A	callRecursiveQueryDecoratingFunction()	0	7	2

<?php

namespace Staudenmeir\LaravelAdjacencyList\Eloquent;

use Illuminate\Database\Eloquent\Builder;

This use statement conflicts with another class in this namespace, Staudenmeir\LaravelAdjacencyList\Eloquent\Builder. Consider defining an alias.

use Illuminate\Database\Query\JoinClause;
use Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar;

trait HasRecursiveRelationshipScopes
{
    /**
     * Add a recursive expression for the whole tree to the query.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param int|null $maxDepth
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeTree(Builder $query, $maxDepth = null)
    {
        $constraint = function (Builder $query) {
            $query->isRoot();
        };

        return $query->treeOf($constraint, $maxDepth);
    }

    /**
     * Add a recursive expression for a custom tree to the query.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param callable $constraint
     * @param int|null $maxDepth
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeTreeOf(Builder $query, callable $constraint, $maxDepth = null)
    {
        return $query->withRelationshipExpression('desc', $constraint, 0, null, $maxDepth);
    }

    /**
     * Limit the query to models with children.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeHasChildren(Builder $query)
    {
        $keys = (new static())->newQuery()

It seems like newQuery() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->select($this->getParentKeyName())

It seems like getParentKeyName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->hasParent();

        return $query->whereIn($this->getLocalKeyName(), $keys);

It seems like getLocalKeyName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Limit the query to models with a parent.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeHasParent(Builder $query)
    {
        return $query->whereNotNull($this->getParentKeyName());
    }

    /**
     * Limit the query to leaf models.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeIsLeaf(Builder $query)
    {
        $keys = (new static())->newQuery()
            ->select($this->getParentKeyName())
            ->hasParent();

        return $query->whereNotIn($this->getLocalKeyName(), $keys);
    }

    /**
     * Limit the query to root models.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeIsRoot(Builder $query)
    {
        return $query->whereNull($this->getParentKeyName());
    }

    /**
     * Limit the query by depth.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param mixed $operator
     * @param mixed $value
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWhereDepth(Builder $query, $operator, $value = null)
    {
        $arguments = array_slice(func_get_args(), 1);

        return $query->where($this->getDepthName(), ...$arguments);

It seems like getDepthName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Order the query breadth-first.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeBreadthFirst(Builder $query)
    {
        return $query->orderBy($this->getDepthName());
    }

    /**
     * Order the query depth-first.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeDepthFirst(Builder $query)
    {
        $sql = $query->getExpressionGrammar()->compileOrderByPath();

        return $query->orderByRaw($sql);
    }

    /**
     * Add a recursive expression for the relationship to the query.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $direction
     * @param callable $constraint
     * @param int $initialDepth
     * @param string|null $from
     * @param int|null $maxDepth
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeWithRelationshipExpression(Builder $query, $direction, callable $constraint, $initialDepth, $from = null, $maxDepth = null)
    {
        $from = $from ?: $this->getTable();

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $grammar = $query->getExpressionGrammar();

        $expression = $this->getInitialQuery($grammar, $constraint, $initialDepth, $from)

It seems like $grammar can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $grammar of Staudenmeir\LaravelAdjacencyList\Eloquent\HasRecursiveRelationshipScopes::getInitialQuery() does only seem to accept Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar, maybe add an additional type check?

            ->unionAll(
                $this->getRecursiveQuery($grammar, $direction, $from, $maxDepth)

It seems like $grammar can also be of type Illuminate\Database\Eloquent\Builder; however, parameter $grammar of Staudenmeir\LaravelAdjacencyList\Eloquent\HasRecursiveRelationshipScopes::getRecursiveQuery() does only seem to accept Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar, maybe add an additional type check?

            );

        $name = $this->getExpressionName();

It seems like getExpressionName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $query->getModel()->setTable($name);

        return $query->withRecursiveExpression($name, $expression)->from($name);
    }

    /**
     * Get the initial query for a relationship expression.
     *
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar|\Illuminate\Database\Grammar $grammar
     * @param callable $constraint
     * @param int $initialDepth
     * @param string $from
     * @return \Illuminate\Database\Eloquent\Builder $query
     */
    protected function getInitialQuery(ExpressionGrammar $grammar, callable $constraint, $initialDepth, $from)
    {
        $depth = $grammar->wrap($this->getDepthName());

The method wrap() does not exist on Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar. Since it exists in all sub-types, consider adding an abstract or default implementation to Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar.

        $initialPath = $grammar->compileInitialPath(
            $this->getLocalKeyName(),
            $this->getPathName()

It seems like getPathName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        );

        $query = $this->newModelQuery()

It seems like newModelQuery() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ->select('*')
            ->selectRaw($initialDepth.' as '.$depth)
            ->selectRaw($initialPath)
            ->from($from);

        foreach ($this->getCustomPaths() as $path) {

It seems like getCustomPaths() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $query->selectRaw(
                $grammar->compileInitialPath($path['column'], $path['name'])
            );
        }

        $constraint($query);

        return $query;
    }

    /**
     * Get the recursive query for a relationship expression.
     *
     * @param \Staudenmeir\LaravelAdjacencyList\Query\Grammars\ExpressionGrammar|\Illuminate\Database\Grammar $grammar
     * @param string $direction
     * @param string $from
     * @param int|null $maxDepth
     * @return \Illuminate\Database\Eloquent\Builder $query
     */
    protected function getRecursiveQuery(ExpressionGrammar $grammar, $direction, $from, $maxDepth = null)
    {
        $name = $this->getExpressionName();

        $table = explode(' as ', $from)[1] ?? $from;

        $depth = $grammar->wrap($this->getDepthName());

        $joinColumns = [
            'asc' => [
                $name.'.'.$this->getParentKeyName(),
                $this->getQualifiedLocalKeyName(),

It seems like getQualifiedLocalKeyName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ],
            'desc' => [
                $name.'.'.$this->getLocalKeyName(),
                $this->qualifyColumn($this->getParentKeyName()),

It seems like qualifyColumn() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            ],
        ];

        if ($direction === 'both') {
            $recursiveDepth = "$depth + (case when {$joinColumns['desc'][1]}={$joinColumns['desc'][0]} then 1 else -1 end)";
        } else {
            $recursiveDepth = $depth.' '.($direction === 'asc' ? '-' : '+').' 1';
        }

        $recursivePath = $grammar->compileRecursivePath(
            $this->getQualifiedLocalKeyName(),
            $this->getPathName()
        );

        $recursivePathBindings = $grammar->getRecursivePathBindings($this->getPathSeparator());

It seems like getPathSeparator() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        $query = $this->newModelQuery()
            ->select($table.'.*')
            ->selectRaw($recursiveDepth.' as '.$depth)
            ->selectRaw($recursivePath, $recursivePathBindings)
            ->from($from);

        foreach ($this->getCustomPaths() as $path) {
            $query->selectRaw(
                $grammar->compileRecursivePath(
                    $this->qualifyColumn($path['column']),
                    $path['name']
                ),
                $grammar->getRecursivePathBindings($path['separator'])
            );
        }

        $this->addRecursiveQueryJoinsAndConstraints($query, $direction, $name, $joinColumns);

        if (!is_null($maxDepth)) {
            $query->where($this->getDepthName(), '<', $maxDepth);
        }

        $this->callRecursiveQueryDecoratingFunction($query);

        return $query;
    }

    /**
     * Add join and where clauses to the recursive query for a relationship expression.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string $direction
     * @param string $name
     * @param array $joinColumns
     * @return void
     */
    protected function addRecursiveQueryJoinsAndConstraints(Builder $query, $direction, $name, array $joinColumns)
    {
        if ($direction === 'both') {
            $query->join($name, function (JoinClause $join) use ($joinColumns) {
                $join->on($joinColumns['asc'][0], '=', $joinColumns['asc'][1])
                    ->orOn($joinColumns['desc'][0], '=', $joinColumns['desc'][1]);
            });

            $depth = $this->getDepthName();

            $query->where(function (Builder  $query) use ($depth, $joinColumns) {
                $query->where($depth, '=', 0)
                    ->orWhere(function (Builder $query) use ($depth, $joinColumns) {
                        $query->whereColumn($joinColumns['asc'][0], '=', $joinColumns['asc'][1])
                            ->where($depth, '<', 0);
                    })
                    ->orWhere(function (Builder $query) use ($depth, $joinColumns) {
                        $query->whereColumn($joinColumns['desc'][0], '=', $joinColumns['desc'][1])
                            ->where($depth, '>', 0);
                    });
            });
        } else {
            $query->join($name, $joinColumns[$direction][0], '=', $joinColumns[$direction][1]);
        }
    }

    /**
     * Call decorating function for recursive builder if set
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    protected function callRecursiveQueryDecoratingFunction(Builder $query) {
        if (is_callable(static::$recursiveQueryDecoratingFunction)) {
            (static::$recursiveQueryDecoratingFunction)($query);
            static::$recursiveQueryDecoratingFunction = null;

The property recursiveQueryDecoratingFunction does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $query;
    }
}