1
|
|
|
<?php |
2
|
|
|
declare(strict_types=1); |
3
|
|
|
|
4
|
|
|
/** |
5
|
|
|
* This file is part of phpDocumentor. |
6
|
|
|
* |
7
|
|
|
* For the full copyright and license information, please view the LICENSE |
8
|
|
|
* file that was distributed with this source code. |
9
|
|
|
* |
10
|
|
|
* @author Mike van Riel <[email protected]> |
11
|
|
|
* @copyright 2010-2018 Mike van Riel / Naenius (http://www.naenius.com) |
12
|
|
|
* @license http://www.opensource.org/licenses/mit-license.php MIT |
13
|
|
|
* @link http://phpdoc.org |
14
|
|
|
*/ |
15
|
|
|
|
16
|
|
|
namespace phpDocumentor\Transformer\Writer; |
17
|
|
|
|
18
|
|
|
use phpDocumentor\Application; |
19
|
|
|
use phpDocumentor\Descriptor\ClassDescriptor; |
20
|
|
|
use phpDocumentor\Descriptor\ConstantDescriptor; |
21
|
|
|
use phpDocumentor\Descriptor\FileDescriptor; |
22
|
|
|
use phpDocumentor\Descriptor\FunctionDescriptor; |
23
|
|
|
use phpDocumentor\Descriptor\InterfaceDescriptor; |
24
|
|
|
use phpDocumentor\Descriptor\ProjectDescriptor; |
25
|
|
|
use phpDocumentor\Descriptor\TraitDescriptor; |
26
|
|
|
use phpDocumentor\Descriptor\Validator\Error; |
27
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\AuthorTag; |
28
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\CoversTag; |
29
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\IgnoreTag; |
30
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\InternalTag; |
31
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\LicenseTag; |
32
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\MethodTag; |
33
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\ParamTag; |
34
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\PropertyTag; |
35
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\ReturnTag; |
36
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\UsesTag; |
37
|
|
|
use phpDocumentor\Transformer\Behaviour\Tag\VarTag; |
38
|
|
|
use phpDocumentor\Transformer\Router\RouterAbstract; |
39
|
|
|
use phpDocumentor\Transformer\Transformation; |
40
|
|
|
use phpDocumentor\Transformer\Transformer; |
41
|
|
|
use phpDocumentor\Transformer\Writer\Xml\ArgumentConverter; |
42
|
|
|
use phpDocumentor\Transformer\Writer\Xml\ConstantConverter; |
43
|
|
|
use phpDocumentor\Transformer\Writer\Xml\DocBlockConverter; |
44
|
|
|
use phpDocumentor\Transformer\Writer\Xml\InterfaceConverter; |
45
|
|
|
use phpDocumentor\Transformer\Writer\Xml\MethodConverter; |
46
|
|
|
use phpDocumentor\Transformer\Writer\Xml\PropertyConverter; |
47
|
|
|
use phpDocumentor\Transformer\Writer\Xml\TagConverter; |
48
|
|
|
use phpDocumentor\Transformer\Writer\Xml\TraitConverter; |
49
|
|
|
|
50
|
|
|
/** |
51
|
|
|
* Converts the structural information of phpDocumentor into an XML file. |
52
|
|
|
*/ |
53
|
|
|
class Xml extends WriterAbstract |
54
|
|
|
{ |
55
|
|
|
/** @var \DOMDocument $xml */ |
56
|
|
|
protected $xml; |
57
|
|
|
|
58
|
|
|
protected $docBlockConverter; |
59
|
|
|
|
60
|
|
|
protected $argumentConverter; |
61
|
|
|
|
62
|
|
|
protected $methodConverter; |
63
|
|
|
|
64
|
|
|
protected $propertyConverter; |
65
|
|
|
|
66
|
|
|
protected $constantConverter; |
67
|
|
|
|
68
|
|
|
protected $interfaceConverter; |
69
|
|
|
|
70
|
|
|
protected $traitConverter; |
71
|
|
|
|
72
|
2 |
|
public function __construct(RouterAbstract $router) |
73
|
|
|
{ |
74
|
2 |
|
$this->docBlockConverter = new DocBlockConverter(new TagConverter(), $router); |
75
|
2 |
|
$this->argumentConverter = new ArgumentConverter(); |
76
|
2 |
|
$this->methodConverter = new MethodConverter($this->argumentConverter, $this->docBlockConverter); |
77
|
2 |
|
$this->propertyConverter = new PropertyConverter($this->docBlockConverter); |
78
|
2 |
|
$this->constantConverter = new ConstantConverter($this->docBlockConverter); |
79
|
2 |
|
$this->interfaceConverter = new InterfaceConverter( |
80
|
2 |
|
$this->docBlockConverter, |
81
|
2 |
|
$this->methodConverter, |
82
|
2 |
|
$this->constantConverter |
83
|
|
|
); |
84
|
2 |
|
$this->traitConverter = new TraitConverter( |
85
|
2 |
|
$this->docBlockConverter, |
86
|
2 |
|
$this->methodConverter, |
87
|
2 |
|
$this->propertyConverter |
88
|
|
|
); |
89
|
2 |
|
} |
90
|
|
|
|
91
|
|
|
/** |
92
|
|
|
* This method generates the AST output |
93
|
|
|
* |
94
|
|
|
* @param ProjectDescriptor $project Document containing the structure. |
95
|
|
|
* @param Transformation $transformation Transformation to execute. |
96
|
|
|
*/ |
97
|
2 |
|
public function transform(ProjectDescriptor $project, Transformation $transformation) |
98
|
|
|
{ |
99
|
2 |
|
$artifact = $this->getDestinationPath($transformation); |
100
|
|
|
|
101
|
2 |
|
$this->checkForSpacesInPath($artifact); |
102
|
|
|
|
103
|
2 |
|
$this->xml = new \DOMDocument('1.0', 'utf-8'); |
104
|
2 |
|
$this->xml->formatOutput = true; |
105
|
2 |
|
$document_element = new \DOMElement('project'); |
106
|
2 |
|
$this->xml->appendChild($document_element); |
107
|
|
|
|
108
|
2 |
|
$document_element->setAttribute('title', $project->getName()); |
109
|
2 |
|
$document_element->setAttribute('version', Application::VERSION()); |
110
|
|
|
|
111
|
2 |
|
$this->buildPartials($document_element, $project); |
112
|
|
|
|
113
|
2 |
|
$transformer = $transformation->getTransformer(); |
114
|
|
|
|
115
|
2 |
|
foreach ($project->getFiles() as $file) { |
116
|
1 |
|
$this->buildFile($document_element, $file, $transformer); |
117
|
|
|
} |
118
|
|
|
|
119
|
2 |
|
$this->finalize($project); |
120
|
2 |
|
file_put_contents($artifact, $this->xml->saveXML()); |
121
|
2 |
|
} |
122
|
|
|
|
123
|
2 |
|
protected function buildPartials(\DOMElement $parent, ProjectDescriptor $project) |
124
|
|
|
{ |
125
|
2 |
|
$child = new \DOMElement('partials'); |
126
|
2 |
|
$parent->appendChild($child); |
127
|
2 |
|
foreach ($project->getPartials() as $name => $element) { |
128
|
|
|
$partial = new \DOMElement('partial'); |
129
|
|
|
$child->appendChild($partial); |
130
|
|
|
$partial->setAttribute('name', $name); |
131
|
|
|
$partial->appendChild(new \DOMText($element)); |
132
|
|
|
} |
133
|
2 |
|
} |
134
|
|
|
|
135
|
1 |
|
protected function buildFile(\DOMElement $parent, FileDescriptor $file, Transformer $transformer) |
136
|
|
|
{ |
137
|
1 |
|
$child = new \DOMElement('file'); |
138
|
1 |
|
$parent->appendChild($child); |
139
|
|
|
|
140
|
1 |
|
$path = ltrim($file->getPath(), './'); |
141
|
1 |
|
$child->setAttribute('path', $path); |
142
|
1 |
|
$child->setAttribute( |
143
|
1 |
|
'generated-path', |
144
|
1 |
|
$transformer->generateFilename($path) |
145
|
|
|
); |
146
|
1 |
|
$child->setAttribute('hash', $file->getHash()); |
147
|
|
|
|
148
|
1 |
|
$this->docBlockConverter->convert($child, $file); |
149
|
|
|
|
150
|
|
|
// add namespace aliases |
151
|
1 |
|
foreach ($file->getNamespaceAliases() as $alias => $namespace) { |
152
|
1 |
|
$alias_obj = new \DOMElement('namespace-alias', (string) $namespace); |
153
|
1 |
|
$child->appendChild($alias_obj); |
154
|
1 |
|
$alias_obj->setAttribute('name', (string) $alias); |
155
|
|
|
} |
156
|
|
|
|
157
|
|
|
/** @var ConstantDescriptor $constant */ |
158
|
1 |
|
foreach ($file->getConstants() as $constant) { |
159
|
|
|
$this->constantConverter->convert($child, $constant); |
160
|
|
|
} |
161
|
|
|
|
162
|
|
|
/** @var FunctionDescriptor $function */ |
163
|
1 |
|
foreach ($file->getFunctions() as $function) { |
164
|
|
|
$this->buildFunction($child, $function); |
165
|
|
|
} |
166
|
|
|
|
167
|
|
|
/** @var InterfaceDescriptor $interface */ |
168
|
1 |
|
foreach ($file->getInterfaces() as $interface) { |
169
|
|
|
$this->interfaceConverter->convert($child, $interface); |
170
|
|
|
} |
171
|
|
|
|
172
|
|
|
/** @var ClassDescriptor $class */ |
173
|
1 |
|
foreach ($file->getClasses() as $class) { |
174
|
|
|
$this->buildClass($child, $class); |
175
|
|
|
} |
176
|
|
|
|
177
|
|
|
/** @var TraitDescriptor $class */ |
178
|
1 |
|
foreach ($file->getTraits() as $trait) { |
179
|
|
|
$this->traitConverter->convert($child, $trait); |
180
|
|
|
} |
181
|
|
|
|
182
|
|
|
// add markers |
183
|
1 |
|
if (count($file->getMarkers()) > 0) { |
184
|
|
|
$markers = new \DOMElement('markers'); |
185
|
|
|
$child->appendChild($markers); |
186
|
|
|
|
187
|
|
|
foreach ($file->getMarkers() as $marker) { |
188
|
|
|
if (! $marker['type']) { |
189
|
|
|
continue; |
190
|
|
|
} |
191
|
|
|
|
192
|
|
|
$type = preg_replace('/[^A-Za-z0-9\-]/', '', $marker['type']); |
193
|
|
|
$marker_obj = new \DOMElement(strtolower($type)); |
194
|
|
|
$markers->appendChild($marker_obj); |
195
|
|
|
|
196
|
|
|
if (array_key_exists('message', $marker)) { |
197
|
|
|
$marker_obj->appendChild(new \DOMText(trim((string) $marker['message']))); |
198
|
|
|
} |
199
|
|
|
$marker_obj->setAttribute('line', (string) $marker['line']); |
200
|
|
|
} |
201
|
|
|
} |
202
|
|
|
|
203
|
1 |
|
// if we want to include the source for each file; append a new |
204
|
1 |
|
// element 'source' which contains a compressed, encoded version |
205
|
|
|
// of the source |
206
|
|
|
if ($file->getSource()) { |
|
|
|
|
207
|
|
|
$child->appendChild(new \DOMElement('source', base64_encode(gzcompress($file->getSource())))); |
208
|
|
|
} |
209
|
|
|
} |
210
|
|
|
|
211
|
|
|
/** |
212
|
|
|
* Retrieves the destination location for this artifact. |
213
|
|
|
* |
214
|
|
|
* @return string |
215
|
|
|
*/ |
216
|
|
|
protected function getDestinationPath(Transformation $transformation) |
217
|
1 |
|
{ |
218
|
|
|
return $transformation->getTransformer()->getTarget() |
219
|
|
|
. DIRECTORY_SEPARATOR . $transformation->getArtifact(); |
220
|
1 |
|
} |
221
|
|
|
|
222
|
|
|
/** |
223
|
|
|
* Export this function definition to the given parent DOMElement. |
224
|
|
|
* |
225
|
|
|
* @param \DOMElement $parent Element to augment. |
226
|
|
|
* @param FunctionDescriptor $function Element to export. |
227
|
|
|
* @param \DOMElement $child if supplied this element will be augmented instead of freshly added. |
228
|
|
|
*/ |
229
|
|
|
public function buildFunction(\DOMElement $parent, FunctionDescriptor $function, \DOMElement $child = null) |
230
|
|
|
{ |
231
|
|
|
if (!$child) { |
232
|
|
|
$child = new \DOMElement('function'); |
233
|
|
|
$parent->appendChild($child); |
234
|
|
|
} |
235
|
|
|
|
236
|
|
|
$namespace = $function->getNamespace() |
237
|
|
|
?: $parent->getAttribute('namespace'); |
238
|
|
|
$child->setAttribute('namespace', ltrim((string) $namespace, '\\')); |
239
|
|
|
$child->setAttribute('line', (string) $function->getLine()); |
240
|
|
|
|
241
|
|
|
$child->appendChild(new \DOMElement('name', $function->getName())); |
242
|
|
|
$child->appendChild(new \DOMElement('full_name', (string) $function->getFullyQualifiedStructuralElementName())); |
243
|
|
|
|
244
|
|
|
$this->docBlockConverter->convert($child, $function); |
245
|
2 |
|
|
246
|
|
|
foreach ($function->getArguments() as $argument) { |
247
|
2 |
|
$this->argumentConverter->convert($child, $argument); |
248
|
2 |
|
} |
249
|
|
|
} |
250
|
|
|
|
251
|
|
|
/** |
252
|
|
|
* Exports the given reflection object to the parent XML element. |
253
|
|
|
* |
254
|
|
|
* This method creates a new child element on the given parent XML element |
255
|
|
|
* and takes the properties of the Reflection argument and sets the |
256
|
|
|
* elements and attributes on the child. |
257
|
|
|
* |
258
|
|
|
* If a child DOMElement is provided then the properties and attributes are |
259
|
|
|
* set on this but the child element is not appended onto the parent. This |
260
|
|
|
* is the responsibility of the invoker. Essentially this means that the |
261
|
|
|
* $parent argument is ignored in this case. |
262
|
|
|
* |
263
|
|
|
* @param \DOMElement $parent The parent element to augment. |
264
|
|
|
* @param ClassDescriptor $class The data source. |
265
|
|
|
* @param \DOMElement $child Optional: child element to use instead of creating a |
266
|
|
|
* new one on the $parent. |
267
|
|
|
*/ |
268
|
|
|
public function buildClass(\DOMElement $parent, ClassDescriptor $class, \DOMElement $child = null) |
269
|
|
|
{ |
270
|
|
|
if (!$child) { |
271
|
|
|
$child = new \DOMElement('class'); |
272
|
|
|
$parent->appendChild($child); |
273
|
|
|
} |
274
|
|
|
|
275
|
|
|
$child->setAttribute('final', $class->isFinal() ? 'true' : 'false'); |
276
|
|
|
$child->setAttribute('abstract', $class->isAbstract() ? 'true' : 'false'); |
277
|
|
|
|
278
|
|
|
if ($class->getParent() !== null) { |
279
|
|
|
$parentFqcn = $class->getParent() instanceof ClassDescriptor |
280
|
|
|
? (string) $class->getParent()->getFullyQualifiedStructuralElementName() |
281
|
|
|
: (string) $class->getParent(); |
282
|
|
|
$child->appendChild(new \DOMElement('extends', $parentFqcn)); |
283
|
|
|
} |
284
|
|
|
|
285
|
|
|
/** @var InterfaceDescriptor $interface */ |
286
|
|
|
foreach ($class->getInterfaces() as $interface) { |
287
|
|
|
$interfaceFqcn = $interface instanceof InterfaceDescriptor |
288
|
|
|
? (string) $interface->getFullyQualifiedStructuralElementName() |
289
|
|
|
: (string) $interface; |
290
|
|
|
$child->appendChild(new \DOMElement('implements', $interfaceFqcn)); |
291
|
|
|
} |
292
|
|
|
|
293
|
|
|
if ($child === null) { |
294
|
|
|
$child = new \DOMElement('interface'); |
295
|
|
|
$parent->appendChild($child); |
296
|
|
|
} |
297
|
|
|
|
298
|
|
|
$namespace = (string) $class->getNamespace()->getFullyQualifiedStructuralElementName(); |
299
|
|
|
$child->setAttribute('namespace', ltrim($namespace, '\\')); |
300
|
|
|
$child->setAttribute('line', (string) $class->getLine()); |
301
|
|
|
|
302
|
|
|
$child->appendChild(new \DOMElement('name', $class->getName())); |
303
|
|
|
$child->appendChild(new \DOMElement('full_name', (string) $class->getFullyQualifiedStructuralElementName())); |
304
|
|
|
|
305
|
|
|
$this->docBlockConverter->convert($child, $class); |
306
|
|
|
|
307
|
|
|
foreach ($class->getConstants() as $constant) { |
308
|
|
|
// TODO #840: Workaround; for some reason there are NULLs in the constants array. |
309
|
|
|
if ($constant) { |
310
|
|
|
$this->constantConverter->convert($child, $constant); |
311
|
|
|
} |
312
|
|
|
} |
313
|
|
|
|
314
|
|
|
foreach ($class->getInheritedConstants() as $constant) { |
315
|
|
|
// TODO #840: Workaround; for some reason there are NULLs in the constants array. |
316
|
|
|
if ($constant) { |
317
|
|
|
$this->constantConverter->convert($child, $constant); |
318
|
|
|
} |
319
|
|
|
} |
320
|
|
|
|
321
|
|
|
foreach ($class->getProperties() as $property) { |
322
|
|
|
// TODO #840: Workaround; for some reason there are NULLs in the properties array. |
323
|
|
|
if ($property) { |
324
|
|
|
$this->propertyConverter->convert($child, $property); |
325
|
|
|
} |
326
|
|
|
} |
327
|
|
|
|
328
|
|
|
foreach ($class->getInheritedProperties() as $property) { |
329
|
|
|
// TODO #840: Workaround; for some reason there are NULLs in the properties array. |
330
|
|
|
if ($property) { |
331
|
|
|
$this->propertyConverter->convert($child, $property); |
332
|
|
|
} |
333
|
|
|
} |
334
|
|
|
|
335
|
|
|
foreach ($class->getMethods() as $method) { |
336
|
|
|
// TODO #840: Workaround; for some reason there are NULLs in the methods array. |
337
|
|
|
if ($method) { |
338
|
|
|
$this->methodConverter->convert($child, $method); |
339
|
|
|
} |
340
|
|
|
} |
341
|
|
|
|
342
|
|
|
foreach ($class->getInheritedMethods() as $method) { |
343
|
|
|
// TODO #840: Workaround; for some reason there are NULLs in the methods array. |
344
|
|
|
if ($method) { |
345
|
|
|
$methodElement = $this->methodConverter->convert($child, $method); |
346
|
|
|
$methodElement->appendChild( |
347
|
|
|
new \DOMElement( |
348
|
|
|
'inherited_from', |
349
|
|
|
(string) $method->getParent()->getFullyQualifiedStructuralElementName() |
350
|
|
|
) |
351
|
|
|
); |
352
|
|
|
} |
353
|
|
|
} |
354
|
|
|
} |
355
|
|
|
|
356
|
|
|
/** |
357
|
|
|
* Finalizes the processing and executing all post-processing actions. |
358
|
|
|
* |
359
|
|
|
* This method is responsible for extracting and manipulating the data that |
360
|
|
|
* is global to the project, such as: |
361
|
|
|
* |
362
|
|
|
* - Package tree |
363
|
|
|
* - Namespace tree |
364
|
|
|
* - Marker list |
365
|
|
|
* - Deprecated elements listing |
366
|
|
|
* - Removal of objects related to visibility |
367
|
|
|
*/ |
368
|
|
|
protected function finalize(ProjectDescriptor $projectDescriptor) |
369
|
|
|
{ |
370
|
|
|
// TODO: move all these behaviours to a central location for all template parsers |
371
|
|
|
$behaviour = new AuthorTag(); |
372
|
|
|
$behaviour->process($this->xml); |
373
|
|
|
$behaviour = new CoversTag(); |
374
|
|
|
$behaviour->process($this->xml); |
375
|
|
|
$behaviour = new IgnoreTag(); |
376
|
|
|
$behaviour->process($this->xml); |
377
|
|
|
$behaviour = new InternalTag( |
378
|
|
|
$projectDescriptor->isVisibilityAllowed(ProjectDescriptor\Settings::VISIBILITY_INTERNAL) |
379
|
|
|
); |
380
|
|
|
$behaviour->process($this->xml); |
381
|
|
|
$behaviour = new LicenseTag(); |
382
|
|
|
$behaviour->process($this->xml); |
383
|
|
|
$behaviour = new MethodTag(); |
384
|
|
|
$behaviour->process($this->xml); |
385
|
|
|
$behaviour = new ParamTag(); |
386
|
|
|
$behaviour->process($this->xml); |
387
|
|
|
$behaviour = new PropertyTag(); |
388
|
|
|
$behaviour->process($this->xml); |
389
|
|
|
$behaviour = new ReturnTag(); |
390
|
|
|
$behaviour->process($this->xml); |
391
|
|
|
$behaviour = new UsesTag(); |
392
|
|
|
$behaviour->process($this->xml); |
393
|
|
|
$behaviour = new VarTag(); |
394
|
|
|
$behaviour->process($this->xml); |
395
|
|
|
$this->buildPackageTree($this->xml); |
396
|
|
|
$this->buildNamespaceTree($this->xml); |
397
|
2 |
|
$this->buildDeprecationList($this->xml); |
398
|
|
|
} |
399
|
|
|
|
400
|
2 |
|
/** |
401
|
2 |
|
* Collects all packages and subpackages, and adds a new section in the |
402
|
2 |
|
* DOM to provide an overview. |
403
|
2 |
|
* |
404
|
2 |
|
* @param \DOMDocument $dom Packages are extracted and a summary inserted |
405
|
2 |
|
* in this object. |
406
|
2 |
|
*/ |
407
|
2 |
|
protected function buildPackageTree(\DOMDocument $dom) |
408
|
|
|
{ |
409
|
2 |
|
$xpath = new \DOMXPath($dom); |
410
|
2 |
|
$packages = ['global' => true]; |
411
|
2 |
|
$qry = $xpath->query('//@package'); |
412
|
2 |
|
for ($i = 0; $i < $qry->length; ++$i) { |
413
|
2 |
|
if (isset($packages[$qry->item($i)->nodeValue])) { |
414
|
2 |
|
continue; |
415
|
2 |
|
} |
416
|
2 |
|
|
417
|
2 |
|
$packages[$qry->item($i)->nodeValue] = true; |
418
|
2 |
|
} |
419
|
2 |
|
|
420
|
2 |
|
$packages = $this->generateNamespaceTree(array_keys($packages)); |
421
|
2 |
|
$this->generateNamespaceElements($packages, $dom->documentElement, 'package'); |
422
|
2 |
|
} |
423
|
2 |
|
|
424
|
2 |
|
/** |
425
|
2 |
|
* Collects all namespaces and sub-namespaces, and adds a new section in |
426
|
2 |
|
* the DOM to provide an overview. |
427
|
2 |
|
* |
428
|
|
|
* @param \DOMDocument $dom Namespaces are extracted and a summary inserted |
429
|
|
|
* in this object. |
430
|
|
|
*/ |
431
|
|
|
protected function buildNamespaceTree(\DOMDocument $dom) |
432
|
|
|
{ |
433
|
|
|
$xpath = new \DOMXPath($dom); |
434
|
|
|
$namespaces = []; |
435
|
|
|
$qry = $xpath->query('//@namespace'); |
436
|
2 |
|
for ($i = 0; $i < $qry->length; ++$i) { |
437
|
|
|
if (isset($namespaces[$qry->item($i)->nodeValue])) { |
438
|
2 |
|
continue; |
439
|
2 |
|
} |
440
|
2 |
|
|
441
|
2 |
|
$namespaces[$qry->item($i)->nodeValue] = true; |
442
|
1 |
|
} |
443
|
|
|
|
444
|
|
|
$namespaces = $this->generateNamespaceTree(array_keys($namespaces)); |
445
|
|
|
$this->generateNamespaceElements($namespaces, $dom->documentElement); |
446
|
1 |
|
} |
447
|
|
|
|
448
|
|
|
/** |
449
|
2 |
|
* Adds a node to the xml for deprecations and the count value |
450
|
2 |
|
* |
451
|
2 |
|
* @param \DOMDocument $dom Markers are extracted and a summary inserted in this object. |
452
|
|
|
*/ |
453
|
|
|
protected function buildDeprecationList(\DOMDocument $dom) |
454
|
|
|
{ |
455
|
|
|
$nodes = $this->getNodeListForTagBasedQuery($dom, 'deprecated'); |
456
|
|
|
|
457
|
|
|
$node = new \DOMElement('deprecated'); |
458
|
|
|
$dom->documentElement->appendChild($node); |
459
|
|
|
$node->setAttribute('count', (string) $nodes->length); |
460
|
2 |
|
} |
461
|
|
|
|
462
|
2 |
|
/** |
463
|
2 |
|
* Build a tag based query string and return result |
464
|
2 |
|
* |
465
|
2 |
|
* @param \DOMDocument $dom Markers are extracted and a summary inserted |
466
|
|
|
* in this object. |
467
|
|
|
* @param string $marker The marker we're searching for throughout xml |
468
|
|
|
* |
469
|
|
|
* @return \DOMNodeList |
470
|
|
|
*/ |
471
|
|
|
protected function getNodeListForTagBasedQuery($dom, $marker) |
472
|
|
|
{ |
473
|
2 |
|
$xpath = new \DOMXPath($dom); |
474
|
2 |
|
|
475
|
2 |
|
$query = '/project/file/markers/' . $marker . '|'; |
476
|
|
|
$query .= '/project/file/docblock/tag[@name="' . $marker . '"]|'; |
477
|
|
|
$query .= '/project/file/class/docblock/tag[@name="' . $marker . '"]|'; |
478
|
|
|
$query .= '/project/file/class/*/docblock/tag[@name="' . $marker . '"]|'; |
479
|
|
|
$query .= '/project/file/interface/docblock/tag[@name="' . $marker . '"]|'; |
480
|
|
|
$query .= '/project/file/interface/*/docblock/tag[@name="' . $marker . '"]|'; |
481
|
|
|
$query .= '/project/file/function/docblock/tag[@name="' . $marker . '"]|'; |
482
|
2 |
|
$query .= '/project/file/constant/docblock/tag[@name="' . $marker . '"]'; |
483
|
|
|
|
484
|
2 |
|
return $xpath->query($query); |
485
|
|
|
} |
486
|
2 |
|
|
487
|
2 |
|
/** |
488
|
2 |
|
* Generates a hierarchical array of namespaces with their singular name |
489
|
2 |
|
* from a single level list of namespaces with their full name. |
490
|
|
|
* |
491
|
|
|
* @param array $namespaces the list of namespaces as retrieved from the xml. |
492
|
|
|
* |
493
|
|
|
* @return array |
494
|
|
|
*/ |
495
|
|
|
protected function generateNamespaceTree($namespaces) |
496
|
|
|
{ |
497
|
|
|
sort($namespaces); |
498
|
|
|
|
499
|
|
|
$result = []; |
500
|
2 |
|
foreach ($namespaces as $namespace) { |
501
|
|
|
if (!$namespace) { |
502
|
2 |
|
$namespace = 'global'; |
503
|
|
|
} |
504
|
2 |
|
|
505
|
2 |
|
$namespace_list = explode('\\', $namespace); |
506
|
2 |
|
|
507
|
2 |
|
$node = &$result; |
508
|
2 |
|
foreach ($namespace_list as $singular) { |
509
|
2 |
|
if (!isset($node[$singular])) { |
510
|
2 |
|
$node[$singular] = []; |
511
|
2 |
|
} |
512
|
|
|
|
513
|
2 |
|
$node = &$node[$singular]; |
514
|
|
|
} |
515
|
|
|
} |
516
|
|
|
|
517
|
|
|
return $result; |
518
|
|
|
} |
519
|
|
|
|
520
|
|
|
/** |
521
|
|
|
* Recursive method to create a hierarchical set of nodes in the dom. |
522
|
|
|
* |
523
|
|
|
* @param array[] $namespaces the list of namespaces to process. |
524
|
2 |
|
* @param \DOMElement $parent_element the node to receive the children of |
525
|
|
|
* the above list. |
526
|
2 |
|
* @param string $node_name the name of the summary element. |
527
|
|
|
*/ |
528
|
2 |
|
protected function generateNamespaceElements($namespaces, $parent_element, $node_name = 'namespace') |
529
|
2 |
|
{ |
530
|
2 |
|
foreach ($namespaces as $name => $sub_namespaces) { |
531
|
|
|
$node = new \DOMElement($node_name); |
532
|
|
|
$parent_element->appendChild($node); |
533
|
|
|
$node->setAttribute('name', $name); |
534
|
2 |
|
$fullName = $parent_element->nodeName === $node_name |
535
|
|
|
? $parent_element->getAttribute('full_name') . '\\' . $name |
536
|
2 |
|
: $name; |
537
|
2 |
|
$node->setAttribute('full_name', $fullName); |
538
|
2 |
|
$this->generateNamespaceElements($sub_namespaces, $node, $node_name); |
539
|
2 |
|
} |
540
|
|
|
} |
541
|
|
|
} |
542
|
|
|
|
In PHP, under loose comparison (like
==
, or!=
, orswitch
conditions), values of different types might be equal.For
string
values, the empty string''
is a special case, in particular the following results might be unexpected: