Yiisoft\Validator\Rule\NestedHandler::validate()

Complexity

Conditions	20
Paths	95

Size

Total Lines	103
Code Lines	57

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	49
CRAP Score	20.024

Importance

Changes	7
Bugs	1	Features	0

<?php
    public function validate(mixed $value, object $rule, ValidationContext $context): Result
    {
        if (!$rule instanceof Nested) {
            throw new UnexpectedRuleException(Nested::class, $rule);
        }

        if ($rule->getRules() === null) {
            if (!is_object($value)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'Nested rule without rules could be used for objects only. %s given.',
                        get_debug_type($value)
                    )
                );
            }

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

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

        if (is_array($value)) {
            $data = $value;
        } elseif (is_object($value)) {
            /** @var mixed $data */
            $data = (new ObjectDataSet($value, $rule->getPropertyVisibility()))->getData();
            if (!is_array($data) && !is_object($data)) {
                $message = sprintf(
                    'An object set data can only have an array or an object type. %s given',
                    get_debug_type($data),
                );

                throw new InvalidArgumentException($message);
            }
        } else {
            return (new Result())->addError(
                'Value should be an array or an object. {valueType} given.',
                [
                    'attribute' => $context->getAttribute(),
                    'valueType' => get_debug_type($value),
                ],
            );
        }

        $compoundResult = new Result();
        $results = [];
        /** @var int|string $valuePath */
        foreach ($rule->getRules() as $valuePath => $rules) {
            if (is_array($data) && $rule->getRequirePropertyPath() && !ArrayHelper::pathExists($data, $valuePath)) {
                if (is_int($valuePath)) {
                    $valuePathList = [$valuePath];
                } else {
                    /** @var list<string> $valuePathList */
                    $valuePathList = StringHelper::parsePath($valuePath);
                }

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

                continue;
            }

            /** @var mixed $validatedValue */
            $validatedValue = ArrayHelper::getValueByPath($data, $valuePath);
            $rules = is_iterable($rules) ? $rules : [$rules];

            $itemResult = $context->getValidator()->validate($validatedValue, $rules);

            if ($itemResult->isValid()) {
                continue;
            }

            $result = new Result();
            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?

                }

                $result->addError($error->getMessage(), $error->getParameters(), $valuePathList);
            }
            $results[] = $result;
        }

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

        return $compoundResult;
    }