Passed
Pull Request — master (#86)
by Dmitriy
02:22
created

DefinitionResolver::resolveArray()   A

Complexity

Conditions 4
Paths 3

Size

Total Lines 14
Code Lines 6

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 7
CRAP Score 4

Importance

Changes 0
Metric Value
eloc 6
dl 0
loc 14
ccs 7
cts 7
cp 1
rs 10
c 0
b 0
f 0
cc 4
nc 3
nop 2
crap 4
1
<?php
2
3
declare(strict_types=1);
4
5
namespace Yiisoft\Factory\Definition;
6
7
use Psr\Container\ContainerInterface;
8
use Yiisoft\Factory\Exception\InvalidConfigException;
9
10
use function is_array;
11
use function is_callable;
12
use function is_string;
13
14
class DefinitionResolver
15
{
16
    /**
17
     * Resolves dependencies by replacing them with the actual object instances.
18
     *
19
     * @param array<string,mixed> $dependencies The dependencies.
20
     *
21
     * @return array The resolved dependencies.
22
     * @psalm-return array<string,mixed>
23
     */
24 38
    public static function resolveArray(ContainerInterface $container, array $dependencies): array
25
    {
26 38
        $result = [];
27
        /** @var mixed $definition */
28 38
        foreach ($dependencies as $key => $definition) {
29 38
            if ($definition instanceof ParameterDefinition && !$definition->hasValue()) {
30 16
                continue;
31
            }
32
33
            /** @var mixed */
34 38
            $result[$key] = self::resolve($container, $definition);
35
        }
36
37 36
        return $result;
38
    }
39
40
    /**
41
     * This function resolves a definition recursively, checking for loops.
42
     *
43
     * @param mixed $definition
44
     *
45
     * @return mixed
46
     */
47 38
    public static function resolve(ContainerInterface $container, $definition)
48
    {
49 38
        if ($definition instanceof DefinitionInterface) {
50
            /** @var mixed $definition */
51 36
            $definition = $definition->resolve($container);
52 13
        } elseif (is_array($definition)) {
53
            /** @psalm-var array<string,mixed> $definition */
54 11
            return self::resolveArray($container, $definition);
55
        }
56
57 36
        return $definition;
58
    }
59
60
    /**
61
     * @param mixed $value
62
     *
63
     * @return array|CallableDefinition|DefinitionInterface|ValueDefinition
64
     */
65 10
    public static function ensureResolvable($value)
66
    {
67 10
        if ($value instanceof ReferenceInterface || is_array($value)) {
68 1
            return $value;
69
        }
70
71 9
        if ($value instanceof DefinitionInterface) {
72
            throw new InvalidConfigException('Only references are allowed in parameters, a definition object was provided: ' . var_export($value, true));
73
        }
74
75 9
        return new ValueDefinition($value);
76
    }
77
}
78