Validator::validateInternal() - Code Metrics - Inspection of "Fix #251: Merge rules and attributes" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#255)

by Alexander

created 2022-07-17 11:20 UTC

Validator::validateInternal() B

↳ Parent: Validator

Complexity

Conditions	7
Paths	10

Size

Total Lines	28
Code Lines	17

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	7

Importance

Changes

Metric	Value
eloc	17
c	0
b	0
f	0
dl	0
loc	28
ccs	18
cts	18
cp	1
rs	8.8333
cc	7
nc	10
nop	3
crap	7

<?php

declare(strict_types=1);

namespace Yiisoft\Validator;

use InvalidArgumentException;
use JetBrains\PhpStorm\Pure;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use Yiisoft\Validator\DataSet\ArrayDataSet;
use Yiisoft\Validator\DataSet\ScalarDataSet;
use Yiisoft\Validator\Rule\Callback;

use Yiisoft\Validator\Rule\Trait\PreValidateTrait;
use function is_array;
use function is_object;

/**
 * Validator validates {@link DataSetInterface} against rules set for data set attributes.
 */
final class Validator implements ValidatorInterface
{
    use PreValidateTrait;

    public function __construct(private RuleHandlerResolverInterface $ruleHandlerResolver)
    {
    }

    /**
     * @param DataSetInterface|mixed|RulesProviderInterface $data
     * @param iterable<RuleInterface|RuleInterface[]> $rules
     */
    public function validate($data, iterable $rules = []): Result
    {
        $data = $this->normalizeDataSet($data);
        if ($data instanceof RulesProviderInterface) {
            $explicitRules = $rules;
            $rules = (array) $data->getRules();

            foreach ($explicitRules as $key => $value) {
                $rules[$key] = $value;
            }
        }

        $context = new ValidationContext($this, $data);
        $compoundResult = new Result();

        $results = [];

        foreach ($rules as $attribute => $attributeRules) {
            $result = new Result();

            $tempRule = is_array($attributeRules) ? $attributeRules : [$attributeRules];
            $attributeRules = $this->normalizeRules($tempRule);

            if (is_int($attribute)) {
                $validatedData = $data->getData();
                $validatedContext = $context;
            } else {
                $validatedData = $data->getAttributeValue($attribute);
                $validatedContext = $context->withAttribute($attribute);
            }

            $tempResult = $this->validateInternal(
                $validatedData,
                $attributeRules,
                $validatedContext
            );

            $result = $this->addErrors($result, $tempResult->getErrors());
            $results[] = $result;
        }

        foreach ($results as $result) {
            $compoundResult = $this->addErrors($compoundResult, $result->getErrors());
        }

        if ($data instanceof PostValidationHookInterface) {
            $data->processValidationResult($compoundResult);
        }

        return $compoundResult;
    }

    #[Pure]
    private function normalizeDataSet($data): DataSetInterface
    {
        if ($data instanceof DataSetInterface) {
            return $data;
        }

        if (is_object($data) || is_array($data)) {
            return new ArrayDataSet((array)$data);
        }

        return new ScalarDataSet($data);
    }

    /**
     * @param $value
     * @param iterable<RuleInterface> $rules
     * @param ValidationContext $context
     *
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     *
     * @return Result
     */
    private function validateInternal($value, iterable $rules, ValidationContext $context): Result
    {
        $compoundResult = new Result();
        foreach ($rules as $rule) {
            if ($rule instanceof BeforeValidationInterface) {
                $preValidateResult = $this->preValidate($value, $context, $rule);
                if ($preValidateResult) {
                    continue;
                }
            }

            $ruleHandler = $this->ruleHandlerResolver->resolve($rule->getHandlerClassName());
            $ruleResult = $ruleHandler->validate($value, $rule, $context);
            if ($ruleResult->isValid()) {
                continue;
            }

            $context->setParameter($this->parameterPreviousRulesErrored, true);

            foreach ($ruleResult->getErrors() as $error) {
                $valuePath = $error->getValuePath();
                if ($context->getAttribute() !== null) {
                    $valuePath = [$context->getAttribute()] + $valuePath;
                }
                $compoundResult->addError($error->getMessage(), $valuePath);
            }
        }
        return $compoundResult;
    }

    /**
     * @param array $rules
     *
     * @return iterable<RuleInterface>
     */
    private function normalizeRules(iterable $rules): iterable
    {
        foreach ($rules as $rule) {
            yield $this->normalizeRule($rule);
        }
    }

    private function normalizeRule($rule): RuleInterface
    {
        if (is_callable($rule)) {
            return new Callback($rule);
        }

        if (!$rule instanceof RuleInterface) {
            throw new InvalidArgumentException(
                sprintf(
                    'Rule should be either an instance of %s or a callable, %s given.',
                    RuleInterface::class,
                    gettype($rule)
                )
            );
        }

        return $rule;
    }

    private function addErrors(Result $result, array $errors): Result
    {
        foreach ($errors as $error) {
            $result->addError($error->getMessage(), $error->getValuePath());
        }
        return $result;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Validator;
6
7		use InvalidArgumentException;
8		use JetBrains\PhpStorm\Pure;
9		use Psr\Container\ContainerExceptionInterface;
10		use Psr\Container\NotFoundExceptionInterface;
11		use Yiisoft\Validator\DataSet\ArrayDataSet;
12		use Yiisoft\Validator\DataSet\ScalarDataSet;
13		use Yiisoft\Validator\Rule\Callback;
14
15		use Yiisoft\Validator\Rule\Trait\PreValidateTrait;
16		use function is_array;
17		use function is_object;
18
19		/**
20		* Validator validates {@link DataSetInterface} against rules set for data set attributes.
21		*/
22		final class Validator implements ValidatorInterface
23		{
24		use PreValidateTrait;
25
26	576	public function __construct(private RuleHandlerResolverInterface $ruleHandlerResolver)
27		{
28		}
29
30		/**
31		* @param DataSetInterface\|mixed\|RulesProviderInterface $data
32		* @param iterable<RuleInterface\|RuleInterface[]> $rules
33		*/
34	39	public function validate($data, iterable $rules = []): Result
35		{
36	39	$data = $this->normalizeDataSet($data);
37	39	if ($data instanceof RulesProviderInterface) {
38	2	$explicitRules = $rules;
39	2	$rules = (array) $data->getRules();
40
41	2	foreach ($explicitRules as $key => $value) {
42		$rules[$key] = $value;
43		}
44		}
45
46	39	$context = new ValidationContext($this, $data);
47	39	$compoundResult = new Result();
48
49	39	$results = [];
50
51	39	foreach ($rules as $attribute => $attributeRules) {
52	39	$result = new Result();
53
54	39	$tempRule = is_array($attributeRules) ? $attributeRules : [$attributeRules];
55	39	$attributeRules = $this->normalizeRules($tempRule);
56
57	39	if (is_int($attribute)) {
58	24	$validatedData = $data->getData();
59	24	$validatedContext = $context;
60		} else {
61	15	$validatedData = $data->getAttributeValue($attribute);
62	15	$validatedContext = $context->withAttribute($attribute);
63		}
64
65	39	$tempResult = $this->validateInternal(
66		$validatedData,
67		$attributeRules,
68		$validatedContext
69		);
70
71	37	$result = $this->addErrors($result, $tempResult->getErrors());
72	37	$results[] = $result;
73		}
74
75	37	foreach ($results as $result) {
76	37	$compoundResult = $this->addErrors($compoundResult, $result->getErrors());
77		}
78
79	37	if ($data instanceof PostValidationHookInterface) {
80		$data->processValidationResult($compoundResult);
81		}
82
83	37	return $compoundResult;
84		}
85
86	39	#[Pure]
87		private function normalizeDataSet($data): DataSetInterface
88		{
89	39	if ($data instanceof DataSetInterface) {
90	8	return $data;
91		}
92
93	31	if (is_object($data) \|\| is_array($data)) {
94	6	return new ArrayDataSet((array)$data);
95		}
96
97	30	return new ScalarDataSet($data);
98		}
99
100		/**
101		* @param $value
102		* @param iterable<RuleInterface> $rules
103		* @param ValidationContext $context
104		*
105		* @throws ContainerExceptionInterface
106		* @throws NotFoundExceptionInterface
107		*
108		* @return Result
109		*/
110	39	private function validateInternal($value, iterable $rules, ValidationContext $context): Result
111		{
112	39	$compoundResult = new Result();
113	39	foreach ($rules as $rule) {
114	39	if ($rule instanceof BeforeValidationInterface) {
115	37	$preValidateResult = $this->preValidate($value, $context, $rule);
116	37	if ($preValidateResult) {
117	2	continue;
118		}
119		}
120
121	37	$ruleHandler = $this->ruleHandlerResolver->resolve($rule->getHandlerClassName());
122	35	$ruleResult = $ruleHandler->validate($value, $rule, $context);
123	35	if ($ruleResult->isValid()) {
124	24	continue;
125		}
126
127	22	$context->setParameter($this->parameterPreviousRulesErrored, true);
128
129	22	foreach ($ruleResult->getErrors() as $error) {
130	22	$valuePath = $error->getValuePath();
131	22	if ($context->getAttribute() !== null) {
132	3	$valuePath = [$context->getAttribute()] + $valuePath;
133		}
134	22	$compoundResult->addError($error->getMessage(), $valuePath);
135		}
136		}
137	37	return $compoundResult;
138		}
139
140		/**
141		* @param array $rules
142		*
143		* @return iterable<RuleInterface>
144		*/
145	39	private function normalizeRules(iterable $rules): iterable
146		{
147	39	foreach ($rules as $rule) {
148	39	yield $this->normalizeRule($rule);
149		}
150		}
151
152	39	private function normalizeRule($rule): RuleInterface
153		{
154	39	if (is_callable($rule)) {
155	3	return new Callback($rule);
156		}
157
158	39	if (!$rule instanceof RuleInterface) {
159		throw new InvalidArgumentException(
160		sprintf(
161		'Rule should be either an instance of %s or a callable, %s given.',
162		RuleInterface::class,
163		gettype($rule)
164		)
165		);
166		}
167
168	39	return $rule;
169		}
170
171	37	private function addErrors(Result $result, array $errors): Result
172		{
173	37	foreach ($errors as $error) {
174	22	$result->addError($error->getMessage(), $error->getValuePath());
175		}
176	37	return $result;
177		}
178		}
179

yiisoft / validator

Pull Request — master (#255)

Validator::validateInternal() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like