Yiisoft\Validator\Rule\Nested

Complexity

Total Complexity

29

Size/Duplication

Total Lines	202
Duplicated Lines	0 %

Test Coverage

Coverage

82.54%

Importance

Changes	4
Bugs	2	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getRequirePropertyPath()	0	3	1
A	getRules()	0	3	1
A	getNoPropertyPathMessage()	0	3	1
A	getPropertyVisibility()	0	3	1
A	getOptions()	0	17	2
A	__construct()	0	41	1
A	getHandlerClassName()	0	3	1
B	prepareRules()	0	26	9
B	normalizeRules()	0	48	9
A	checkRules()	0	8	3

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Attribute;
use Closure;
use InvalidArgumentException;
use JetBrains\PhpStorm\ArrayShape;
use ReflectionProperty;
use Traversable;
use Yiisoft\Strings\StringHelper;
use Yiisoft\Validator\BeforeValidationInterface;
use Yiisoft\Validator\Rule\Trait\BeforeValidationTrait;
use Yiisoft\Validator\Rule\Trait\RuleNameTrait;
use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
use Yiisoft\Validator\RuleInterface;
use Yiisoft\Validator\RulesDumper;
use Yiisoft\Validator\RulesProvider\AttributesRulesProvider;
use Yiisoft\Validator\RulesProviderInterface;
use Yiisoft\Validator\SerializableRuleInterface;
use Yiisoft\Validator\SkipOnEmptyInterface;
use Yiisoft\Validator\ValidationContext;

use function array_pop;
use function count;

This use statement conflicts with another class in this namespace, Yiisoft\Validator\Rule\count. Consider defining an alias.

use function implode;
use function is_array;
use function ltrim;
use function rtrim;
use function sprintf;

/**
 * Can be used for validation of nested structures.
 */
#[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
final class Nested implements SerializableRuleInterface, BeforeValidationInterface, SkipOnEmptyInterface
{
    use BeforeValidationTrait;
    use RuleNameTrait;
    use SkipOnEmptyTrait;

    private const SEPARATOR = '.';
    private const EACH_SHORTCUT = '*';

    /**
     * @var iterable<Closure|Closure[]|RuleInterface|RuleInterface[]>|null
     */
    private ?iterable $rules = null;

    public function __construct(
        /**
         * Rules for validate value that can be described by:
         * - object that implement {@see RulesProviderInterface};
         * - name of class from whose attributes their will be derived;
         * - array or object implementing the `Traversable` interface that contain {@see RuleInterface} implementations
         *   or closures.
         *
         * `$rules` can be null if validatable value is object. In this case rules will be derived from object via
         * `getRules()` method if object implement {@see RulesProviderInterface} or from attributes otherwise.
         *
         * @var class-string|iterable<Closure|Closure[]|RuleInterface|RuleInterface[]>|RulesProviderInterface|null
         */
        iterable|object|string|null $rules = null,

        /**
         * @var int What visibility levels to use when reading data and rules from validatable object.
         */
        private int $propertyVisibility = ReflectionProperty::IS_PRIVATE | ReflectionProperty::IS_PROTECTED | ReflectionProperty::IS_PUBLIC,

        /**
         * @var int What visibility levels to use when reading rules from the class specified in {@see $rules}
         * attribute.
         */
        private int $rulesPropertyVisibility = ReflectionProperty::IS_PRIVATE | ReflectionProperty::IS_PROTECTED | ReflectionProperty::IS_PUBLIC,
        private bool $requirePropertyPath = false,
        private string $noPropertyPathMessage = 'Property path "{path}" is not found.',
        private bool $normalizeRules = true,

        /**
         * @var bool|callable|null
         */
        private $skipOnEmpty = null,
        private bool $skipOnError = false,

        /**
         * @var Closure(mixed, ValidationContext):bool|null
         */
        private ?Closure $when = null,
    ) {
        $this->rules = $this->prepareRules($rules);
    }

    /**
     * @return iterable<Closure|Closure[]|RuleInterface|RuleInterface[]>|null
     */
    public function getRules(): ?iterable
    {
        return $this->rules;
    }

    public function getPropertyVisibility(): int
    {
        return $this->propertyVisibility;
    }

    /**
     * @return bool
     */
    public function getRequirePropertyPath(): bool
    {
        return $this->requirePropertyPath;
    }

    /**
     * @return string
     */
    public function getNoPropertyPathMessage(): string
    {
        return $this->noPropertyPathMessage;
    }

    /**
     * @param class-string|iterable<Closure|Closure[]|RuleInterface|RuleInterface[]>|RulesProviderInterface|null $source

The doc comment class-string|iterable<Closure|Closure[]|RuleInterface|RuleInterface[]>|RulesProviderInterface|null at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string|iterable<Closure|Closure[]|RuleInterface|RuleInterface[]>|RulesProviderInterface|null.

     */
    private function prepareRules(iterable|object|string|null $source): ?iterable
    {
        if ($source === null) {
            return null;
        }

        if ($source instanceof RulesProviderInterface) {
            $rules = $source->getRules();
            return $this->normalizeRules ? $this->normalizeRules($rules) : $rules;

The expression return $this->normalizeRules ? $this->normalizeRules($rules) : $rules could return the type array which is incompatible with the type-hinted return iterable|null. Consider adding an additional type-check to rule them out.

        }

        $isTraversable = $source instanceof Traversable;

        if (!$isTraversable && !is_array($source)) {
            return (new AttributesRulesProvider($source, $this->rulesPropertyVisibility))->getRules();

The expression return new Yiisoft\Validator\RulesProvider\AttributesRulesProvider($source, $this->rulesPropertyVisibility)->getRules() returns the type array which is incompatible with the type-hinted return iterable|null.

It seems like $source can also be of type iterable; however, parameter $source of Yiisoft\Validator\RulesProvider\AttributesRulesProvider::__construct() does only seem to accept object|string, maybe add an additional type check?

        }

        /** @psalm-suppress InvalidArgument Psalm don't see $isTraversable above. */
        $rules = $isTraversable ? iterator_to_array($source) : $source;

It seems like $source can also be of type array; however, parameter $iterator of iterator_to_array() does only seem to accept Traversable, maybe add an additional type check?

        if (self::checkRules($rules)) {
            $message = sprintf('Each rule should be an instance of %s.', RuleInterface::class);
            throw new InvalidArgumentException($message);
        }

        return $this->normalizeRules ? $this->normalizeRules($rules) : $rules;

The expression return $this->normalizeRules ? $this->normalizeRules($rules) : $rules returns the type Traversable|array which is incompatible with the type-hinted return iterable|null.

    }

    private static function checkRules($rules): bool
    {
        return array_reduce(
            $rules,
            function (bool $carry, $rule) {
                return $carry || (is_array($rule) ? self::checkRules($rule) : !$rule instanceof RuleInterface);
            },
            false
        );
    }

    private function normalizeRules(iterable $sourceRules): array
    {
        $rules = $sourceRules instanceof Traversable ? iterator_to_array($sourceRules) : $sourceRules;
        while (true) {
            $breakWhile = true;
            $rulesMap = [];

            foreach ($rules as $valuePath => $rule) {
                if ($valuePath === self::EACH_SHORTCUT) {
                    throw new InvalidArgumentException('Bare shortcut is prohibited. Use "Each" rule instead.');
                }

                $parts = StringHelper::parsePath(
                    (string) $valuePath,
                    delimiter: self::EACH_SHORTCUT,
                    preserveDelimiterEscaping: true
                );
                if (count($parts) === 1) {
                    continue;
                }

                $breakWhile = false;

                $lastValuePath = array_pop($parts);
                $lastValuePath = ltrim($lastValuePath, '.');
                $lastValuePath = str_replace('\\' . self::EACH_SHORTCUT, self::EACH_SHORTCUT, $lastValuePath);

                $remainingValuePath = implode(self::EACH_SHORTCUT, $parts);
                $remainingValuePath = rtrim($remainingValuePath, self::SEPARATOR);

                if (!isset($rulesMap[$remainingValuePath])) {
                    $rulesMap[$remainingValuePath] = [];
                }

                $rulesMap[$remainingValuePath][$lastValuePath] = $rule;
                unset($rules[$valuePath]);
            }

            foreach ($rulesMap as $valuePath => $nestedRules) {
                $rules[$valuePath] = new Each([new self($nestedRules, normalizeRules: false)]);
            }

            if ($breakWhile === true) {
                break;
            }
        }

        return $rules;

The expression return $rules could return the type iterable which is incompatible with the type-hinted return array. Consider adding an additional type-check to rule them out.

    }

    #[ArrayShape([
        'requirePropertyPath' => 'bool',
        'noPropertyPathMessage' => 'array',
        'skipOnEmpty' => 'bool',
        'skipOnError' => 'bool',
        'rules' => 'array|null',
    ])]
    public function getOptions(): array
    {
        return [
            'requirePropertyPath' => $this->getRequirePropertyPath(),
            'noPropertyPathMessage' => [
                'message' => $this->getNoPropertyPathMessage(),
            ],
            'skipOnEmpty' => $this->getSkipOnEmptyOption(),
            'skipOnError' => $this->skipOnError,
            'rules' => $this->rules === null ? null : (new RulesDumper())->asArray($this->rules),
        ];
    }

    public function getHandlerClassName(): string
    {
        return NestedHandler::class;
    }
}