Validator::validate() - Code Metrics - Inspection of "Make translator optional + Improve package configu..." - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#371)

by Sergei

created 2022-11-15 13:28 UTC

Validator::validate() F

↳ Parent: Validator

Complexity

Conditions	16
Paths	280

Size

Total Lines	77
Code Lines	43

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	37
CRAP Score	16.4314

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	43
c	2
b	0
f	0
dl	0
loc	77
ccs	37
cts	42
cp	0.881
rs	3.7333
cc	16
nc	280
nop	3
crap	16.4314

How to fix Long Method Complexity

<?php

declare(strict_types=1);

namespace Yiisoft\Validator;

use InvalidArgumentException;
use ReflectionException;
use ReflectionProperty;
use Traversable;
use Yiisoft\Translator\CategorySource;
use Yiisoft\Translator\IdMessageReader;
use Yiisoft\Translator\IntlMessageFormatter;
use Yiisoft\Translator\SimpleMessageFormatter;
use Yiisoft\Translator\Translator;
use Yiisoft\Translator\TranslatorInterface;
use Yiisoft\Validator\Rule\Callback;
use Yiisoft\Validator\Rule\Trait\PreValidateTrait;
use Yiisoft\Validator\RulesProvider\AttributesRulesProvider;

use function extension_loaded;
use function is_callable;
use function is_int;
use function is_object;
use function is_string;

/**
 * Validator validates {@link DataSetInterface} against rules set for data set attributes.
 *
 * @psalm-import-type RulesType from ValidatorInterface
 */
final class Validator implements ValidatorInterface
{
    use PreValidateTrait;

    private TranslatorInterface $translator;

    /**
     * @var callable
     */
    private $defaultSkipOnEmptyCallback;

    /**
     * @param int $rulesPropertyVisibility What visibility levels to use when reading rules from the class specified in
     * `$rules` argument in {@see validate()} method.
     */
    public function __construct(
        private RuleHandlerResolverInterface $ruleHandlerResolver,
        ?TranslatorInterface $translator = null,
        private int $rulesPropertyVisibility = ReflectionProperty::IS_PRIVATE
        | ReflectionProperty::IS_PROTECTED
        | ReflectionProperty::IS_PUBLIC,
        bool|callable|null $defaultSkipOnEmpty = null,
        private string $translationCategory = 'yii-validator',
    ) {
        $this->translator = $translator ?? $this->createDefaultTranslator();
        $this->defaultSkipOnEmptyCallback = SkipOnEmptyNormalizer::normalize($defaultSkipOnEmpty);
    }

    /**
     * @param DataSetInterface|mixed|RulesProviderInterface $data
     *
     * @psalm-param RulesType $rules
     *
     * @throws ReflectionException
     */
    public function validate(
        mixed $data,
        iterable|object|string|null $rules = null,
        ?ValidationContext $context = null
    ): Result {
        $data = DataSetHelper::normalize($data);
        if ($rules === null && $data instanceof RulesProviderInterface) {
            $rules = $data->getRules();
        } elseif ($rules instanceof RulesProviderInterface) {
            $rules = $rules->getRules();
        } elseif ($rules instanceof RuleInterface) {
            $rules = [$rules];
        } elseif (is_string($rules) || (is_object($rules) && !$rules instanceof Traversable)) {
            $rules = (new AttributesRulesProvider($rules, $this->rulesPropertyVisibility))->getRules();
        }

        $compoundResult = new Result();
        $context ??= new ValidationContext($this, $data);
        $results = [];

        /**
         * @var mixed $attribute
         * @var mixed $attributeRules
         */
        foreach ($rules ?? [] as $attribute => $attributeRules) {
            $result = new Result();

            if (!is_iterable($attributeRules)) {
                $attributeRules = [$attributeRules];
            }

            $attributeRules = $this->normalizeRules($attributeRules);

            if (is_int($attribute)) {
                /** @psalm-suppress MixedAssignment */
                $validatedData = $data->getData();
            } elseif (is_string($attribute)) {
                /** @psalm-suppress MixedAssignment */
                $validatedData = $data->getAttributeValue($attribute);
                $context->setAttribute($attribute);
            } else {
                $message = sprintf(
                    'An attribute can only have an integer or a string type. %s given.',
                    get_debug_type($attribute),
                );

                throw new InvalidArgumentException($message);
            }

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

            foreach ($tempResult->getErrors() as $error) {
                $result->addError($error->getMessage(), $error->getParameters(), $error->getValuePath());
            }

            $results[] = $result;
        }

        foreach ($results as $result) {
            foreach ($result->getErrors() as $error) {
                $compoundResult->addError(
                    $this->translator->translate(
                        $error->getMessage(),
                        $error->getParameters(),
                        $this->translationCategory
                    ),
                    $error->getParameters(),
                    $error->getValuePath()
                );
            }
        }

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

        return $compoundResult;
    }

    /**
     * @param iterable<RuleInterface> $rules
     */
    private function validateInternal(mixed $value, iterable $rules, ValidationContext $context): Result
    {
        $compoundResult = new Result();
        foreach ($rules as $rule) {
            if ($this->preValidate($value, $context, $rule)) {
                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(), $error->getParameters(), $valuePath);
            }
        }
        return $compoundResult;
    }

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

    private function normalizeRule(mixed $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,
                    get_debug_type($rule)
                )
            );
        }

        if ($rule instanceof SkipOnEmptyInterface && $rule->getSkipOnEmpty() === null) {
            $rule = $rule->skipOnEmpty($this->defaultSkipOnEmptyCallback);
        }

        return $rule;
    }

    private function createDefaultTranslator(): Translator
    {
        $categorySource = new CategorySource(
            $this->translationCategory,
            new IdMessageReader(),
            extension_loaded('intl') ? new IntlMessageFormatter() : new SimpleMessageFormatter(),
        );

        $translator = new Translator();
        $translator->addCategorySources($categorySource);
        return $translator;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Validator;
6
7		use InvalidArgumentException;
8		use ReflectionException;
9		use ReflectionProperty;
10		use Traversable;
11		use Yiisoft\Translator\CategorySource;
12		use Yiisoft\Translator\IdMessageReader;
13		use Yiisoft\Translator\IntlMessageFormatter;
14		use Yiisoft\Translator\SimpleMessageFormatter;
15		use Yiisoft\Translator\Translator;
16		use Yiisoft\Translator\TranslatorInterface;
17		use Yiisoft\Validator\Rule\Callback;
18		use Yiisoft\Validator\Rule\Trait\PreValidateTrait;
19		use Yiisoft\Validator\RulesProvider\AttributesRulesProvider;
20
21		use function extension_loaded;
22		use function is_callable;
23		use function is_int;
24		use function is_object;
25		use function is_string;
26
27		/**
28		* Validator validates {@link DataSetInterface} against rules set for data set attributes.
29		*
30		* @psalm-import-type RulesType from ValidatorInterface
31		*/
32		final class Validator implements ValidatorInterface
33		{
34		use PreValidateTrait;
35
36		private TranslatorInterface $translator;
37
38		/**
39		* @var callable
40		*/
41		private $defaultSkipOnEmptyCallback;
42
43		/**
44		* @param int $rulesPropertyVisibility What visibility levels to use when reading rules from the class specified in
45		* `$rules` argument in {@see validate()} method.
46		*/
47	696	public function __construct(
48		private RuleHandlerResolverInterface $ruleHandlerResolver,
49		?TranslatorInterface $translator = null,
50		private int $rulesPropertyVisibility = ReflectionProperty::IS_PRIVATE
51		\| ReflectionProperty::IS_PROTECTED
52		\| ReflectionProperty::IS_PUBLIC,
53		bool\|callable\|null $defaultSkipOnEmpty = null,
54		private string $translationCategory = 'yii-validator',
55		) {
56	696	$this->translator = $translator ?? $this->createDefaultTranslator();
57	696	$this->defaultSkipOnEmptyCallback = SkipOnEmptyNormalizer::normalize($defaultSkipOnEmpty);
58		}
59
60		/**
61		* @param DataSetInterface\|mixed\|RulesProviderInterface $data
62		*
63		* @psalm-param RulesType $rules
64		*
65		* @throws ReflectionException
66		*/
67	716	public function validate(
68		mixed $data,
69		iterable\|object\|string\|null $rules = null,
70		?ValidationContext $context = null
71		): Result {
72	716	$data = DataSetHelper::normalize($data);
73	716	if ($rules === null && $data instanceof RulesProviderInterface) {
74	27	$rules = $data->getRules();
75	693	} elseif ($rules instanceof RulesProviderInterface) {
76	2	$rules = $rules->getRules();
77	691	} elseif ($rules instanceof RuleInterface) {
78	1	$rules = [$rules];
79	690	} elseif (is_string($rules) \|\| (is_object($rules) && !$rules instanceof Traversable)) {
80		$rules = (new AttributesRulesProvider($rules, $this->rulesPropertyVisibility))->getRules();
81		}
82
83	716	$compoundResult = new Result();
84	716	$context ??= new ValidationContext($this, $data);
85	716	$results = [];
86
87		/**
88		* @var mixed $attribute
89		* @var mixed $attributeRules
90		*/
91	716	foreach ($rules ?? [] as $attribute => $attributeRules) {
92	705	$result = new Result();
93
94	705	if (!is_iterable($attributeRules)) {
95	630	$attributeRules = [$attributeRules];
96		}
97
98	705	$attributeRules = $this->normalizeRules($attributeRules);
99
100	705	if (is_int($attribute)) {
101		/** @psalm-suppress MixedAssignment */
102	614	$validatedData = $data->getData();
103	95	} elseif (is_string($attribute)) {
104		/** @psalm-suppress MixedAssignment */
105	95	$validatedData = $data->getAttributeValue($attribute);
106	95	$context->setAttribute($attribute);
107		} else {
108		$message = sprintf(
109		'An attribute can only have an integer or a string type. %s given.',
110		get_debug_type($attribute),
111		);
112
113		throw new InvalidArgumentException($message);
114		}
115
116	705	$tempResult = $this->validateInternal($validatedData, $attributeRules, $context);
117
118	680	foreach ($tempResult->getErrors() as $error) {
119	396	$result->addError($error->getMessage(), $error->getParameters(), $error->getValuePath());
120		}
121
122	680	$results[] = $result;
123		}
124
125	691	foreach ($results as $result) {
126	680	foreach ($result->getErrors() as $error) {
127	396	$compoundResult->addError(
128	396	$this->translator->translate(
129	396	$error->getMessage(),
130	396	$error->getParameters(),
131	396	$this->translationCategory
132		),
133	396	$error->getParameters(),
134	396	$error->getValuePath()
135		);
136		}
137		}
138
139	691	if ($data instanceof PostValidationHookInterface) {
140		$data->processValidationResult($compoundResult);
141		}
142
143	691	return $compoundResult;
144		}
145
146		/**
147		* @param iterable<RuleInterface> $rules
148		*/
149	705	private function validateInternal(mixed $value, iterable $rules, ValidationContext $context): Result
150		{
151	705	$compoundResult = new Result();
152	705	foreach ($rules as $rule) {
153	705	if ($this->preValidate($value, $context, $rule)) {
154	27	continue;
155		}
156
157	699	$ruleHandler = $this->ruleHandlerResolver->resolve($rule->getHandlerClassName());
158	697	$ruleResult = $ruleHandler->validate($value, $rule, $context);
159	674	if ($ruleResult->isValid()) {
160	301	continue;
161		}
162
163	396	$context->setParameter($this->parameterPreviousRulesErrored, true);
164
165	396	foreach ($ruleResult->getErrors() as $error) {
166	396	$valuePath = $error->getValuePath();
167	396	if ($context->getAttribute() !== null) {
168	71	$valuePath = [$context->getAttribute(), ...$valuePath];
169		}
170	396	$compoundResult->addError($error->getMessage(), $error->getParameters(), $valuePath);
171		}
172		}
173	680	return $compoundResult;
174		}
175
176		/**
177		* @return iterable<RuleInterface>
178		*/
179	705	private function normalizeRules(iterable $rules): iterable
180		{
181		/** @var mixed $rule */
182	705	foreach ($rules as $rule) {
183	705	yield $this->normalizeRule($rule);
184		}
185		}
186
187	705	private function normalizeRule(mixed $rule): RuleInterface
188		{
189	705	if (is_callable($rule)) {
190	4	return new Callback($rule);
191		}
192
193	704	if (!$rule instanceof RuleInterface) {
194		throw new InvalidArgumentException(
195		sprintf(
196		'Rule should be either an instance of %s or a callable, %s given.',
197		RuleInterface::class,
198		get_debug_type($rule)
199		)
200		);
201		}
202
203	704	if ($rule instanceof SkipOnEmptyInterface && $rule->getSkipOnEmpty() === null) {
204	617	$rule = $rule->skipOnEmpty($this->defaultSkipOnEmptyCallback);
205		}
206
207	704	return $rule;
208		}
209
210	1	private function createDefaultTranslator(): Translator
211		{
212	1	$categorySource = new CategorySource(
213	1	$this->translationCategory,
214	1	new IdMessageReader(),
215	1	extension_loaded('intl') ? new IntlMessageFormatter() : new SimpleMessageFormatter(),
216		);
217
218	1	$translator = new Translator();
219	1	$translator->addCategorySources($categorySource);
220	1	return $translator;
221		}
222		}
223

yiisoft / validator

Pull Request — master (#371)

Validator::validate() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like