Yiisoft\Validator\Rule\NestedHandler

Complexity

Total Complexity

21

Size/Duplication

Total Lines	118
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	prepareRules()	0	20	6
C	validate()	0	89	15

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Yiisoft\Arrays\ArrayHelper;
use Yiisoft\Strings\StringHelper;
use Yiisoft\Validator\DataSet\ObjectDataSet;
use Yiisoft\Validator\Exception\UnexpectedRuleException;
use Yiisoft\Validator\Result;
use Yiisoft\Validator\RuleHandlerInterface;
use Yiisoft\Validator\RuleInterface;
use Yiisoft\Validator\ValidationContext;

use function is_array;
use function is_int;
use function is_object;

/**
 * A handler for {@see Nested} rule. Validates nested structures.
 */
final class NestedHandler implements RuleHandlerInterface
{
    public function validate(mixed $value, object $rule, ValidationContext $context): Result
    {
        if (!$rule instanceof Nested) {
            throw new UnexpectedRuleException(Nested::class, $rule);
        }

        /** @var mixed $value */
        $value = $context->getParameter(ValidationContext::PARAMETER_VALUE_AS_ARRAY) ?? $value;

        if ($rule->getRules() === null) {
            if (!is_object($value)) {
                return (new Result())->addError($rule->getNoRulesWithNoObjectMessage(), [
                    'attribute' => $context->getTranslatedAttribute(),
                    'type' => get_debug_type($value),
                ]);
            }

            $dataSet = new ObjectDataSet($value, $rule->getValidatedObjectPropertyVisibility());

            return $context->validate($dataSet);
        }

        if (is_array($value)) {
            $data = $value;
        } elseif (is_object($value)) {
            $data = (new ObjectDataSet($value, $rule->getValidatedObjectPropertyVisibility()))->getData();
            if ($data === null) {
                return (new Result())->addError($rule->getIncorrectDataSetTypeMessage(), [
                    'type' => get_debug_type($data),
                ]);
            }
        } else {
            return (new Result())->addError($rule->getIncorrectInputMessage(), [
                'attribute' => $context->getTranslatedAttribute(),
                'type' => get_debug_type($value),
            ]);
        }

        $preparedRules = [];
        $this->prepareRules($rule->getRules(), $preparedRules);

        $compoundResult = new Result();

        foreach ($preparedRules as $valuePath => $rules) {
            if ($rule->isPropertyPathRequired() && !ArrayHelper::pathExists($data, $valuePath)) {

It seems like $data can also be of type null; however, parameter $array of Yiisoft\Arrays\ArrayHelper::pathExists() does only seem to accept array, maybe add an additional type check?

                if (is_int($valuePath)) {
                    $valuePathList = [$valuePath];
                } else {
                    /** @var list<string> $valuePathList */
                    $valuePathList = StringHelper::parsePath($valuePath);
                }

                $compoundResult->addError(
                    $rule->getNoPropertyPathMessage(),
                    [
                        'path' => $valuePath,
                        'attribute' => $context->getTranslatedAttribute(),
                    ],
                    $valuePathList,
                );

                continue;
            }

            /** @var mixed $validatedValue */
            $validatedValue = ArrayHelper::getValueByPath($data, $valuePath);

It seems like $data can also be of type null; however, parameter $array of Yiisoft\Arrays\ArrayHelper::getValueByPath() does only seem to accept array|object, maybe add an additional type check?

            $itemResult = $context->validate($validatedValue, $rules);
            if ($itemResult->isValid()) {
                continue;
            }

            foreach ($itemResult->getErrors() as $error) {
                if (is_int($valuePath)) {
                    $valuePathList = [$valuePath];
                } else {
                    /** @var list<string> $valuePathList */
                    $valuePathList = StringHelper::parsePath($valuePath);
                }

                if (!empty($valuePathList)) {
                    array_push($valuePathList, ...$error->getValuePath());

It seems like $valuePathList can also be of type Yiisoft\Validator\Rule\list; however, parameter $array of array_push() does only seem to accept array, maybe add an additional type check?

                }

                $compoundResult->addError($error->getMessage(), $error->getParameters(), $valuePathList);
            }
        }

        return $compoundResult;
    }

    /**
     * @psalm-param iterable<iterable<RuleInterface>|RuleInterface> $rawRules
     *
     * @param RuleInterface[] $result
     */
    public function prepareRules(iterable $rawRules, array &$result, ?string $baseValuePath = null): void
    {
        /** @var int|string $valuePath */
        foreach ($rawRules as $valuePath => $rules) {
            if (is_int($valuePath)) {
                $key = $baseValuePath;
            } else {
                $key = ($baseValuePath !== null ? $baseValuePath . '.' : '') . $valuePath;
            }

            if (is_iterable($rules)) {
                $this->prepareRules($rules, $result, $key);
                continue;
            }

            if ($key === null) {
                $result[] = $rules;
            } else {
                /** @psalm-suppress UndefinedInterfaceMethod */
                $result[$key][] = $rules;
            }
        }
    }
}