generated from yiisoft/package-template
/
Normalizer.php
97 lines (84 loc) · 3.26 KB
/
Normalizer.php
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
<?php
declare(strict_types=1);
namespace Yiisoft\Definitions\Helpers;
use Yiisoft\Definitions\ArrayDefinition;
use Yiisoft\Definitions\CallableDefinition;
use Yiisoft\Definitions\Contract\DefinitionInterface;
use Yiisoft\Definitions\Contract\ReferenceInterface;
use Yiisoft\Definitions\Exception\InvalidConfigException;
use Yiisoft\Definitions\Reference;
use Yiisoft\Definitions\ValueDefinition;
use function array_key_exists;
use function is_array;
use function is_callable;
use function is_object;
use function is_string;
/**
* Normalizer definition from configuration to an instance of {@see DefinitionInterface}.
*
* @psalm-import-type ArrayDefinitionConfig from ArrayDefinition
*/
final class Normalizer
{
/**
* 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 ReferenceInterface},
* - callable,
* - array,
* - ready object.
*
* @param mixed $definition The definition for normalization.
* @param string $class 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.
*
* @throws InvalidConfigException If configuration is not valid.
*
* @return DefinitionInterface Normalized definition as an object.
*/
public static function normalize($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));
}
}