Validator::validate() - Code Metrics - Inspection of "[RFC] Split validator features" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#320)

by Dmitriy

created 2022-10-04 11:12 UTC

Validator::validate() B

↳ Parent: Validator

Complexity

Conditions	11
Paths	40

Size

Total Lines	49
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	24
CRAP Score	11.055

Importance

Changes	6
Bugs	1	Features	0

Metric	Value
eloc	30
c	6
b	1
f	0
dl	0
loc	49
ccs	24
cts	26
cp	0.9231
rs	7.3166
cc	11
nc	40
nop	3
crap	11.055

How to fix Complexity

<?php

declare(strict_types=1);

namespace Yiisoft\Validator;

use Closure;
use InvalidArgumentException;
use JetBrains\PhpStorm\Pure;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use ReflectionProperty;
use Traversable;
use Yiisoft\Validator\DataSet\ArrayDataSet;
use Yiisoft\Validator\DataSet\MixedDataSet;
use Yiisoft\Validator\DataSet\ObjectDataSet;
use Yiisoft\Validator\Rule\Callback;
use Yiisoft\Validator\Rule\Trait\PreValidateTrait;

use Yiisoft\Validator\RulesProvider\AttributesRulesProvider;

use function is_callable;
use function is_int;

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

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

    public function __construct(
        private RuleHandlerResolverInterface $ruleHandlerResolver,

        /**
         * @var bool|callable|null
         */
        $defaultSkipOnEmpty = null,
        /**
         * @var int What visibility levels to use when reading rules from the class specified in `$rules` argument in
         * {@see validate()} method.
         */
        private int $rulesPropertyVisibility = ReflectionProperty::IS_PRIVATE
        | ReflectionProperty::IS_PROTECTED
        | ReflectionProperty::IS_PUBLIC,
    ) {
        $this->defaultSkipOnEmptyCallback = SkipOnEmptyNormalizer::normalize($defaultSkipOnEmpty);
    }

    /**
     * @param DataSetInterface|mixed|RulesProviderInterface $data
     * @param class-string|iterable<Closure|Closure[]|RuleInterface|RuleInterface[]>|RulesProviderInterface|null $rules

     *
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    public function validate(
        mixed $data,
        iterable|RulesProviderInterface|null $rules = null,
        ?ValidationContext $context = null,
    ): Result {
        $data = $this->normalizeDataSet($data);

        if ($rules === null && $data instanceof RulesProviderInterface) {
            $rules = $data->getRules();
        } elseif ($rules instanceof RulesProviderInterface) {
            $rules = $rules->getRules();
        } elseif (!$rules instanceof Traversable && !is_array($rules) && $rules !== null) {
            $rules = (new AttributesRulesProvider($rules, $this->rulesPropertyVisibility))->getRules();
            $rules = (new AttributesRulesProvider(/** @scrutinizer ignore-type */ $rules, $this->rulesPropertyVisibility))->getRules();
        }

        $context = new ValidationContext(
            $context?->getValidator() ?? $this,
            $context?->getDataSet() ?? $data,
            $context?->getAttribute() ?? null,
            $context?->getParameters() ?? [],
        );

        $compoundResult = new Result();

        foreach ($rules ?? [] as $attribute => $attributeRules) {
            $tempRule = is_iterable($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);
            }

            $this->validateInternal(
                $validatedData,
                $attributeRules,
                $validatedContext,
                $compoundResult,
            );
        }

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

        return $compoundResult;
    }

    /**
     * @param iterable<Closure|Closure[]|RuleInterface|RuleInterface[]> $rules
     *
     * @throws ContainerExceptionInterface
     * @throws NotFoundExceptionInterface
     */
    private function validateInternal($value, iterable $rules, ValidationContext $context, Result $compoundResult): void
    {
        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, $error->getParameters());
            }
        }
    }

    /**
     * @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,
                    get_debug_type($rule)
                )
            );
        }

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

        return $rule;
    }

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

        if (is_object($data)) {
            return new ObjectDataSet($data);
        }

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

        return new MixedDataSet($data);
    }
}


yiisoft / validator

Pull Request — master (#320)

Validator::validate() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like