|
1
|
|
|
<?php |
|
2
|
|
|
declare(strict_types = 1); |
|
3
|
|
|
|
|
4
|
|
|
namespace Innmind\Reflection; |
|
5
|
|
|
|
|
6
|
|
|
use Innmind\Reflection\Exception\InvalidArgumentException; |
|
7
|
|
|
use Innmind\Reflection\Exception\LogicException; |
|
8
|
|
|
use Innmind\Reflection\InjectionStrategy\SetterStrategy; |
|
9
|
|
|
use Innmind\Reflection\InjectionStrategy\NamedMethodStrategy; |
|
10
|
|
|
use Innmind\Reflection\InjectionStrategy\ReflectionStrategy; |
|
11
|
|
|
use Innmind\Immutable\Collection; |
|
12
|
|
|
use Innmind\Immutable\CollectionInterface; |
|
13
|
|
|
use Innmind\Immutable\TypedCollection; |
|
14
|
|
|
use Innmind\Immutable\TypedCollectionInterface; |
|
15
|
|
|
|
|
16
|
|
|
class ReflectionObject |
|
17
|
|
|
{ |
|
18
|
|
|
private $object; |
|
19
|
|
|
private $properties; |
|
20
|
|
|
private $injectionStrategies; |
|
21
|
|
|
|
|
22
|
10 |
|
public function __construct( |
|
23
|
|
|
$object, |
|
24
|
|
|
CollectionInterface $properties = null, |
|
25
|
|
|
TypedCollectionInterface $injectionStrategies = null |
|
26
|
|
|
) { |
|
27
|
10 |
|
if (!is_object($object)) { |
|
28
|
1 |
|
throw new InvalidArgumentException; |
|
29
|
|
|
} |
|
30
|
|
|
|
|
31
|
9 |
|
$this->object = $object; |
|
32
|
|
|
|
|
33
|
9 |
|
$this->properties = $properties ?? new Collection([]); |
|
34
|
9 |
|
$this->initInjectionStrategies($injectionStrategies); |
|
35
|
9 |
|
} |
|
36
|
|
|
|
|
37
|
|
|
/** |
|
38
|
|
|
* Add a property that will be injected |
|
39
|
|
|
* |
|
40
|
|
|
* @param string $name |
|
41
|
|
|
* @param mixed $value |
|
42
|
|
|
* |
|
43
|
|
|
* @return self |
|
44
|
|
|
*/ |
|
45
|
4 |
|
public function withProperty(string $name, $value) |
|
46
|
|
|
{ |
|
47
|
4 |
|
return new self( |
|
48
|
4 |
|
$this->object, |
|
49
|
4 |
|
$this->properties->set($name, $value), |
|
50
|
4 |
|
$this->injectionStrategies |
|
51
|
|
|
); |
|
52
|
|
|
} |
|
53
|
|
|
|
|
54
|
|
|
/** |
|
55
|
|
|
* Add a set of properties that need to be injected |
|
56
|
|
|
* |
|
57
|
|
|
* @param array $properties |
|
58
|
|
|
* |
|
59
|
|
|
* @return self |
|
60
|
|
|
*/ |
|
61
|
1 |
|
public function withProperties(array $properties): self |
|
62
|
|
|
{ |
|
63
|
1 |
|
return new self( |
|
64
|
1 |
|
$this->object, |
|
65
|
1 |
|
$this->properties->merge(new Collection($properties)), |
|
66
|
1 |
|
$this->injectionStrategies |
|
67
|
|
|
); |
|
68
|
|
|
} |
|
69
|
|
|
|
|
70
|
|
|
/** |
|
71
|
|
|
* Return the collection of properties that will be injected in the object |
|
72
|
|
|
* |
|
73
|
|
|
* @return CollectionInterface |
|
74
|
|
|
*/ |
|
75
|
2 |
|
public function getProperties(): CollectionInterface |
|
76
|
|
|
{ |
|
77
|
2 |
|
return $this->properties; |
|
78
|
|
|
} |
|
79
|
|
|
|
|
80
|
|
|
/** |
|
81
|
|
|
* Return the list of injection strategies used |
|
82
|
|
|
* |
|
83
|
|
|
* @return TypedCollectionInterface |
|
84
|
|
|
*/ |
|
85
|
1 |
|
public function getInjectionStrategies(): TypedCollectionInterface |
|
86
|
|
|
{ |
|
87
|
1 |
|
return $this->injectionStrategies; |
|
88
|
|
|
} |
|
89
|
|
|
|
|
90
|
|
|
/** |
|
91
|
|
|
* Return the object with the list of properties set on it |
|
92
|
|
|
* |
|
93
|
|
|
* @return object |
|
94
|
|
|
*/ |
|
95
|
7 |
|
public function buildObject() |
|
96
|
|
|
{ |
|
97
|
7 |
|
foreach ($this->properties as $key => $value) { |
|
98
|
5 |
|
$this->inject($key, $value); |
|
99
|
|
|
} |
|
100
|
|
|
|
|
101
|
5 |
|
return $this->object; |
|
102
|
|
|
} |
|
103
|
|
|
|
|
104
|
|
|
/** |
|
105
|
|
|
* Inject the given key/value pair into the object |
|
106
|
|
|
* |
|
107
|
|
|
* @param string $key |
|
108
|
|
|
* @param mixed $value |
|
109
|
|
|
* |
|
110
|
|
|
* @return void |
|
111
|
|
|
*/ |
|
112
|
5 |
|
private function inject(string $key, $value) |
|
113
|
|
|
{ |
|
114
|
5 |
|
foreach ($this->injectionStrategies as $strategy) { |
|
115
|
5 |
|
if ($strategy->supports($this->object, $key, $value)) { |
|
116
|
3 |
|
$strategy->inject($this->object, $key, $value); |
|
117
|
|
|
|
|
118
|
5 |
|
return; |
|
119
|
|
|
} |
|
120
|
|
|
} |
|
121
|
|
|
|
|
122
|
2 |
|
throw new LogicException(sprintf( |
|
123
|
2 |
|
'Property "%s" cannot be injected', |
|
124
|
|
|
$key |
|
125
|
|
|
)); |
|
126
|
|
|
} |
|
127
|
|
|
|
|
128
|
|
|
/** |
|
129
|
|
|
* @param TypedCollectionInterface $strategies |
|
130
|
|
|
* |
|
131
|
|
|
* @return void |
|
132
|
|
|
*/ |
|
133
|
9 |
View Code Duplication |
private function initInjectionStrategies(TypedCollectionInterface $strategies = null) |
|
|
|
|
|
|
134
|
|
|
{ |
|
135
|
9 |
|
$strategies = $strategies ?? new TypedCollection( |
|
136
|
7 |
|
InjectionStrategyInterface::class, |
|
137
|
|
|
[ |
|
138
|
7 |
|
new SetterStrategy, |
|
139
|
7 |
|
new NamedMethodStrategy, |
|
140
|
9 |
|
new ReflectionStrategy, |
|
141
|
|
|
] |
|
142
|
|
|
); |
|
143
|
|
|
|
|
144
|
9 |
|
if ($strategies->getType() !== InjectionStrategyInterface::class) { |
|
145
|
|
|
throw new InvalidArgumentException; |
|
146
|
|
|
} |
|
147
|
|
|
|
|
148
|
9 |
|
$this->injectionStrategies = $strategies; |
|
149
|
9 |
|
} |
|
150
|
|
|
} |
|
151
|
|
|
|
Innmind /
Reflection
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.