RDS\Hydrogen\Criteria\Where

Complexity

Total Complexity

16

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	3

Test Coverage

Coverage

90%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	normalizeValue()	0	15	5
A	normalizeOperator()	0	12	5
A	completeMissingParameters()	0	8	2
A	getOperator()	0	4	1
A	getValue()	0	4	1
A	isAnd()	0	4	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\Criteria;

use Illuminate\Contracts\Support\Arrayable;
use RDS\Hydrogen\Criteria\Where\Operator;

/**
 * Class Where
 */
class Where extends Criterion
{
    /**
     * @var Operator
     */
    private $operator;

    /**
     * @var mixed
     */
    private $value;

    /**
     * @var bool
     */
    private $and;

    /**
     * Where constructor.
     * @param string $field
     * @param string $operator
     * @param mixed $value
     * @param bool $and
     */
    public function __construct(string $field, string $operator, $value, bool $and = true)
    {
        parent::__construct($field);

        $this->value = $this->normalizeValue($value);
        $this->operator = $this->normalizeOperator(new Operator($operator), $this->value);
        $this->and = $and;
    }

    /**
     * @param mixed $value
     * @return array|mixed
     */
    private function normalizeValue($value)
    {
        switch (true) {
            case $value instanceof Arrayable:
                return $value->toArray();

            case $value instanceof \Traversable:
                return \iterator_to_array($value);

            case \is_object($value) && \method_exists($value, '__toString'):
                return (string)$value;
        }

        return $value;
    }

    /**
     * @param Operator $operator
     * @param mixed $value
     * @return Operator
     */
    private function normalizeOperator(Operator $operator, $value): Operator
    {
        if (\is_array($value) && $operator->is(Operator::EQ)) {
            return $operator->changeTo(Operator::IN);
        }

        if (\is_array($value) && $operator->is(Operator::NEQ)) {
            return $operator->changeTo(Operator::NOT_IN);
        }

        return $operator;
    }

    /**
     * @param mixed $operator
     * @param null $value
     * @return array
     */
    public static function completeMissingParameters($operator, $value = null): array
    {
        if ($value === null) {
            [$value, $operator] = [$operator, Operator::EQ];
        }

        return [$operator, $value];
    }

    /**
     * @return Operator
     */
    public function getOperator(): Operator
    {
        return $this->operator;
    }

    /**
     * @return mixed
     */
    public function getValue()
    {
        return $this->value;
    }

    /**
     * @return bool
     */
    public function isAnd(): bool
    {
        return $this->and;
    }
}