Staudenmeir\LaravelAdjacencyList\Eloquent\HasRecursiveRelationshipScopes

Complexity

Total Complexity

18

Size/Duplication

Total Lines	241
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getInitialQuery()	0	24	2
A	getRecursiveQuery()	0	48	5
A	scopeDepthFirst()	0	3	1
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	scopeWithRelationshipExpression()	0	16	2
A	scopeHasParent()	0	3	1
A	scopeTreeOf()	0	3	1

<?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 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?

The expression return $query->whereIn($this->getLocalKeyName(), $keys) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * 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());

The expression return $query->whereNotNull($this->getParentKeyName()) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * 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);

The expression return $query->whereNotIn($this->getLocalKeyName(), $keys) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * 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());

The expression return $query->whereNull($this->getParentKeyName()) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * 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());

The expression return $query->orderBy($this->getDepthName()) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * Order the query depth-first.
     *
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function scopeDepthFirst(Builder $query)
    {
        return $query->orderBy($this->getPathName());

The expression return $query->orderBy($this->getPathName()) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

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

    }

    /**
     * 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);

The expression return $query->withRecursiveExpression($name, $expression)->from($name) also could return the type Illuminate\Database\Query\Builder which is incompatible with the documented return type Illuminate\Database\Eloquent\Builder.

    }

    /**
     * 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()
        );

        $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());

        $recursiveDepth = $grammar->wrap($this->getDepthName()).' '.($direction === 'asc' ? '-' : '+').' 1';

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

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

            $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']),

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

                    $path['name']
                ),
                $grammar->getRecursivePathBindings($path['separator'])
            );
        }

        if ($direction === 'asc') {
            $first = $this->getParentKeyName();
            $second = $this->getQualifiedLocalKeyName();
        } else {
            $first = $this->getLocalKeyName();
            $second = $this->qualifyColumn($this->getParentKeyName());
        }

        $query->join($name, $name.'.'.$first, '=', $second);

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

        return $query;
    }
}