1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
/** |
4
|
|
|
* micrometa |
5
|
|
|
* |
6
|
|
|
* @category Jkphl |
7
|
|
|
* @package Jkphl\Micrometa |
8
|
|
|
* @subpackage Jkphl\Micrometa\Infrastructure\Parser |
9
|
|
|
* @author Joschi Kuphal <[email protected]> / @jkphl |
10
|
|
|
* @copyright Copyright © 2017 Joschi Kuphal <[email protected]> / @jkphl |
11
|
|
|
* @license http://opensource.org/licenses/MIT The MIT License (MIT) |
12
|
|
|
*/ |
13
|
|
|
|
14
|
|
|
/*********************************************************************************** |
15
|
|
|
* The MIT License (MIT) |
16
|
|
|
* |
17
|
|
|
* Copyright © 2017 Joschi Kuphal <[email protected]> / @jkphl |
18
|
|
|
* |
19
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of |
20
|
|
|
* this software and associated documentation files (the "Software"), to deal in |
21
|
|
|
* the Software without restriction, including without limitation the rights to |
22
|
|
|
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of |
23
|
|
|
* the Software, and to permit persons to whom the Software is furnished to do so, |
24
|
|
|
* subject to the following conditions: |
25
|
|
|
* |
26
|
|
|
* The above copyright notice and this permission notice shall be included in all |
27
|
|
|
* copies or substantial portions of the Software. |
28
|
|
|
* |
29
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
30
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS |
31
|
|
|
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR |
32
|
|
|
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
33
|
|
|
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
34
|
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
35
|
|
|
***********************************************************************************/ |
36
|
|
|
|
37
|
|
|
namespace Jkphl\Micrometa\Infrastructure\Parser; |
38
|
|
|
|
39
|
|
|
use Jkphl\Micrometa\Application\Contract\ParsingResultInterface; |
40
|
|
|
use Jkphl\Micrometa\Infrastructure\Parser\JsonLD\CachingContextLoader; |
41
|
|
|
use Jkphl\Micrometa\Infrastructure\Parser\JsonLD\VocabularyCache; |
42
|
|
|
use Jkphl\Micrometa\Ports\Format; |
43
|
|
|
use ML\JsonLD\Exception\JsonLdException; |
44
|
|
|
use ML\JsonLD\JsonLD as JsonLDParser; |
45
|
|
|
use ML\JsonLD\LanguageTaggedString; |
46
|
|
|
use ML\JsonLD\Node; |
47
|
|
|
use ML\JsonLD\NodeInterface; |
48
|
|
|
use ML\JsonLD\TypedValue; |
49
|
|
|
use Psr\Http\Message\UriInterface; |
50
|
|
|
use Psr\Log\LoggerInterface; |
51
|
|
|
|
52
|
|
|
/** |
53
|
|
|
* JsonLD parser |
54
|
|
|
* |
55
|
|
|
* @package Jkphl\Micrometa |
56
|
|
|
* @subpackage Jkphl\Micrometa\Infrastructure |
57
|
|
|
* @see https://jsonld-examples.com/ |
58
|
|
|
* @see http://www.dr-chuck.com/csev-blog/2016/04/json-ld-performance-sucks-for-api-specs/ |
59
|
|
|
*/ |
60
|
|
|
class JsonLD extends AbstractParser |
61
|
|
|
{ |
62
|
|
|
/** |
63
|
|
|
* Format |
64
|
|
|
* |
65
|
|
|
* @var int |
66
|
|
|
*/ |
67
|
|
|
const FORMAT = Format::JSON_LD; |
68
|
|
|
/** |
69
|
|
|
* Regex pattern for matching leading comments in a JSON string |
70
|
|
|
* |
71
|
|
|
* @var string |
72
|
|
|
*/ |
73
|
|
|
const JSON_COMMENT_PATTERN = '#(/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/)|([\s\t]//.*)|(^//.*)#'; |
74
|
|
|
/** |
75
|
|
|
* Vocabulary cache |
76
|
|
|
* |
77
|
|
|
* @var VocabularyCache |
78
|
|
|
*/ |
79
|
|
|
protected $vocabularyCache; |
80
|
|
|
/** |
81
|
|
|
* Context loader |
82
|
|
|
* |
83
|
|
|
* @var CachingContextLoader |
84
|
|
|
*/ |
85
|
|
|
protected $contextLoader; |
86
|
|
|
|
87
|
|
|
/** |
88
|
|
|
* JSON-LD parser constructor |
89
|
|
|
* |
90
|
|
|
* @param UriInterface $uri Base URI |
91
|
|
|
* @param LoggerInterface $logger Logger |
92
|
|
|
*/ |
93
|
5 |
|
public function __construct(UriInterface $uri, LoggerInterface $logger) |
94
|
|
|
{ |
95
|
5 |
|
parent::__construct($uri, $logger); |
96
|
5 |
|
$this->vocabularyCache = new VocabularyCache(); |
97
|
5 |
|
$this->contextLoader = new CachingContextLoader($this->vocabularyCache); |
98
|
5 |
|
} |
99
|
|
|
|
100
|
|
|
/** |
101
|
|
|
* Parse a DOM document |
102
|
|
|
* |
103
|
|
|
* @param \DOMDocument $dom DOM Document |
104
|
|
|
* @return ParsingResultInterface Micro information items |
105
|
|
|
*/ |
106
|
4 |
|
public function parseDom(\DOMDocument $dom) |
107
|
|
|
{ |
108
|
4 |
|
$this->logger->info('Running parser: '.(new \ReflectionClass(__CLASS__))->getShortName()); |
109
|
4 |
|
$items = []; |
110
|
|
|
|
111
|
|
|
// Find and process all JSON-LD documents |
112
|
4 |
|
$xpath = new \DOMXPath($dom); |
113
|
4 |
|
$jsonLDDocs = $xpath->query('//*[local-name(.) = "script"][@type = "application/ld+json"]'); |
114
|
4 |
|
$this->logger->debug('Processing '.$jsonLDDocs->length.' JSON-LD documents'); |
115
|
|
|
|
116
|
|
|
// Run through all JSON-LD documents |
117
|
4 |
|
foreach ($jsonLDDocs as $jsonLDDoc) { |
118
|
4 |
|
$jsonLDDocSource = preg_replace(self::JSON_COMMENT_PATTERN, '', $jsonLDDoc->textContent); |
119
|
4 |
|
$i = $this->parseDocument($jsonLDDocSource); |
120
|
3 |
|
$items = array_merge($items, $i); |
121
|
3 |
|
break; |
122
|
|
|
} |
123
|
|
|
|
124
|
3 |
|
return new ParsingResult(self::FORMAT, $items); |
125
|
|
|
} |
126
|
|
|
|
127
|
|
|
/** |
128
|
|
|
* Parse a JSON-LD document |
129
|
|
|
* |
130
|
|
|
* @param string $jsonLDDocSource JSON-LD document |
131
|
|
|
* @return array Items |
132
|
|
|
*/ |
133
|
4 |
|
protected function parseDocument($jsonLDDocSource) |
134
|
|
|
{ |
135
|
|
|
// Unserialize the JSON-LD document |
136
|
4 |
|
$jsonLDDoc = @json_decode($jsonLDDocSource); |
137
|
|
|
|
138
|
|
|
// If this is not a valid JSON document: Return |
139
|
4 |
|
if (!is_object($jsonLDDoc) && !is_array($jsonLDDoc)) { |
140
|
2 |
|
$this->logger->error('Skipping invalid JSON-LD document'); |
141
|
1 |
|
return []; |
142
|
|
|
} |
143
|
|
|
|
144
|
|
|
// Parse the document |
145
|
2 |
|
return array_filter( |
146
|
2 |
|
is_array($jsonLDDoc) ? |
147
|
2 |
|
array_map([$this, 'parseRootNode'], $jsonLDDoc) : [$this->parseRootNode($jsonLDDoc)] |
148
|
|
|
); |
149
|
|
|
} |
150
|
|
|
|
151
|
|
|
/** |
152
|
|
|
* Parse a JSON-LD root node |
153
|
|
|
* |
154
|
|
|
* @param \stdClass $jsonLDRoot JSON-LD root node |
155
|
|
|
*/ |
156
|
2 |
|
protected function parseRootNode($jsonLDRoot) |
157
|
|
|
{ |
158
|
2 |
|
$item = null; |
159
|
|
|
|
160
|
|
|
try { |
161
|
2 |
|
$jsonDLDocument = JsonLDParser::getDocument($jsonLDRoot, ['documentLoader' => $this->contextLoader]); |
162
|
|
|
|
163
|
|
|
// Run through all nodes to parse the first one |
164
|
|
|
/** @var Node $node */ |
165
|
2 |
|
foreach ($jsonDLDocument->getGraph()->getNodes() as $node) { |
166
|
2 |
|
$item = $this->parseNode($node); |
167
|
2 |
|
break; |
168
|
|
|
} |
169
|
|
|
} catch (JsonLdException $exception) { |
170
|
|
|
$this->logger->error($exception->getMessage(), ['exception' => $exception]); |
171
|
|
|
} |
172
|
|
|
|
173
|
2 |
|
return $item; |
174
|
|
|
} |
175
|
|
|
|
176
|
|
|
/** |
177
|
|
|
* Parse a JSON-LD node |
178
|
|
|
* |
179
|
|
|
* @param NodeInterface $node Node |
180
|
|
|
* @return \stdClass Item |
181
|
|
|
*/ |
182
|
2 |
|
protected function parseNode(NodeInterface $node) |
183
|
|
|
{ |
184
|
|
|
return (object)[ |
185
|
2 |
|
'type' => $this->parseNodeType($node), |
186
|
2 |
|
'id' => $node->getId() ?: null, |
187
|
2 |
|
'properties' => $this->parseNodeProperties($node), |
188
|
|
|
]; |
189
|
|
|
} |
190
|
|
|
|
191
|
|
|
/** |
192
|
|
|
* Parse the type of a JSON-LD node |
193
|
|
|
* |
194
|
|
|
* @param NodeInterface $node Node |
195
|
|
|
* @return array Item type |
196
|
|
|
*/ |
197
|
2 |
|
protected function parseNodeType(NodeInterface $node) |
198
|
|
|
{ |
199
|
|
|
/** @var Node $itemType */ |
200
|
2 |
|
return ($itemType = $node->getType()) ? [$this->vocabularyCache->expandIRI($itemType->getId())] : []; |
201
|
|
|
} |
202
|
|
|
|
203
|
|
|
/** |
204
|
|
|
* Parse the properties of a JSON-LD node |
205
|
|
|
* |
206
|
|
|
* @param NodeInterface $node Node |
207
|
|
|
* @return array Item properties |
208
|
|
|
*/ |
209
|
2 |
|
protected function parseNodeProperties(NodeInterface $node) |
210
|
|
|
{ |
211
|
2 |
|
$properties = []; |
212
|
|
|
|
213
|
|
|
// Run through all node properties |
214
|
2 |
|
foreach ($node->getProperties() as $name => $property) { |
215
|
|
|
// Skip the node type |
216
|
2 |
|
if ($name === Node::TYPE) { |
217
|
2 |
|
continue; |
218
|
|
|
} |
219
|
|
|
|
220
|
|
|
// Initialize the property (if necessary) |
221
|
2 |
|
$this->initializeNodeProperty($name, $properties); |
222
|
|
|
|
223
|
|
|
// Parse and process the property value |
224
|
2 |
|
$this->processNodeProperty($name, $this->parse($property), $properties); |
225
|
|
|
} |
226
|
|
|
|
227
|
2 |
|
return $properties; |
228
|
|
|
} |
229
|
|
|
|
230
|
|
|
/** |
231
|
|
|
* Initialize a JSON-LD node property (if necessary) |
232
|
|
|
* |
233
|
|
|
* @param string $name Property name |
234
|
|
|
* @param array $properties Item properties |
235
|
|
|
*/ |
236
|
2 |
|
protected function initializeNodeProperty($name, array &$properties) |
237
|
|
|
{ |
238
|
2 |
|
if (empty($properties[$name])) { |
239
|
2 |
|
$properties[$name] = $this->vocabularyCache->expandIRI($name); |
240
|
2 |
|
$properties[$name]->values = []; |
241
|
|
|
} |
242
|
2 |
|
} |
243
|
|
|
|
244
|
|
|
/** |
245
|
|
|
* Process a property value |
246
|
|
|
* |
247
|
|
|
* @param string $name Property name |
248
|
|
|
* @param \stdClass|array|string $value Property value |
249
|
|
|
* @param array $properties Item properties |
250
|
|
|
*/ |
251
|
2 |
|
protected function processNodeProperty($name, $value, array &$properties) |
252
|
|
|
{ |
253
|
|
|
// If this is a nested item |
254
|
2 |
|
if (is_object($value)) { |
255
|
2 |
|
$this->processNodePropertyObject($name, $value, $properties); |
256
|
|
|
|
257
|
|
|
// Else: If this is a value list |
258
|
2 |
|
} elseif (is_array($value)) { |
259
|
1 |
|
foreach ($value as $listValue) { |
260
|
1 |
|
$this->processNodeProperty($name, $listValue, $properties); |
261
|
|
|
} |
262
|
|
|
|
263
|
|
|
// Else: If the value is not empty |
264
|
2 |
|
} elseif ($value) { |
265
|
2 |
|
$properties[$name]->values[] = $value; |
266
|
|
|
} |
267
|
2 |
|
} |
268
|
|
|
|
269
|
|
|
/** |
270
|
|
|
* Process a property value object |
271
|
|
|
* |
272
|
|
|
* @param string $name Property name |
273
|
|
|
* @param \stdClass $value Property value |
274
|
|
|
* @param array $properties Properties |
275
|
|
|
*/ |
276
|
2 |
|
protected function processNodePropertyObject($name, $value, array &$properties) |
277
|
|
|
{ |
278
|
2 |
|
if (!empty($value->type) || !empty($value->lang)) { |
279
|
2 |
|
$properties[$name]->values[] = $value; |
280
|
|
|
|
281
|
|
|
// @type = @id |
282
|
2 |
|
} elseif (!empty($value->id)) { |
283
|
2 |
|
$properties[$name]->values[] = $value->id; |
284
|
|
|
} |
285
|
2 |
|
} |
286
|
|
|
|
287
|
|
|
/** |
288
|
|
|
* Parse a JSON-LD fragment |
289
|
|
|
* |
290
|
|
|
* @param NodeInterface|LanguageTaggedString|TypedValue|array $jsonLD JSON-LD fragment |
291
|
|
|
* @return \stdClass|string|array Parsed fragment |
292
|
|
|
*/ |
293
|
2 |
|
protected function parse($jsonLD) |
294
|
|
|
{ |
295
|
|
|
// If it's a node object |
296
|
2 |
|
if ($jsonLD instanceof NodeInterface) { |
297
|
2 |
|
return $this->parseNode($jsonLD); |
298
|
|
|
|
299
|
|
|
// Else if it's a language tagged string |
300
|
2 |
|
} elseif ($jsonLD instanceof LanguageTaggedString) { |
301
|
1 |
|
return $this->parseLanguageTaggedString($jsonLD); |
302
|
|
|
|
303
|
|
|
// Else if it's a typed value |
304
|
2 |
|
} elseif ($jsonLD instanceof TypedValue) { |
305
|
2 |
|
return $this->parseTypedValue($jsonLD); |
306
|
|
|
} |
307
|
|
|
|
308
|
|
|
// Else if it's a list of items |
309
|
|
|
//elseif (is_array($jsonLD)) { |
310
|
1 |
|
return array_map([$this, 'parse'], $jsonLD); |
311
|
|
|
// } |
312
|
|
|
} |
313
|
|
|
|
314
|
|
|
/** |
315
|
|
|
* Parse a language tagged string |
316
|
|
|
* |
317
|
|
|
* @param LanguageTaggedString $value Language tagged string |
318
|
|
|
* @return \stdClass Value |
319
|
|
|
*/ |
320
|
1 |
|
protected function parseLanguageTaggedString(LanguageTaggedString $value) |
321
|
|
|
{ |
322
|
1 |
|
return (object)['value' => $value->getValue(), 'lang' => $value->getLanguage()]; |
323
|
|
|
} |
324
|
|
|
|
325
|
|
|
/** |
326
|
|
|
* Parse a typed value |
327
|
|
|
* |
328
|
|
|
* @param TypedValue $value Typed value |
329
|
|
|
* @return string Value |
330
|
|
|
*/ |
331
|
2 |
|
protected function parseTypedValue(TypedValue $value) |
332
|
|
|
{ |
333
|
2 |
|
return $value->getValue(); |
334
|
|
|
} |
335
|
|
|
} |
336
|
|
|
|