RulesSerializer::getRuleIndex() - Code Metrics - Inspection of "Merge branch 'develop'" - limoncello-php-dist/flute - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1a67d2...dfab50 )

by Neomerx

created 2018-04-24 15:54 UTC

RulesSerializer::getRuleIndex() A

↳ Parent: RulesSerializer

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0
ccs	4
cts	4
cp	1
cc	1
eloc	4
nc	1
nop	1
crap	1

<?php namespace Limoncello\Flute\Validation\Serialize;

/**
 * Copyright 2015-2017 [email protected]
 *
 * 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\Validation\Contracts\Execution\BlockSerializerInterface;
use Limoncello\Validation\Contracts\Rules\RuleInterface;
use Limoncello\Validation\Execution\BlockSerializer;

/**
 * @package Limoncello\Flute
 */
class RulesSerializer
{
    // Single rule serialization keys

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

    /** Index key */
    protected const RULES_SINGLE_START_INDEXES = self::RULES_SINGLE_INDEX + 1;

    /** Index key */
    protected const RULES_SINGLE_END_INDEXES = self::RULES_SINGLE_START_INDEXES + 1;

    // Rules array serialization keys

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

    /** Index key */
    protected const RULES_ARRAY_START_INDEXES = self::RULES_ARRAY_INDEXES + 1;

    /** Index key */
    protected const RULES_ARRAY_END_INDEXES = self::RULES_ARRAY_START_INDEXES + 1;

    /**
     * @var BlockSerializerInterface
     */
    private $blockSerializer;

    /**
     * @param RuleInterface $rule
     *
     * @return array
     */
    public function addRule(RuleInterface $rule): array
    {
        $this->getSerializer()->clearBlocksWithStart()->clearBlocksWithEnd();

        $result = [
            static::RULES_SINGLE_INDEX         => $this->getSerializer()->addBlock($rule->toBlock()),
            static::RULES_SINGLE_START_INDEXES => $this->getSerializer()->getBlocksWithStart(),
            static::RULES_SINGLE_END_INDEXES   => $this->getSerializer()->getBlocksWithEnd(),
        ];

        return $result;
    }

    /**
     * @param BlockSerializerInterface $blockSerializer
     */
    public function __construct(BlockSerializerInterface $blockSerializer)
    {
        $this->blockSerializer = $blockSerializer;
    }

    /**
     * @param RuleInterface[] $rules
     *
     * @return array
     */
    public function addRules(array $rules): array
    {
        $this->getSerializer()->clearBlocksWithStart()->clearBlocksWithEnd();

        $indexes = [];
        foreach ($rules as $name => $rule) {
            assert($rule instanceof RuleInterface);

            $ruleName = $rule->getName();
            if (empty($ruleName) === true) {
                $ruleName = $name;
            }

            $block          = $rule->setName($ruleName)->enableCapture()->toBlock();
            $indexes[$name] = $this->getSerializer()->addBlock($block);
        }

        $ruleIndexes = [
            static::RULES_ARRAY_INDEXES       => $indexes,
            static::RULES_ARRAY_START_INDEXES => $this->getSerializer()->getBlocksWithStart(),
            static::RULES_ARRAY_END_INDEXES   => $this->getSerializer()->getBlocksWithEnd(),
        ];

        $this->getSerializer()->clearBlocksWithStart()->clearBlocksWithEnd();

        return $ruleIndexes;
    }

    /**
     * @return array
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    public function getBlocks(): array
    {
        $blocks = BlockSerializer::unserializeBlocks($this->getSerializer()->get());

        return $blocks;
    }

    /**
     * @param array $singleRuleIndexes
     *
     * @return int
     */
    public static function getRuleIndex(array $singleRuleIndexes): int
    {
        assert(array_key_exists(static::RULES_SINGLE_INDEX, $singleRuleIndexes));
        $result = $singleRuleIndexes[static::RULES_SINGLE_INDEX];

        return $result;
    }

    /**
     * @param array $singleRuleIndexes
     *
     * @return array
     */
    public static function getRuleStartIndexes(array $singleRuleIndexes): array
    {
        assert(array_key_exists(static::RULES_SINGLE_START_INDEXES, $singleRuleIndexes));
        $result = $singleRuleIndexes[static::RULES_SINGLE_START_INDEXES];

        return $result;
    }

    /**
     * @param array $singleRuleIndexes
     *
     * @return array
     */
    public static function getRuleEndIndexes(array $singleRuleIndexes): array
    {
        assert(array_key_exists(static::RULES_SINGLE_END_INDEXES, $singleRuleIndexes));
        $result = $singleRuleIndexes[static::RULES_SINGLE_END_INDEXES];

        return $result;
    }

    /**
     * @param array $arrayRulesIndexes
     *
     * @return array
     */
    public static function getRulesIndexes(array $arrayRulesIndexes): array
    {
        assert(array_key_exists(static::RULES_ARRAY_INDEXES, $arrayRulesIndexes));
        $result = $arrayRulesIndexes[static::RULES_ARRAY_INDEXES];

        return $result;
    }

    /**
     * @param array $arrayRulesIndexes
     *
     * @return array
     */
    public static function getRulesStartIndexes(array $arrayRulesIndexes): array
    {
        assert(array_key_exists(static::RULES_ARRAY_START_INDEXES, $arrayRulesIndexes));
        $result = $arrayRulesIndexes[static::RULES_ARRAY_START_INDEXES];

        return $result;
    }

    /**
     * @param array $arrayRulesIndexes
     *
     * @return array
     */
    public static function getRulesEndIndexes(array $arrayRulesIndexes): array
    {
        assert(array_key_exists(static::RULES_ARRAY_END_INDEXES, $arrayRulesIndexes));
        $result = $arrayRulesIndexes[static::RULES_ARRAY_END_INDEXES];

        return $result;
    }

    /**
     * @return BlockSerializerInterface
     */
    protected function getSerializer(): BlockSerializerInterface
    {
        return $this->blockSerializer;
    }
}


1		<?php namespace Limoncello\Flute\Validation\Serialize;
2
3		/**
4		* Copyright 2015-2017 [email protected]
5		*
6		* Licensed under the Apache License, Version 2.0 (the "License");
7		* you may not use this file except in compliance with the License.
8		* You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS,
14		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15		* See the License for the specific language governing permissions and
16		* limitations under the License.
17		*/
18
19		use Limoncello\Validation\Contracts\Execution\BlockSerializerInterface;
20		use Limoncello\Validation\Contracts\Rules\RuleInterface;
21		use Limoncello\Validation\Execution\BlockSerializer;
22
23		/**
24		* @package Limoncello\Flute
25		*/
26		class RulesSerializer
27		{
28		// Single rule serialization keys
29
30		/** Index key */
31		protected const RULES_SINGLE_INDEX = 0;
32
33		/** Index key */
34		protected const RULES_SINGLE_START_INDEXES = self::RULES_SINGLE_INDEX + 1;
35
36		/** Index key */
37		protected const RULES_SINGLE_END_INDEXES = self::RULES_SINGLE_START_INDEXES + 1;
38
39		// Rules array serialization keys
40
41		/** Index key */
42		protected const RULES_ARRAY_INDEXES = 0;
43
44		/** Index key */
45		protected const RULES_ARRAY_START_INDEXES = self::RULES_ARRAY_INDEXES + 1;
46
47		/** Index key */
48		protected const RULES_ARRAY_END_INDEXES = self::RULES_ARRAY_START_INDEXES + 1;
49
50		/**
51		* @var BlockSerializerInterface
52		*/
53		private $blockSerializer;
54
55		/**
56		* @param RuleInterface $rule
57		*
58		* @return array
59		*/
60	40	public function addRule(RuleInterface $rule): array
61		{
62	40	$this->getSerializer()->clearBlocksWithStart()->clearBlocksWithEnd();
63
64		$result = [
65	40	static::RULES_SINGLE_INDEX => $this->getSerializer()->addBlock($rule->toBlock()),
66	40	static::RULES_SINGLE_START_INDEXES => $this->getSerializer()->getBlocksWithStart(),
67	40	static::RULES_SINGLE_END_INDEXES => $this->getSerializer()->getBlocksWithEnd(),
68		];
69
70	40	return $result;
71		}
72
73		/**
74		* @param BlockSerializerInterface $blockSerializer
75		*/
76	57	public function __construct(BlockSerializerInterface $blockSerializer)
77		{
78	57	$this->blockSerializer = $blockSerializer;
79		}
80
81		/**
82		* @param RuleInterface[] $rules
83		*
84		* @return array
85		*/
86	57	public function addRules(array $rules): array
87		{
88	57	$this->getSerializer()->clearBlocksWithStart()->clearBlocksWithEnd();
89
90	57	$indexes = [];
91	57	foreach ($rules as $name => $rule) {
92	53	assert($rule instanceof RuleInterface);
93
94	53	$ruleName = $rule->getName();
95	53	if (empty($ruleName) === true) {
96	53	$ruleName = $name;
97		}
98
99	53	$block = $rule->setName($ruleName)->enableCapture()->toBlock();
100	53	$indexes[$name] = $this->getSerializer()->addBlock($block);
101		}
102
103		$ruleIndexes = [
104	57	static::RULES_ARRAY_INDEXES => $indexes,
105	57	static::RULES_ARRAY_START_INDEXES => $this->getSerializer()->getBlocksWithStart(),
106	57	static::RULES_ARRAY_END_INDEXES => $this->getSerializer()->getBlocksWithEnd(),
107		];
108
109	57	$this->getSerializer()->clearBlocksWithStart()->clearBlocksWithEnd();
110
111	57	return $ruleIndexes;
112		}
113
114		/**
115		* @return array
116		*
117		* @SuppressWarnings(PHPMD.StaticAccess)
118		*/
119	57	public function getBlocks(): array
120		{
121	57	$blocks = BlockSerializer::unserializeBlocks($this->getSerializer()->get());
122
123	57	return $blocks;
124		}
125
126		/**
127		* @param array $singleRuleIndexes
128		*
129		* @return int
130		*/
131	14	public static function getRuleIndex(array $singleRuleIndexes): int
132		{
133	14	assert(array_key_exists(static::RULES_SINGLE_INDEX, $singleRuleIndexes));
134	14	$result = $singleRuleIndexes[static::RULES_SINGLE_INDEX];
135
136	14	return $result;
137		}
138
139		/**
140		* @param array $singleRuleIndexes
141		*
142		* @return array
143		*/
144	15	public static function getRuleStartIndexes(array $singleRuleIndexes): array
145		{
146	15	assert(array_key_exists(static::RULES_SINGLE_START_INDEXES, $singleRuleIndexes));
147	15	$result = $singleRuleIndexes[static::RULES_SINGLE_START_INDEXES];
148
149	15	return $result;
150		}
151
152		/**
153		* @param array $singleRuleIndexes
154		*
155		* @return array
156		*/
157	15	public static function getRuleEndIndexes(array $singleRuleIndexes): array
158		{
159	15	assert(array_key_exists(static::RULES_SINGLE_END_INDEXES, $singleRuleIndexes));
160	15	$result = $singleRuleIndexes[static::RULES_SINGLE_END_INDEXES];
161
162	15	return $result;
163		}
164
165		/**
166		* @param array $arrayRulesIndexes
167		*
168		* @return array
169		*/
170	46	public static function getRulesIndexes(array $arrayRulesIndexes): array
171		{
172	46	assert(array_key_exists(static::RULES_ARRAY_INDEXES, $arrayRulesIndexes));
173	46	$result = $arrayRulesIndexes[static::RULES_ARRAY_INDEXES];
174
175	46	return $result;
176		}
177
178		/**
179		* @param array $arrayRulesIndexes
180		*
181		* @return array
182		*/
183	54	public static function getRulesStartIndexes(array $arrayRulesIndexes): array
184		{
185	54	assert(array_key_exists(static::RULES_ARRAY_START_INDEXES, $arrayRulesIndexes));
186	54	$result = $arrayRulesIndexes[static::RULES_ARRAY_START_INDEXES];
187
188	54	return $result;
189		}
190
191		/**
192		* @param array $arrayRulesIndexes
193		*
194		* @return array
195		*/
196	54	public static function getRulesEndIndexes(array $arrayRulesIndexes): array
197		{
198	54	assert(array_key_exists(static::RULES_ARRAY_END_INDEXES, $arrayRulesIndexes));
199	54	$result = $arrayRulesIndexes[static::RULES_ARRAY_END_INDEXES];
200
201	54	return $result;
202		}
203
204		/**
205		* @return BlockSerializerInterface
206		*/
207	57	protected function getSerializer(): BlockSerializerInterface
208		{
209	57	return $this->blockSerializer;
210		}
211		}
212

limoncello-php-dist / flute

Push — master ( 1a67d2...dfab50 )

RulesSerializer::getRuleIndex() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like