Limoncello\Flute\Http\Query\QueryValidator

Complexity

Total Complexity

40

Size/Duplication

Total Lines	437
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Test Coverage

Coverage

100%

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	1
A	withAllAllowedFilterFields()	0	8	1
A	withNoAllowedFilterFields()	0	8	1
A	withAllowedFilterFields()	0	8	1
A	withValidatedFilterFields()	0	6	1
B	getFilters()	0	32	6
A	createContextStorage()	0	4	1
A	createCaptureAggregator()	0	4	1
A	createErrorAggregator()	0	4	1
A	setContextStorage()	0	6	1
A	getCaptureAggregator()	0	4	1
A	setCaptureAggregator()	0	6	1
A	getErrorAggregator()	0	4	1
A	setErrorAggregator()	0	6	1
A	getValidatedOperationsAndArguments()	0	9	2
A	getValidatedArguments()	0	9	3
A	getContextStorage()	0	4	1
A	getRulesData()	0	4	1
A	setRulesData()	0	6	1
A	getBlocks()	0	4	1
A	setBlocks()	0	6	1
A	setAttributeRules()	0	9	1
A	unsetAttributeRules()	0	7	1
A	getAttributeRules()	0	4	1
A	getAttributeIndex()	0	6	1
A	executeStarts()	0	9	1
A	executeEnds()	0	9	1
A	executeBlock()	0	11	1
A	debugCheckIndexesExist()	0	16	4

<?php namespace Limoncello\Flute\Http\Query;

/**
 * Copyright 2015-2017 info@neomerx.com
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Limoncello\Container\Traits\HasContainerTrait;
use Limoncello\Flute\Contracts\Adapters\PaginationStrategyInterface;
use Limoncello\Flute\Contracts\Http\Query\QueryParserInterface;
use Limoncello\Flute\Contracts\Http\Query\QueryValidatorInterface;
use Limoncello\Flute\Contracts\Validation\ErrorCodes;
use Limoncello\Flute\Exceptions\InvalidQueryParametersException;
use Limoncello\Flute\Validation\Form\Execution\FormRuleSerializer;
use Limoncello\Validation\Captures\CaptureAggregator;
use Limoncello\Validation\Contracts\Captures\CaptureAggregatorInterface;
use Limoncello\Validation\Contracts\Errors\ErrorAggregatorInterface;
use Limoncello\Validation\Contracts\Execution\ContextStorageInterface;
use Limoncello\Validation\Errors\Error;
use Limoncello\Validation\Errors\ErrorAggregator;
use Limoncello\Validation\Execution\BlockInterpreter;
use Limoncello\Validation\Execution\ContextStorage;
use Psr\Container\ContainerInterface;

/**
 * @package Limoncello\Flute
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class QueryValidator extends QueryParser implements QueryValidatorInterface
{
    use HasContainerTrait;

    /**
     * @var ContextStorageInterface
     */
    private $contextStorage;

    /**
     * @var CaptureAggregatorInterface
     */
    private $captureAggregator;

    /**
     * @var ErrorAggregatorInterface
     */
    private $errorAggregator;

    /**
     * @var array
     */
    private $rulesData;

    /**
     * @var array
     */
    private $blocks;

    /**
     * @var int[]
     */
    private $attributeRules;

    /**
     * @var array
     */
    private $attributeRulesIdx;

    /**
     * @param array                       $data
     * @param ContainerInterface          $container
     * @param PaginationStrategyInterface $paginationStrategy
     * @param string[]|null               $messages
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public function __construct(
        array $data,
        ContainerInterface $container,
        PaginationStrategyInterface $paginationStrategy,
        array $messages = null
    ) {
        $this
            ->setContainer($container)
            ->setRulesData($data)
            ->setBlocks(FormRuleSerializer::extractBlocks($this->getRulesData()))
            ->setContextStorage($this->createContextStorage())
            ->setCaptureAggregator($this->createCaptureAggregator())
            ->setErrorAggregator($this->createErrorAggregator());

        parent::__construct($paginationStrategy, $messages);
    }

    /**
     * @inheritdoc
     */
    public function withAllAllowedFilterFields(): QueryParserInterface
    {
        $self = parent::withAllAllowedFilterFields();

        $this->unsetAttributeRules();

        return $self;
    }

    /**
     * @inheritdoc
     */
    public function withNoAllowedFilterFields(): QueryParserInterface
    {
        $self = parent::withNoAllowedFilterFields();

        $this->unsetAttributeRules();

        return $self;
    }

    /**
     * @inheritdoc
     */
    public function withAllowedFilterFields(array $fields): QueryParserInterface
    {
        $self = parent::withAllowedFilterFields($fields);

        $this->unsetAttributeRules();

        return $self;
    }

    /**
     * @inheritdoc
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public function withValidatedFilterFields(string $rulesSetClass): QueryValidatorInterface
    {
        $this->withAllAllowedFilterFields();

        return $this->setAttributeRules(FormRuleSerializer::getAttributeRules($rulesSetClass, $this->getRulesData()));
    }

    /**
     * @inheritdoc
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     * @SuppressWarnings(PHPMD.ElseExpression)
     */
    public function getFilters(): iterable
    {
        $filters = parent::getFilters();

        $serializedRules = $this->getAttributeRules();

        // if validation rules were actually set
        if ($serializedRules !== null) {
            $this->executeStarts(FormRuleSerializer::getRulesStartIndexes($serializedRules));

            foreach ($filters as $field => $operationsAndArgs) {
                if (($index = $this->getAttributeIndex($field)) !== null) {
                    yield $field => $this->getValidatedOperationsAndArguments($index, $field, $operationsAndArgs);
                } else {
                    // unknown field
                    $value   = null;
                    $context = null;
                    $this->getErrorAggregator()->add(new Error($field, $value, ErrorCodes::INVALID_VALUE, $context));
                }
            }

            $this->executeEnds(FormRuleSerializer::getRulesEndIndexes($this->getAttributeRules()));

It seems like $this->getAttributeRules() targeting Limoncello\Flute\Http\Query\QueryValidator::getAttributeRules() can also be of type null; however, Limoncello\Flute\Validation\Form\Execution\FormRuleSerializer::getRulesEndIndexes() does only seem to accept array, maybe add an additional type check?

            if ($this->getErrorAggregator()->count() > 0) {
                throw new InvalidQueryParametersException($this->createParameterError(static::PARAM_FILTER));
            }
        } else {
            foreach ($filters as $field => $operationsAndArgs) {
                yield $field => $operationsAndArgs;
            }
        }
    }

    /**
     * @return ContextStorageInterface
     */
    protected function createContextStorage(): ContextStorageInterface
    {
        return new ContextStorage($this->getBlocks(), $this->getContainer());
    }

    /**
     * @return CaptureAggregatorInterface
     */
    protected function createCaptureAggregator(): CaptureAggregatorInterface
    {
        return new CaptureAggregator();
    }

    /**
     * @return ErrorAggregatorInterface
     */
    protected function createErrorAggregator(): ErrorAggregatorInterface
    {
        return new ErrorAggregator();
    }

    /**
     * @param ContextStorageInterface $contextStorage
     *
     * @return self
     */
    private function setContextStorage(ContextStorageInterface $contextStorage): self
    {
        $this->contextStorage = $contextStorage;

        return $this;
    }

    /**
     * @return CaptureAggregatorInterface
     */
    private function getCaptureAggregator(): CaptureAggregatorInterface
    {
        return $this->captureAggregator;
    }

    /**
     * @param CaptureAggregatorInterface $captureAggregator
     *
     * @return self
     */
    private function setCaptureAggregator(CaptureAggregatorInterface $captureAggregator): self
    {
        $this->captureAggregator = $captureAggregator;

        return $this;
    }

    /**
     * @return ErrorAggregatorInterface
     */
    private function getErrorAggregator(): ErrorAggregatorInterface
    {
        return $this->errorAggregator;
    }

    /**
     * @param ErrorAggregatorInterface $errorAggregator
     *
     * @return self
     */
    private function setErrorAggregator(ErrorAggregatorInterface $errorAggregator): self
    {
        $this->errorAggregator = $errorAggregator;

        return $this;
    }

    /**
     * @param int      $blockIndex
     * @param string   $name
     * @param iterable $operationsAndArgs
     *
     * @return iterable

Should the return type not be \Generator?

     */
    private function getValidatedOperationsAndArguments(
        int $blockIndex,
        string $name,
        iterable $operationsAndArgs
    ): iterable {
        foreach ($operationsAndArgs as $operation => $args) {
            yield $operation => $this->getValidatedArguments($blockIndex, $name, $args);
        }
    }

    /**
     * @param int      $blockIndex
     * @param string   $name
     * @param iterable $arguments
     *
     * @return iterable

Should the return type not be \Generator?

     */
    private function getValidatedArguments(int $blockIndex, string $name, iterable $arguments): iterable
    {
        foreach ($arguments as $argument) {
            if ($this->executeBlock($argument, $blockIndex) === true) {
                $validated = $this->getCaptureAggregator()->get()[$name];
                yield $validated;
            }
        }
    }

    /**
     * @return ContextStorageInterface
     */
    private function getContextStorage(): ContextStorageInterface
    {
        return $this->contextStorage;
    }

    /**
     * @return array
     */
    private function getRulesData(): array
    {
        return $this->rulesData;
    }

    /**
     * @param array $rulesData
     *
     * @return self
     */
    private function setRulesData(array $rulesData): self
    {
        $this->rulesData = $rulesData;

        return $this;
    }

    /**
     * @return array
     */
    private function getBlocks(): array
    {
        return $this->blocks;
    }

    /**
     * @param array $blocks
     *
     * @return self
     */
    private function setBlocks(array $blocks): self
    {
        $this->blocks = $blocks;

        return $this;
    }

    /**
     * @param array $rules
     *
     * @return self
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private function setAttributeRules(array $rules): self
    {
        assert($this->debugCheckIndexesExist($rules));

        $this->attributeRules    = $rules;
        $this->attributeRulesIdx = FormRuleSerializer::getRulesIndexes($rules);

        return $this;
    }

    /**
     * @return self
     */
    private function unsetAttributeRules(): self
    {
        $this->attributeRules    = null;

It seems like null of type null is incompatible with the declared type array<integer,integer> of property $attributeRules.

        $this->attributeRulesIdx = null;

It seems like null of type null is incompatible with the declared type array of property $attributeRulesIdx.

        return $this;
    }

    /**
     * @return int[]|null
     */
    private function getAttributeRules(): ?array
    {
        return $this->attributeRules;
    }

    /**
     * @param string $name
     *
     * @return int|null
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private function getAttributeIndex(string $name): ?int
    {
        $index = $this->attributeRulesIdx[$name] ?? null;

        return $index;
    }

    /**
     * @param array $indexes
     *
     * @return bool
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private function executeStarts(array $indexes): bool
    {
        return BlockInterpreter::executeStarts(
            $indexes,
            $this->getBlocks(),
            $this->getContextStorage(),
            $this->getErrorAggregator()
        );
    }

    /**
     * @param array $indexes
     *
     * @return bool
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private function executeEnds(array $indexes): bool
    {
        return BlockInterpreter::executeEnds(
            $indexes,
            $this->getBlocks(),
            $this->getContextStorage(),
            $this->getErrorAggregator()
        );
    }

    /**
     * @param mixed $input
     * @param int   $index
     *
     * @return bool
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private function executeBlock($input, int $index): bool
    {
        return BlockInterpreter::executeBlock(
            $input,
            $index,
            $this->getBlocks(),
            $this->getContextStorage(),
            $this->getCaptureAggregator(),
            $this->getErrorAggregator()
        );
    }

    /**
     * @param array $rules
     *
     * @return bool
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private function debugCheckIndexesExist(array $rules): bool
    {
        $allOk = true;

        $indexes = array_merge(
            FormRuleSerializer::getRulesIndexes($rules),
            FormRuleSerializer::getRulesStartIndexes($rules),
            FormRuleSerializer::getRulesEndIndexes($rules)
        );

        foreach ($indexes as $index) {
            $allOk = $allOk && is_int($index) && FormRuleSerializer::isRuleExist($index, $this->getBlocks());
        }

        return $allOk;
    }
}