OldTown\Workflow\Query\NestedExpression

Complexity

Total Complexity

13

Size/Duplication

Total Lines	136
Duplicated Lines	8.09 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

79.41%

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	10	3
A	isNested()	0	4	1
A	getExpressionOperator()	0	4	1
A	setExpressionOperator()	11	11	2
A	getExpressions()	0	4	1
A	setExpressions()	0	7	1
A	validExpressions()	0	9	3
A	getExpressionCount()	0	6	1

<?php
/**
 * @link https://github.com/old-town/old-town-workflow
 * @author  Malofeykin Andrey  <and-rey2@yandex.ru>
 */
namespace OldTown\Workflow\Query;

use OldTown\Workflow\Exception\ArgumentNotNumericException;
use OldTown\Workflow\Exception\InvalidArgumentException;

/**
 * Class NestedExpression
 * @package OldTown\Workflow\Query
 */
class NestedExpression extends AbstractExpression
{
    /**
     *
     * @var integer
     */
    const AND_OPERATOR = 6;
    /**
     *
     * @var integer
     */
    const OR_OPERATOR = 7;

    /**
     *
     *
     * @var int
     */
    private $expressionOperator = self::AND_OPERATOR;

    /**
     * @var AbstractExpression[]
     */
    private $expressions = [];

    /**
     * @param array $expressions
     * @param null $expressionOperator
     * @throws ArgumentNotNumericException
     * @throws InvalidArgumentException
     */
    public function __construct(array $expressions = null, $expressionOperator = null)
    {
        if (null !== $expressions) {
            $this->setExpressions($expressions);
        }

        if (null !== $expressionOperator) {
            $this->setExpressionOperator($expressionOperator);
        }
    }


    /**
     * Флаг определяющий есть ли вложенные свойства
     *
     * @return boolean
     */
    public function isNested()
    {
        return true;
    }

    /**
     * Возвращает тип вложенного выражения
     *
     * @return int
     */
    public function getExpressionOperator()
    {
        return $this->expressionOperator;
    }

    /**
     * Устанавливает тип вложенного выражения
     *
     * @param int $expressionOperator
     * @return $this
     * @throws ArgumentNotNumericException
     */
    public function setExpressionOperator($expressionOperator)

This method seems to be duplicated in your project.

    {
        if (!is_numeric($expressionOperator)) {
            $errMsg = sprintf('Аргумент должен быть числом. Актуальное значение %s', $expressionOperator);
            throw new ArgumentNotNumericException($errMsg);
        }

        $this->expressionOperator = (integer)$expressionOperator;

        return $this;
    }

    /**
     * Возвращает выражения
     *
     * @return AbstractExpression[]
     */
    public function getExpressions()
    {
        return $this->expressions;
    }

    /**
     * Устанавливает выражения
     *
     * @param AbstractExpression[] $expressions
     * @return $this
     * @throws InvalidArgumentException
     */
    public function setExpressions(array $expressions = [])
    {
        $this->validExpressions($expressions);
        $this->expressions = $expressions;

        return $this;
    }

    /**
     * Проверка корректности колекции выражений
     *
     * @param array $expressions
     * @return void
     * @throws InvalidArgumentException
     */
    protected function validExpressions(array $expressions = [])
    {
        foreach ($expressions as $expression) {
            if (!$expression instanceof AbstractExpression) {
                $errMsg = 'Некорректная коллекция объектов запросов в workflow';
                throw new InvalidArgumentException($errMsg);
            }
        }
    }

    /**
     * Колличество выражений
     *
     * @return int
     */
    public function getExpressionCount()
    {
        $expressionCount = count($this->expressions);

        return $expressionCount;
    }
}