0 follower

Final Class Yiisoft\Definitions\Helpers\Normalizer

All Classes | Methods

Inheritance	Yiisoft\Definitions\Helpers\Normalizer

Normalizer definition from configuration to an instance of {@see DefinitionInterface}.

Public Methods

Hide inherited methods

Method	Description	Defined By
normalize()	Normalize definition to an instance of {@see DefinitionInterface}.	Yiisoft\Definitions\Helpers\Normalizer

Method Details

Hide inherited methods

normalize() public static method

Normalize definition to an instance of {@see DefinitionInterface}.

Definition may be defined multiple ways:

class name,
string as reference to another class or alias,
instance of {@see \Yiisoft\Definitions\Contract\ReferenceInterface},
callable,
array,
ready object.

public static Yiisoft\Definitions\Contract\DefinitionInterface normalize ( mixed $definition, string\|null $class = null )
$definition	mixed	The definition for normalization.
$class	string\|null	The class name of the object to be defined (optional). It is used in two cases. The definition is a string, and class name equals to definition. Returned `ArrayDefinition` with defined class. The definition is an array without class name. Class name will be added to array and `ArrayDefinition` will be returned.
return	Yiisoft\Definitions\Contract\DefinitionInterface	Normalized definition as an object.
throws	Yiisoft\Definitions\Exception\InvalidConfigException	If configuration is not valid.

Source code

                public static function normalize(mixed $definition, ?string $class = null): DefinitionInterface
{
    // Reference
    if ($definition instanceof ReferenceInterface) {
        return $definition;
    }
    if (is_string($definition)) {
        // Current class
        if (
            $class === $definition ||
            ($class === null && class_exists($definition))
        ) {
            /** @psalm-var class-string $definition */
            return ArrayDefinition::fromPreparedData($definition);
        }
        // Reference to another class or alias
        return Reference::to($definition);
    }
    // Callable definition
    if (is_callable($definition, true)) {
        return new CallableDefinition($definition);
    }
    // Array definition
    if (is_array($definition)) {
        $config = $definition;
        if (!array_key_exists(ArrayDefinition::CLASS_NAME, $config)) {
            if ($class === null) {
                throw new InvalidConfigException(
                    'Array definition should contain the key "class": ' . var_export($definition, true),
                );
            }
            $config[ArrayDefinition::CLASS_NAME] = $class;
        }
        /** @psalm-var ArrayDefinitionConfig $config */
        return ArrayDefinition::fromConfig($config);
    }
    // Ready object
    if (is_object($definition) && !($definition instanceof DefinitionInterface)) {
        return new ValueDefinition($definition);
    }
    throw new InvalidConfigException('Invalid definition: ' . var_export($definition, true));
}