BenTools\Where\Expression\Expression

Complexity

Total Complexity

15

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	and()	0	5	1
A	or()	0	5	1
B	where()	0	13	5
A	group()	0	4	1
A	not()	0	4	1
B	valuesFactory()	0	15	6
	__toString()	0	1	?
	getValues()	0	1	?

<?php
declare(strict_types=1);

namespace BenTools\Where\Expression;

abstract class Expression
{

    /**
     * @param       $expression
     * @param array ...$values
     * @return CompositeExpression
     * @throws \InvalidArgumentException
     */
    final public function and($expression, ...$values): CompositeExpression
    {
        $expression = $this->where($expression, ...$values);
        return new CompositeExpression('AND', $this, $expression);
    }

    /**
     * @param       $expression
     * @param array ...$values
     * @return CompositeExpression
     * @throws \InvalidArgumentException
     */
    final public function or($expression, ...$values): CompositeExpression
    {
        $expression = $this->where($expression, ...$values);
        return new CompositeExpression('OR', $this, $expression);
    }

    /**
     * @param       $expression
     * @param array ...$values
     * @return Expression
     * @throws \InvalidArgumentException
     */
    final public static function where($expression, ...$values): self
    {
        if (is_string($expression)) {
            return new Condition($expression, self::valuesFactory($values));
        }
        if ($expression instanceof self) {
            if (1 !== func_num_args()) {
                throw new \InvalidArgumentException("Cannot pass values to an existing Expression object.");
            }
            return $expression;
        }
        throw new \InvalidArgumentException(sprintf('Expected string or Expression object, %s given', is_object($expression) ? get_class($expression) : gettype($expression)));
    }

    /**
     * @param       $expression
     * @param array ...$values
     * @return GroupExpression
     * @throws \InvalidArgumentException
     */
    final public static function group($expression, ...$values): GroupExpression
    {
        return new GroupExpression(self::where($expression, ...$values));
    }

    /**
     * @param       $expression
     * @param array ...$values
     * @return NegatedExpression
     * @throws \InvalidArgumentException
     */
    final public static function not($expression, ...$values): NegatedExpression
    {
        return new NegatedExpression(self::where($expression, ...$values));
    }

    /**
     * @param array $values
     * @return array
     * @throws \InvalidArgumentException
     */
    final private static function valuesFactory(array $values): array
    {
        if (0 === count($values)) {
            return [];
        }
        if (1 === count($values) && is_array($values[0])) {
            return $values[0];
        }
        foreach ($values as $value) {
            if (is_array($value)) {
                throw new \InvalidArgumentException("Cannot construct expression with multiple array values.");
            }
        }
        return $values;
    }

    /**
     * @return string
     */
    abstract public function __toString(): string;

    /**
     * @return array
     */
    abstract public function getValues(): array;
}