RDS\Hydrogen\Query\WhereProvider

Complexity

Total Complexity

9

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	6

Test Coverage

Coverage

87.5%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	or()	0	10	2
A	and()	0	10	2
A	orWhere()	0	4	1
A	where()	0	18	3
A	mode()	0	6	1

<?php
/**
 * This file is part of Hydrogen package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
declare(strict_types=1);

namespace RDS\Hydrogen\Query;

use RDS\Hydrogen\Criteria\Group;
use RDS\Hydrogen\Criteria\Where;
use RDS\Hydrogen\Query;
use RDS\Hydrogen\Query\WhereProvider\WhereBetweenProvider;
use RDS\Hydrogen\Query\WhereProvider\WhereInProvider;
use RDS\Hydrogen\Query\WhereProvider\WhereLikeProvider;
use RDS\Hydrogen\Query\WhereProvider\WhereNullProvider;

/**
 * Trait WhereProvider
 * @property-read Query|$this $or
 * @property-read Query|$this $and
 * @mixin Query
 */
trait WhereProvider
{
    use WhereInProvider;
    use WhereLikeProvider;
    use WhereNullProvider;
    use WhereBetweenProvider;

    /**
     * - AND if true
     * - OR if false
     *
     * @var bool
     */
    protected $conjunction = true;

    /**
     * @param \Closure|null $group
     * @return Query|$this|self
     */
    public function or(\Closure $group = null): self
    {
        $this->conjunction = false;

        if ($group !== null) {
            $this->add(new Group($this, $group, $this->mode()));

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

        }

        return $this;
    }

    /**
     * @param \Closure|null $group
     * @return Query|$this|self
     */
    public function and(\Closure $group = null): self
    {
        $this->conjunction = true;

        if ($group !== null) {
            $this->add(new Group($this, $group, $this->mode()));

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

        }

        return $this;
    }

    /**
     * @param string|\Closure $field
     * @param $valueOrOperator
     * @param null $value
     * @return Query|$this|self
     */
    public function orWhere($field, $valueOrOperator = null, $value = null): self
    {
        return $this->or->where($field, $valueOrOperator, $value);
    }

    /**
     * @param string|\Closure $field
     * @param $valueOrOperator
     * @param null $value
     * @return Query|$this|self
     */
    public function where($field, $valueOrOperator = null, $value = null): self
    {
        if (\is_string($field)) {
            [$operator, $value] = Where::completeMissingParameters($valueOrOperator, $value);

The variable $operator does not exist. Did you mean $valueOrOperator?

            return $this->add(new Where($field, $operator, $value, $this->mode()));

The variable $operator does not exist. Did you mean $valueOrOperator?

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

        }

        if ($field instanceof \Closure) {
            return $this->add(new Group($this, $field, $this->mode()));

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

        }

        $error = \vsprintf('Selection set should be a type of string or Closure, but %s given', [
            \studly_case(\gettype($field)),
        ]);

        throw new \InvalidArgumentException($error);
    }


    /**
     * @return bool
     */
    protected function mode(): bool
    {
        return \tap($this->conjunction, function () {
            $this->conjunction = true;
        });
    }
}