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

Complexity

Conditions	9
Paths	9

Size

Total Lines	69
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	27
CRAP Score	9.0036

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 columns is actually a Closure instance, we will assume the developer
        // wants to begin a nested where statement which is wrapped in parenthesis.
        // We'll add that Closure to the query then 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 = $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->where($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';

        // 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;
    }