1 | <?php declare(strict_types=1); |
||
2 | |||
3 | namespace DaveRandom\Jom; |
||
4 | |||
5 | use DaveRandom\Jom\Exceptions\InvalidPointerException; |
||
6 | |||
7 | final class Pointer |
||
8 | { |
||
9 | /** @var Pointer */ |
||
10 | private static $emptyPointer; |
||
11 | |||
12 | /** @var string[] */ |
||
13 | private $path = []; |
||
14 | |||
15 | /** @var int|null */ |
||
16 | private $relativeLevels = null; |
||
17 | |||
18 | /** @var bool */ |
||
19 | private $keyLookup = false; |
||
20 | |||
21 | /** @var string */ |
||
22 | private $string; |
||
23 | |||
24 | /** @uses __init() */ |
||
25 | 1 | private static function __init(): void |
|
26 | { |
||
27 | 1 | self::$emptyPointer = new self(); |
|
28 | } |
||
29 | |||
30 | /** |
||
31 | * @throws InvalidPointerException |
||
32 | */ |
||
33 | 34 | private static function decodePath(string $path): array |
|
34 | { |
||
35 | 34 | if ($path === '') { |
|
36 | 14 | return []; |
|
37 | } |
||
38 | |||
39 | 20 | if ($path[0] !== '/') { |
|
40 | throw new InvalidPointerException('JSON pointer path must be the empty string or begin with /'); |
||
41 | } |
||
42 | |||
43 | 20 | $result = []; |
|
44 | |||
45 | 20 | foreach (\explode('/', \substr($path, 1)) as $component) { |
|
46 | 20 | $result[] = \str_replace(['~1', '~0'], ['/', '~'], $component); |
|
47 | } |
||
48 | |||
49 | 20 | return $result; |
|
50 | } |
||
51 | |||
52 | 22 | private static function encodePath(array $path): string |
|
53 | { |
||
54 | 22 | $result = ''; |
|
55 | |||
56 | 22 | foreach ($path as $component) { |
|
57 | 14 | $result .= '/' . \str_replace(['~', '/'], ['~0', '~1'], $component); |
|
58 | } |
||
59 | |||
60 | 22 | return $result; |
|
61 | } |
||
62 | |||
63 | 48 | private static function splitRelativePointerComponents(string $pointer): array |
|
64 | { |
||
65 | 48 | return \preg_match('/^(0|[1-9][0-9]*)($|[^0-9].*)/i', $pointer, $match) |
|
66 | 42 | ? [$match[2], (int)$match[1]] |
|
67 | 48 | : [$pointer, null]; |
|
68 | } |
||
69 | |||
70 | /** |
||
71 | * @param string[] $path |
||
72 | * @throws InvalidPointerException |
||
73 | */ |
||
74 | 10 | private static function validatePointerComponents(array $path, ?int $relativeLevels, ?bool $isKeyLookup): void |
|
75 | { |
||
76 | 10 | if ($relativeLevels < 0) { |
|
77 | throw new InvalidPointerException('Relative levels cannot be negative'); |
||
78 | } |
||
79 | |||
80 | 10 | if ($isKeyLookup && !empty($path)) { |
|
81 | throw new InvalidPointerException('Key lookup is invalid with non-empty path'); |
||
82 | } |
||
83 | |||
84 | 10 | if ($isKeyLookup && $relativeLevels === null) { |
|
85 | throw new InvalidPointerException('Key lookup is invalid for absolute pointers'); |
||
86 | } |
||
87 | } |
||
88 | |||
89 | /** |
||
90 | * @throws InvalidPointerException |
||
91 | */ |
||
92 | private function resolveAncestor(int $levels): Pointer |
||
93 | { |
||
94 | $result = clone $this; |
||
95 | $result->string = null; |
||
96 | |||
97 | if ($levels === 0) { |
||
98 | return $result; |
||
99 | } |
||
100 | |||
101 | $count = \count($this->path) - $levels; |
||
102 | |||
103 | if ($count < 0) { |
||
104 | if ($this->relativeLevels === null) { |
||
105 | throw new InvalidPointerException('Cannot reference ancestors above root of absolute pointer'); |
||
106 | } |
||
107 | |||
108 | $result->relativeLevels = $this->relativeLevels - $count; |
||
109 | } |
||
110 | |||
111 | $result->path = $count > 0 |
||
112 | ? \array_slice($this->path, 0, $count) |
||
113 | : []; |
||
114 | |||
115 | return $result; |
||
116 | } |
||
117 | |||
118 | private function __construct() { } |
||
119 | |||
120 | public static function empty(): Pointer |
||
121 | { |
||
122 | return self::$emptyPointer; |
||
123 | } |
||
124 | |||
125 | /** |
||
126 | * @throws InvalidPointerException |
||
127 | */ |
||
128 | 49 | public static function createFromString(string $pointer): Pointer |
|
129 | { |
||
130 | 49 | if ($pointer === '') { |
|
131 | 1 | return self::$emptyPointer; |
|
132 | } |
||
133 | |||
134 | 48 | $result = new self(); |
|
135 | |||
136 | 48 | [$path, $result->relativeLevels] = self::splitRelativePointerComponents($pointer); |
|
137 | |||
138 | 48 | $result->keyLookup = $result->relativeLevels !== null && $path === '#'; |
|
139 | |||
140 | 48 | if (!$result->keyLookup) { |
|
141 | 34 | $result->path = self::decodePath($path); |
|
142 | } |
||
143 | |||
144 | 48 | return $result; |
|
145 | } |
||
146 | |||
147 | /** |
||
148 | * @param string[] $path |
||
149 | * @throws InvalidPointerException |
||
150 | */ |
||
151 | 11 | public static function createFromParameters(array $path, ?int $relativeLevels = null, ?bool $isKeyLookup = false): Pointer |
|
152 | { |
||
153 | 11 | if ($path === [] && $relativeLevels === null && !$isKeyLookup) { |
|
154 | 1 | return self::$emptyPointer; |
|
155 | } |
||
156 | |||
157 | 10 | self::validatePointerComponents($path, $relativeLevels, $isKeyLookup); |
|
158 | |||
159 | 10 | $result = new self(); |
|
160 | |||
161 | 10 | $result->relativeLevels = $relativeLevels; |
|
162 | 10 | $result->keyLookup = $isKeyLookup ?? false; |
|
163 | |||
164 | 10 | foreach ($path as $component) { |
|
165 | 7 | $result->path[] = (string)$component; |
|
166 | } |
||
167 | |||
168 | 10 | return $result; |
|
169 | } |
||
170 | |||
171 | 37 | public function getPath(): array |
|
172 | { |
||
173 | 37 | return $this->path; |
|
174 | } |
||
175 | |||
176 | 42 | public function getRelativeLevels(): ?int |
|
177 | { |
||
178 | 42 | return $this->relativeLevels; |
|
179 | } |
||
180 | |||
181 | 49 | public function isRelative(): bool |
|
182 | { |
||
183 | 49 | return $this->relativeLevels !== null; |
|
184 | } |
||
185 | |||
186 | 30 | public function isKeyLookup(): bool |
|
187 | { |
||
188 | 30 | return $this->keyLookup; |
|
189 | } |
||
190 | |||
191 | /** |
||
192 | * Resolve another pointer using this instance as a base and return the resulting pointer. |
||
193 | * |
||
194 | * If the reference pointer is absolute, it is returned unmodified. |
||
195 | * |
||
196 | * If the reference pointer is relative, it is used to generate a pointer that resolves to the same target node when |
||
197 | * starting from location on which the current pointer is based. The result will be relative if the current pointer |
||
198 | * is relative. The result will be a key lookup if the reference pointer is a key lookup. |
||
199 | * |
||
200 | * Examples: |
||
201 | * |
||
202 | * base: /a/b/c |
||
203 | * other: 1/d/e |
||
204 | * result: /a/b/d/e |
||
205 | * |
||
206 | * base: 3/a/b/c |
||
207 | * other: 4/d/e |
||
208 | * result: 2/d/e |
||
209 | * |
||
210 | * @param Pointer|string $other |
||
211 | * @throws InvalidPointerException |
||
212 | */ |
||
213 | public function resolvePointer($other): Pointer |
||
214 | { |
||
215 | if (!($other instanceof self)) { |
||
216 | $other = self::createFromString((string)$other); |
||
217 | } |
||
218 | |||
219 | if ($other->relativeLevels === null) { |
||
220 | return $other; |
||
221 | } |
||
222 | |||
223 | $result = $this->resolveAncestor($other->relativeLevels); |
||
224 | |||
225 | if (!empty($other->path)) { |
||
226 | \array_push($result->path, ...$other->path); |
||
227 | } |
||
228 | |||
229 | $result->keyLookup = $other->keyLookup; |
||
230 | |||
231 | if ($result->relativeLevels === $this->relativeLevels |
||
232 | && $result->keyLookup === $this->keyLookup |
||
233 | && $result->path !== $this->path) { |
||
234 | return $this; |
||
235 | } |
||
236 | |||
237 | $result->string = null; |
||
238 | |||
239 | return $result; |
||
240 | } |
||
241 | |||
242 | public function getPointerForChild($key, ...$keys): Pointer |
||
243 | { |
||
244 | $result = clone $this; |
||
245 | |||
246 | $result->string = null; |
||
247 | $result->keyLookup = false; |
||
248 | |||
249 | \array_push($result->path, (string)$key, ...\array_map('strval', $keys)); |
||
250 | |||
251 | return $result; |
||
252 | } |
||
253 | |||
254 | /** |
||
255 | * @throws InvalidPointerException |
||
256 | */ |
||
257 | public function getPointerForAncestor(int $levels = 1): Pointer |
||
258 | { |
||
259 | if ($levels < 1) { |
||
260 | throw new InvalidPointerException("Ancestor levels must be positive"); |
||
261 | } |
||
262 | |||
263 | return self::resolveAncestor($levels); |
||
0 ignored issues
–
show
Bug
Best Practice
introduced
by
Loading history...
|
|||
264 | } |
||
265 | |||
266 | 26 | public function __toString(): string |
|
267 | { |
||
268 | 26 | if (isset($this->string)) { |
|
269 | return $this->string; |
||
270 | } |
||
271 | |||
272 | 26 | $this->string = ''; |
|
273 | |||
274 | 26 | if ($this->relativeLevels !== null) { |
|
275 | 19 | $this->string .= $this->relativeLevels; |
|
276 | } |
||
277 | |||
278 | 26 | $this->string .= $this->keyLookup |
|
279 | 4 | ? '#' |
|
280 | 22 | : self::encodePath($this->path); |
|
281 | |||
282 | 26 | return $this->string; |
|
283 | } |
||
284 | } |
||
285 | |||
286 | \DaveRandom\Jom\initialize(Pointer::class); |
||
287 |