Yiisoft\Validator\Rule\Nested\Nested

Complexity

Total Complexity

8

Size/Duplication

Total Lines	46
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	checkRules()	0	8	3
A	__construct()	0	22	4
A	getOptions()	0	5	1

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule\Nested;

use Attribute;
use Closure;
use InvalidArgumentException;
use Traversable;
use Yiisoft\Validator\Rule\RuleNameTrait;
use Yiisoft\Validator\Rule\HandlerClassNameTrait;
use Yiisoft\Validator\RuleInterface;
use Yiisoft\Validator\RulesDumper;
use function is_array;

/**
 * Can be used for validation of nested structures.
 *
 * For example, we have an inbound request with the following structure:
 *
 * ```php
 * $request = [
 *     'author' => [
 *         'name' => 'Dmitry',
 *         'age' => 18,
 *     ],
 * ];
 * ```
 *
 * So to make validation we can configure it like this:
 *
 * ```php
 * $rule = new Nested([
 *     'author' => new Nested([
 *         'name' => [new HasLength(min: 3)],
 *         'age' => [new Number(min: 18)],
 *     )];
 * ]);
 * ```
 */
#[Attribute(Attribute::TARGET_PROPERTY)]
final class Nested implements RuleInterface
{
    use HandlerClassNameTrait;
    use RuleNameTrait;

    public function __construct(
        /**
         * @var RuleInterface[][]
         */
        public iterable $rules = [],
        public bool $errorWhenPropertyPathIsNotFound = false,
        public string $propertyPathIsNotFoundMessage = 'Property path "{path}" is not found.',
        public bool $skipOnEmpty = false,
        public bool $skipOnError = false,
        public ?Closure $when = null,
    ) {
        $rules = $rules instanceof Traversable ? iterator_to_array($rules) : $rules;
        if (empty($rules)) {
            throw new InvalidArgumentException('Rules must not be empty.');
        }

        if ($this->checkRules($rules)) {

It seems like $rules can also be of type iterable; however, parameter $rules of Yiisoft\Validator\Rule\Nested\Nested::checkRules() does only seem to accept array, maybe add an additional type check?

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

        $this->rules = $rules;
    }

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

    public function getOptions(): array
    {
        $dumper = new RulesDumper();

        return $dumper->asArray($this->rules, false);
    }
}