LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsWhereClauses::where()

Complexity

Conditions	14
Paths	19

Size

Total Lines	81
Code Lines	27

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	26
CRAP Score	14

Importance

Changes	2
Bugs	0	Features	0

<?php
    public function where($column, $operator = null, $value = null, $boolean = 'and')
    {
        // If the column is an array, we will assume it is an array of key-value pairs
        // and can add them each as a where clause. We will maintain the boolean we
        // received when the method was called and pass it into the nested where.
        if (is_array($column)) {
            return $this->addArrayOfWheres($column, $boolean);

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

        }

        // Here we will make some assumptions about the operator. If only 2 values are
        // passed to the method, we will assume that the operator is an equals sign
        // and keep going. Otherwise, we'll require the operator to be passed in.
        [$value, $operator] = $this->prepareValueAndOperator(

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

            $value, $operator, func_num_args() === 2
        );

        // If the column is actually a Closure instance, we will assume the developer
        // wants to begin a nested where statement which is wrapped in parentheses.
        // We will add that Closure to the query and return back out immediately.
        if ($column instanceof Closure && is_null($operator)) {
            return $this->whereNested($column, $boolean);

The method whereNested() does not exist on LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsWhereClauses. Did you maybe mean where()?

        }

        // If the column is a Closure instance and there is an operator value, we will
        // assume the developer wants to run a subquery and then compare the result
        // of that subquery with the given value that was provided to the method.
        if ($this->isQueryable($column) && ! is_null($operator)) {

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

            [$sub, $bindings] = $this->createSub($column);

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

            return $this->addBinding($bindings, 'where')

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

                ->where(new Expression('('.$sub.')'), $operator, $value, $boolean);
        }

        // If the given operator is not found in the list of valid operators we will
        // assume that the developer is just short-cutting the '=' operators and
        // we will set the operators to '=' and set the values appropriately.
        if ($this->invalidOperator($operator)) {

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

            [$value, $operator] = [$operator, '=='];
        }

        // If the value is a Closure, it means the developer is performing an entire
        // sub-select within the query and we will need to compile the sub-select
        // within the where clause to get the appropriate query record results.
        if ($value instanceof Closure) {
            return $this->whereSub($column, $operator, $value, $boolean);

It seems like $column can also be of type Closure; however, parameter $column of LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsWhereClauses::whereSub() does only seem to accept string, maybe add an additional type check?

        }

        // If the value is "null", we will just assume the developer wants to add a
        // where null clause to the query. So, we will allow a short-cut here to
        // that method for convenience so the developer doesn't have to check.
        if (is_null($value)) {
            return $this->whereNull($column, $boolean, $operator !== '==');

The method whereNull() does not exist on LaravelFreelancerNL\Aranguent\Query\Concerns\BuildsWhereClauses. Did you maybe mean where()?

        }

        $type = 'Basic';

        // If the column is making a JSON reference we'll check to see if the value
        // is a boolean. If it is, we'll add the raw boolean string as an actual
        // value to the query to ensure this is properly handled by the query.
        if (str_contains($column, '->') && is_bool($value)) {

It seems like $column can also be of type Closure; however, parameter $haystack of str_contains() does only seem to accept string, maybe add an additional type check?

            $value = new Expression($value ? 'true' : 'false');

            if (is_string($column)) {
                $type = 'JsonBoolean';
            }
        }

        if ($this->isBitwiseOperator($operator)) {

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

            $type = 'Bitwise';
        }

        $value = $this->bindValue($value);

        // Now that we are working with just a simple query we can put the elements
        // in our array and add the query binding to our array of bindings that
        // will be bound to each SQL statements when it is finally executed.
        $this->wheres[] = compact(

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

            'type', 'column', 'operator', 'value', 'boolean'
        );

        return $this;

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

    }