LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsSelects

Complexity

Total Complexity

35

Size/Duplication

Total Lines	234
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	from()	0	13	3
A	selectSub()	0	9	1
A	fromOptions()	0	11	2
A	addSelect()	0	7	2
A	select()	0	17	5
B	orderByRaw()	0	20	7
A	addColumns()	0	22	6
A	orderBy()	0	23	5
A	union()	0	14	3
A	inRandomOrder()	0	8	1

<?php

declare(strict_types=1);

namespace LaravelFreelancerNL\Aranguent\Query\Concerns;

use Exception;
use Illuminate\Database\Eloquent\Builder as IlluminateEloquentBuilder;
use Illuminate\Database\Query\Builder as IlluminateQueryBuilder;
use Illuminate\Database\Query\Expression;
use InvalidArgumentException;
use LaravelFreelancerNL\Aranguent\Query\Grammar;

trait BuildsSelects
{
    /**
     * Set the table which the query is targeting.
     *
     * @param \Closure|IlluminateQueryBuilder|string $table
     * @param string|null $as
     * @return IlluminateQueryBuilder
     */
    public function from($table, $as = null)
    {
        if ($this->isQueryable($table) && $as !== null) {

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

            return $this->fromSub($table, $as);

The method fromSub() does not exist on LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsSelects. Did you maybe mean from()?

        }

        assert(is_string($table));

        $this->registerTableAlias($table, $as);

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

        $this->from = $table;

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

        return $this;

The expression return $this returns the type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsSelects which is incompatible with the documented return type Illuminate\Database\Query\Builder.

    }

    /**
     * Set the table which the query is targeting.
     *
     * @param array<mixed> $options
     *
     * @return IlluminateQueryBuilder
     */
    public function fromOptions($options)
    {

        $boundOptions = [];
        foreach ($options as $key => $option) {
            $boundOptions[$key]  = $this->bindValue($option, 'fromOptions');

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

        }

        $this->fromOptions = $boundOptions;

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

        return $this;

The expression return $this returns the type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsSelects which is incompatible with the documented return type Illuminate\Database\Query\Builder.

    }

    /**
     * Set the columns to be selected.
     *
     * @param array<mixed>|mixed $columns
     * @return IlluminateQueryBuilder
     * @throws Exception
     */
    public function select($columns = ['*']): IlluminateQueryBuilder
    {
        $this->columns = [];

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

        $this->bindings['select'] = [];

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

        $columns = is_array($columns) ? $columns : func_get_args();

        foreach ($columns as $as => $column) {
            if (is_string($as) && $this->isQueryable($column)) {
                $this->selectSub($column, $as);
                continue;
            }

            $this->addColumns([$as => $column]);
        }

        return $this;

The expression return $this returns the type LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsSelects which is incompatible with the type-hinted return Illuminate\Database\Query\Builder.

    }

    /**
     * Add a subselect expression to the query.
     *
     * @param \Closure|IlluminateQueryBuilder|IlluminateEloquentBuilder|string $query
     * @param string $as
     * @return $this
     *
     * @throws \InvalidArgumentException
     * @throws Exception
     */
    public function selectSub($query, $as)
    {
        [$query] = $this->createSub($query, true);

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

        $this->set($as, new Expression($query), 'postIterationVariables');

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

        $this->addColumns([$as]);

        return $this;
    }

    /**
     * Add a new select column to the query.
     *
     * @param array|mixed $column
     * @return $this
     */
    public function addSelect($column)
    {
        $columns = is_array($column) ? $column : func_get_args();

        $this->addColumns($columns);

        return $this;
    }

    /**
     * @param array<mixed> $columns
     */
    protected function addColumns(array $columns): void
    {
        $table = (string) $this->grammar->getValue($this->from);

        foreach ($columns as $as => $column) {
            if (is_string($as) && $this->isQueryable($column)) {
                if (empty($this->columns)) {
                    $this->select($table . '.*');
                }

                $this->selectSub($column, $as);

                continue;
            }

            if (is_string($as)) {
                $this->columns[$as] = $column;

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

                continue;
            }

            $this->columns[] = $column;
        }
    }

    /**
     * Add an "order by" clause to the query.
     *
     * @param \Closure|IlluminateQueryBuilder|IlluminateEloquentBuilder|Expression|string $column
     * @param string $direction
     * @return $this
     *
     * @throws \InvalidArgumentException
     */
    public function orderBy($column, $direction = 'asc')
    {
        if ($this->isQueryable($column)) {
            assert(!$column instanceof Expression);
            [$query, $bindings] = $this->createSub($column);

            $column = new Expression('(' . $query . ')');

'(' . $query . ')' of type string is incompatible with the type Illuminate\Database\Query\TValue expected by parameter $value of Illuminate\Database\Query\Expression::__construct().

            $this->addBinding($bindings, $this->unions ? 'unionOrder' : 'order');

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

        }

        $direction = strtoupper($direction);

        if (!in_array($direction, ['ASC', 'DESC'], true)) {
            throw new InvalidArgumentException('Order direction must be "asc" or "desc".');
        }

        $this->{$this->unions ? 'unionOrders' : 'orders'}[] = [
            'column' => $column,
            'direction' => $direction,
        ];

        return $this;
    }

    /**
     * @param string $aql
     * @param array<mixed> $bindings
     * @return $this
     */
    public function orderByRaw($aql, $bindings = [])
    {
        $type = 'Raw';

        $sql = new Expression($aql);

$aql of type string is incompatible with the type Illuminate\Database\Query\TValue expected by parameter $value of Illuminate\Database\Query\Expression::__construct().

        $this->{$this->unions ? 'unionOrders' : 'orders'}[] = compact('type', 'sql');

        if (!isset($this->bindings[$this->unions ? 'unionOrders' : 'orders'])) {
            $this->bindings[$this->unions ? 'unionOrders' : 'orders'] = $bindings;

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

            return $this;
        }

        $this->bindings[$this->unions ? 'unionOrders' : 'orders'] = array_merge(
            $this->bindings[$this->unions ? 'unionOrders' : 'orders'],
            $bindings,
        );

        return $this;
    }

    /**
     * Put the query's results in random order.
     *
     * @param string $seed
     * @return $this
     */
    public function inRandomOrder($seed = '')
    {
        assert($this->grammar instanceof Grammar);

        // ArangoDB's random function doesn't accept a seed.
        unset($seed);

        return $this->orderByRaw($this->grammar->compileRandom());
    }

    /**
     * Add a union statement to the query.
     *
     * @param  \Closure|IlluminateQueryBuilder|IlluminateEloquentBuilder $query
     * @param  bool  $all
     * @return $this
     *
     * @SuppressWarnings("PHPMD.BooleanArgumentFlag")
     */
    public function union($query, $all = false)
    {
        if ($query instanceof \Closure) {
            $query($query = $this->newQuery());

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

        }

        if ($query instanceof IlluminateEloquentBuilder) {
            $query = $query->getQuery();
        }

        $this->importBindings($query);

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

        $this->unions[] = compact('query', 'all');

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

        return $this;
    }
}