Yiisoft\Definitions\Helpers\DefinitionValidator::validateArrayDefinition()

Complexity

Conditions	22
Paths	153

Size

Total Lines	125
Code Lines	79

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	44
CRAP Score	22

Importance

Changes	2
Bugs	0	Features	0

<?php
    public static function validateArrayDefinition(array $definition, ?string $id = null): void
    {
        /** @var class-string $className */
        $className = $definition[ArrayDefinition::CLASS_NAME] ?? $id ?? throw new InvalidConfigException(
            'Invalid definition: no class name specified.'
        );
        self::validateClassName($className);
        $classReflection = new ReflectionClass($className);
        $classPublicMethods = [];
        foreach ($classReflection->getMethods() as $reflectionMethod) {
            if ($reflectionMethod->getModifiers() & ReflectionMethod::IS_PUBLIC) {
                $classPublicMethods[] = $reflectionMethod->getName();
            }
        }
        $classPublicProperties = [];
        foreach ($classReflection->getProperties(ReflectionProperty::IS_PUBLIC) as $reflectionProperty) {
            if ($reflectionProperty->getModifiers() & ReflectionProperty::IS_PUBLIC) {
                $classPublicProperties[] = $reflectionProperty->getName();
            }
        }

        foreach ($definition as $key => $value) {
            if (!is_string($key)) {
                throw new InvalidConfigException(
                    sprintf(
                        'Invalid definition: invalid key in array definition. Allow only string keys, got %d.',
                        $key,
                    ),
                );
            }

            // Class
            if ($key === ArrayDefinition::CLASS_NAME) {
                continue;
            }

            // Constructor arguments
            if ($key === ArrayDefinition::CONSTRUCTOR) {
                if (!is_array($value)) {
                    throw new InvalidConfigException(
                        sprintf(
                            'Invalid definition: incorrect constructor arguments. Expected array, got %s.',
                            get_debug_type($value)
                        )
                    );
                }
                /** @var mixed $argument */
                foreach ($value as $argument) {
                    if (is_object($argument) && !self::isValidObject($argument)) {
                        throw new InvalidConfigException(
                            'Only references are allowed in constructor arguments, a definition object was provided: ' .
                            var_export($argument, true)
                        );
                    }
                }
                continue;
            }

            // Methods and properties
            if (str_ends_with($key, '()')) {
                $parsedKey = mb_substr($key, 0, -2);
                if (!$classReflection->hasMethod($parsedKey)) {
                    $possiblePropertiesMessage = $classPublicMethods === []
                        ? 'No public methods available to call.'
                        : sprintf(
                            'Possible methods to call: %s',
                            '"' . implode('", "', $classPublicMethods) . '"',
                        );
                    throw new InvalidConfigException(
                        sprintf(
                            'Invalid definition: class "%s" does not have the public method with name "%s". ' . $possiblePropertiesMessage,
                            $className,
                            $parsedKey,
                        )
                    );
                }
                if (!in_array($parsedKey, $classPublicMethods, true)) {
                    throw new InvalidConfigException(
                        sprintf(
                            'Invalid definition: method "%s" must be public.' .
                            $className . '::' . $key,
                        )
                    );
                }
                if (!is_array($value)) {
                    throw new InvalidConfigException(
                        sprintf(
                            'Invalid definition: incorrect method "%s" arguments. Expected array, got "%s". ' .
                            'Probably you should wrap them into square brackets.',
                            $key,
                            get_debug_type($value),
                        )
                    );
                }
                continue;
            }
            if (str_starts_with($key, '$')) {
                $parsedKey = mb_substr($key, 1);
                if (!$classReflection->hasProperty($parsedKey)) {
                    if ($classPublicProperties === []) {
                        $message = sprintf(
                            'Invalid definition: class "%s" does not have any public properties.',
                            $className,
                        );
                    } else {
                        $message = sprintf(
                            'Invalid definition: class "%s" does not have the public property with name "%s". Possible properties to set: %s.',
                            $className,
                            $parsedKey,
                            '"' . implode('", "', $classPublicProperties) . '"',
                        );
                    }
                    throw new InvalidConfigException($message);
                } elseif (!in_array($parsedKey, $classPublicProperties, true)) {
                    throw new InvalidConfigException(
                        sprintf(
                            'Invalid definition: property "%s" must be public.',
                            $className . '::' . $key,
                        )
                    );
                }
                continue;
            }

            self::throwInvalidArrayDefinitionKey($key);
        }