Limoncello\Flute\Validation\JsonApi\Execution\JsonApiQueryRulesSerializer

Complexity

Total Complexity

29

Size/Duplication

Total Lines	240
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	addRulesFromClass()	0	18	1
F	addQueryRules()	0	34	11
A	getData()	0	7	1
A	readBlocks()	0	4	1
A	hasRules()	0	7	2
A	readRules()	0	6	1
A	readFilterRulesIndexes()	0	4	1
A	readFieldSetRulesIndexes()	0	4	1
A	readSortsRuleIndexes()	0	4	1
A	readIncludesRuleIndexes()	0	4	1
A	readPageOffsetRuleIndexes()	0	4	1
A	readPageLimitRuleIndexes()	0	4	1
A	readRuleMainIndexes()	0	4	1
A	readRuleMainIndex()	0	7	1
A	readRuleStartIndexes()	0	4	1
A	readRuleEndIndexes()	0	4	1
A	isRulesClass()	0	6	2

<?php namespace Limoncello\Flute\Validation\JsonApi\Execution;

/**
 * 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\Flute\Contracts\Validation\JsonApiQueryRulesInterface;
use Limoncello\Flute\Contracts\Validation\JsonApiQueryRulesSerializerInterface;
use Limoncello\Flute\Validation\Serialize\RulesSerializer;
use Limoncello\Validation\Contracts\Rules\RuleInterface;
use Neomerx\JsonApi\Contracts\Http\Query\BaseQueryParserInterface;

/**
 * @package Limoncello\Flute
 *
 * @SuppressWarnings(PHPMD.TooManyPublicMethods)
 */
class JsonApiQueryRulesSerializer extends RulesSerializer implements JsonApiQueryRulesSerializerInterface
{
    /**
     * @var array
     */
    private $serializedRules = [];

    /** Index key */
    protected const FILTER_RULES = 0;

    /** Index key */
    protected const FIELD_SET_RULES = self::FILTER_RULES + 1;

    /** Index key */
    protected const SORTS_RULE = self::FIELD_SET_RULES + 1;

    /** Index key */
    protected const INCLUDES_RULE = self::SORTS_RULE + 1;

    /** Index key */
    protected const PAGE_OFFSET_RULE = self::INCLUDES_RULE + 1;

    /** Index key */
    protected const PAGE_LIMIT_RULE = self::PAGE_OFFSET_RULE + 1;

    /** Index key */
    protected const SINGLE_RULE_INDEX = 0;

    /** Serialized indexes key */
    protected const SERIALIZED_RULES = 0;

    /** Serialized rules key */
    protected const SERIALIZED_BLOCKS = self::SERIALIZED_RULES + 1;

    /**
     * @inheritdoc
     */
    public function addRulesFromClass(string $rulesClass): JsonApiQueryRulesSerializerInterface
    {
        assert(static::isRulesClass($rulesClass));

Since isRulesClass() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of isRulesClass() to at least protected.

        $name = $rulesClass;

        /** @var JsonApiQueryRulesInterface $rulesClass */

        return $this->addQueryRules(
            $name,
            $rulesClass::getFilterRules(),
            $rulesClass::getFieldSetRules(),
            $rulesClass::getSortsRule(),
            $rulesClass::getIncludesRule(),
            $rulesClass::getPageOffsetRule(),
            $rulesClass::getPageLimitRule()
        );
    }

    /**
     * @param string               $name
     * @param RuleInterface[]|null $filterRules
     * @param RuleInterface[]|null $fieldSetRules
     * @param RuleInterface|null   $sortsRule
     * @param RuleInterface|null   $includesRule
     * @param RuleInterface|null   $pageOffsetRule
     * @param RuleInterface|null   $pageLimitRule
     *
     * @return self
     *
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.NPathComplexity)
     */
    public function addQueryRules(
        string $name,
        ?array $filterRules,
        ?array $fieldSetRules,
        ?RuleInterface $sortsRule,
        ?RuleInterface $includesRule,
        ?RuleInterface $pageOffsetRule,
        ?RuleInterface $pageLimitRule
    ): JsonApiQueryRulesSerializerInterface {
        assert(!empty($name));
        assert(static::hasRules($name, $this->serializedRules) === false);

        $sortsRule === null ?: $sortsRule->setName(BaseQueryParserInterface::PARAM_SORT);
        $includesRule === null ?: $includesRule->setName(BaseQueryParserInterface::PARAM_INCLUDE);
        $pageOffsetRule === null ?: $pageOffsetRule->setName(BaseQueryParserInterface::PARAM_PAGE);
        $pageLimitRule === null ?: $pageLimitRule->setName(BaseQueryParserInterface::PARAM_PAGE);

        $this->serializedRules[$name] = [
            static::FILTER_RULES     =>
                $filterRules === null ? null : $this->addRules($filterRules),
            static::FIELD_SET_RULES  =>
                $fieldSetRules === null ? null : $this->addRules($fieldSetRules),
            static::SORTS_RULE       =>
                $sortsRule === null ? null : $this->addRules([static::SINGLE_RULE_INDEX => $sortsRule]),
            static::INCLUDES_RULE    =>
                $includesRule === null ? null : $this->addRules([static::SINGLE_RULE_INDEX => $includesRule]),
            static::PAGE_OFFSET_RULE =>
                $pageOffsetRule === null ? null : $this->addRules([static::SINGLE_RULE_INDEX => $pageOffsetRule]),
            static::PAGE_LIMIT_RULE  =>
                $pageLimitRule === null ? null : $this->addRules([static::SINGLE_RULE_INDEX => $pageLimitRule]),
        ];

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function getData(): array
    {
        return [
            static::SERIALIZED_RULES  => $this->serializedRules,
            static::SERIALIZED_BLOCKS => $this->getBlocks(),
        ];
    }

    /**
     * @inheritdoc
     */
    public static function readBlocks(array $serializedData): array
    {
        return $serializedData[static::SERIALIZED_BLOCKS];
    }

    /**
     * @inheritdoc
     */
    public static function hasRules(string $name, array $serializedData): bool
    {
        // the value could be null so we have to check by key existence.
        return
            array_key_exists(static::SERIALIZED_RULES, $serializedData) === true &&
            array_key_exists($name, $serializedData[static::SERIALIZED_RULES]);
    }

    /**
     * @inheritdoc
     */
    public static function readRules(string $name, array $serializedData): array
    {
        assert(static::hasRules($name, $serializedData) === true);

        return $serializedData[static::SERIALIZED_RULES][$name];
    }

    /**
     * @inheritdoc
     */
    public static function readFilterRulesIndexes(array $serializedRules): ?array
    {
        return $serializedRules[static::FILTER_RULES];
    }

    /**
     * @inheritdoc
     */
    public static function readFieldSetRulesIndexes(array $serializedRules): ?array
    {
        return $serializedRules[static::FIELD_SET_RULES];
    }

    /**
     * @inheritdoc
     */
    public static function readSortsRuleIndexes(array $serializedRules): ?array
    {
        return $serializedRules[static::SORTS_RULE];
    }

    /**
     * @inheritdoc
     */
    public static function readIncludesRuleIndexes(array $serializedRules): ?array
    {
        return $serializedRules[static::INCLUDES_RULE];
    }

    /**
     * @inheritdoc
     */
    public static function readPageOffsetRuleIndexes(array $serializedRules): ?array
    {
        return $serializedRules[static::PAGE_OFFSET_RULE];
    }

    /**
     * @inheritdoc
     */
    public static function readPageLimitRuleIndexes(array $serializedRules): ?array
    {
        return $serializedRules[static::PAGE_LIMIT_RULE];
    }

    /**
     * @inheritdoc
     */
    public static function readRuleMainIndexes(array $ruleIndexes): ?array
    {
        return parent::getRulesIndexes($ruleIndexes);

It seems like you call parent on a different method (getRulesIndexes() instead of readRuleMainIndexes()). Are you sure this is correct? If so, you might want to change this to $this->getRulesIndexes().

    }

    /**
     * @inheritdoc
     */
    public static function readRuleMainIndex(array $ruleIndexes): ?int
    {
        // if you read main/first/only rule and blocks actually have more then something must be wrong
        assert(count($ruleIndexes[static::RULES_ARRAY_INDEXES]) === 1);

        return $ruleIndexes[static::RULES_ARRAY_INDEXES][static::SINGLE_RULE_INDEX];
    }

    /**
     * @inheritdoc
     */
    public static function readRuleStartIndexes(array $ruleIndexes): array
    {
        return parent::getRulesStartIndexes($ruleIndexes);

It seems like you call parent on a different method (getRulesStartIndexes() instead of readRuleStartIndexes()). Are you sure this is correct? If so, you might want to change this to $this->getRulesStartIndexes().

    }

    /**
     * @inheritdoc
     */
    public static function readRuleEndIndexes(array $ruleIndexes): array
    {
        return parent::getRulesEndIndexes($ruleIndexes);

It seems like you call parent on a different method (getRulesEndIndexes() instead of readRuleEndIndexes()). Are you sure this is correct? If so, you might want to change this to $this->getRulesEndIndexes().

    }

    /**
     * @param string $rulesClass
     *
     * @return bool
     */
    private static function isRulesClass(string $rulesClass): bool
    {
        return
            class_exists($rulesClass) === true &&
            in_array(JsonApiQueryRulesInterface::class, class_implements($rulesClass)) === true;
    }
}