ArrayValidation::validateArrayImplementation() - Code Metrics - Inspection of "0.7.0" - limoncello-php-dist/validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 22fd50...798002 )

by Neomerx

created 2017-08-14 16:25 UTC

ArrayValidation::validateArrayImplementation() B

↳ Parent: ArrayValidation

Complexity

Conditions	2
Paths	2

Size

Total Lines	29
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	8.8571
c	0
b	0
f	0
cc	2
eloc	21
nc	2
nop	3

<?php namespace Limoncello\Validation\Validator;

/**
 * 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\Captures\CaptureAggregatorInterface;
use Limoncello\Validation\Contracts\Errors\ErrorAggregatorInterface;
use Limoncello\Validation\Contracts\Rules\RuleInterface;
use Limoncello\Validation\Execution\BlockInterpreter;
use Limoncello\Validation\Execution\BlockSerializer;

/**
 * @package Limoncello\Validation
 *
 * The trait expects the following method to be implemented by a class that uses this trait.
 * - createContextStorageFromBlocks(array $blocks): ContextStorageInterface
 */
trait ArrayValidation
{
    /**
     * @var RuleInterface[]
     */
    private $rules;

    /**
     * @return RuleInterface[]
     */
    protected function getRules(): array
    {
        return $this->rules;
    }

    /**
     * @param RuleInterface[] $rules
     *
     * @return self
     */
    private function setRules(array $rules): self
    {
        $this->rules = $rules;

        return $this;
    }

    /**
     * @param array                      $input
     * @param CaptureAggregatorInterface $captures
     * @param ErrorAggregatorInterface   $errors
     *
     * @return void
     *
     * @SuppressWarnings(PHPMD.StaticAccess)
     */
    private function validateArrayImplementation(
        array $input,
        CaptureAggregatorInterface $captures,
        ErrorAggregatorInterface $errors
    ): void {
        list($indexMap, $serialized) = $this->getSerializedRules($this->getRules());

        $blocks = BlockSerializer::unserializeBlocks($serialized);

        // the method is expected to be implemented by a class that uses this trait
        $context = $this->createContextStorageFromBlocks($blocks);
trait Idable {
    public function equalIds(Idable $other) {
        return $this->getId() === $other->getId();
    }
}

        BlockInterpreter::executeStarts(
            BlockSerializer::unserializeBlocksWithStart($serialized),
            $blocks,
            $context,
            $errors
        );
        foreach ($input as $key => $value) {
            $blockIndex = $indexMap[$key];
            BlockInterpreter::executeBlock($value, $blockIndex, $blocks, $context, $captures, $errors);
        }
        BlockInterpreter::executeEnds(
            BlockSerializer::unserializeBlocksWithEnd($serialized),
            $blocks,
            $context,
            $errors
        );
    }

    /**
     * @param RuleInterface[] $rules
     *
     * @return array
     */
    private function getSerializedRules(array $rules): array
    {
        $serializer = new BlockSerializer();

        $indexMap = [];
        foreach ($rules as $name => $rule) {
            $indexMap[$name] = $serializer->addBlock($rule->setName($name)->enableCapture()->toBlock());
        }

        $serialized = $serializer->get();

        return [$indexMap, $serialized];
    }
}


1			<?php namespace Limoncello\Validation\Validator;
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\Captures\CaptureAggregatorInterface;
20			use Limoncello\Validation\Contracts\Errors\ErrorAggregatorInterface;
21			use Limoncello\Validation\Contracts\Rules\RuleInterface;
22			use Limoncello\Validation\Execution\BlockInterpreter;
23			use Limoncello\Validation\Execution\BlockSerializer;
24
25			/**
26			* @package Limoncello\Validation
27			*
28			* The trait expects the following method to be implemented by a class that uses this trait.
29			* - createContextStorageFromBlocks(array $blocks): ContextStorageInterface
30			*/
31			trait ArrayValidation
32			{
33			/**
34			* @var RuleInterface[]
35			*/
36			private $rules;
37
38			/**
39			* @return RuleInterface[]
40			*/
41			protected function getRules(): array
42			{
43			return $this->rules;
44			}
45
46			/**
47			* @param RuleInterface[] $rules
48			*
49			* @return self
50			*/
51			private function setRules(array $rules): self
52			{
53			$this->rules = $rules;
54
55			return $this;
56			}
57
58			/**
59			* @param array $input
60			* @param CaptureAggregatorInterface $captures
61			* @param ErrorAggregatorInterface $errors
62			*
63			* @return void
64			*
65			* @SuppressWarnings(PHPMD.StaticAccess)
66			*/
67			private function validateArrayImplementation(
68			array $input,
69			CaptureAggregatorInterface $captures,
70			ErrorAggregatorInterface $errors
71			): void {
72			list($indexMap, $serialized) = $this->getSerializedRules($this->getRules());
73
74			$blocks = BlockSerializer::unserializeBlocks($serialized);
75
76			// the method is expected to be implemented by a class that uses this trait
77			$context = $this->createContextStorageFromBlocks($blocks);
			0 ignored issues – show Bug introduced 2017-08-14 16:28 UTC by Report Bug Copy Issue Report It seems like `createContextStorageFromBlocks()` must be provided by classes using this trait. How about adding it as abstract method to this trait? This check looks for methods that are used by a trait but not required by it. To illustrate, let’s look at the following code example trait Idable { public function equalIds(Idable $other) { return $this->getId() === $other->getId(); } } The trait `Idable` provides a method `equalsId` that in turn relies on the method `getId()`. If this method does not exist on a class mixing in this trait, the method will fail. Adding the `getId()` as an abstract method to the trait will make sure it is available. Loading history...
78
79			BlockInterpreter::executeStarts(
80			BlockSerializer::unserializeBlocksWithStart($serialized),
81			$blocks,
82			$context,
83			$errors
84			);
85			foreach ($input as $key => $value) {
86			$blockIndex = $indexMap[$key];
87			BlockInterpreter::executeBlock($value, $blockIndex, $blocks, $context, $captures, $errors);
88			}
89			BlockInterpreter::executeEnds(
90			BlockSerializer::unserializeBlocksWithEnd($serialized),
91			$blocks,
92			$context,
93			$errors
94			);
95			}
96
97			/**
98			* @param RuleInterface[] $rules
99			*
100			* @return array
101			*/
102			private function getSerializedRules(array $rules): array
103			{
104			$serializer = new BlockSerializer();
105
106			$indexMap = [];
107			foreach ($rules as $name => $rule) {
108			$indexMap[$name] = $serializer->addBlock($rule->setName($name)->enableCapture()->toBlock());
109			}
110
111			$serialized = $serializer->get();
112
113			return [$indexMap, $serialized];
114			}
115			}
116

limoncello-php-dist / validation

Push — master ( 22fd50...798002 )

ArrayValidation::validateArrayImplementation() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like