Code Coverage for D:\Apache2.4.33\htdocs\iaLib\inc

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 16	CRAP	0.00% covered (danger)	0.00%	0 / 206
DocumentIt	0.00% covered (danger)	0.00%	0 / 1	0.00% covered (danger)	0.00%	0 / 16	8190.00	0.00% covered (danger)	0.00%	0 / 206
document_class				0.00% covered (danger)	0.00%	0 / 1	156.00	0.00% covered (danger)	0.00%	0 / 35
document_public_methods				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 13
document_properties				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 12
document_constants				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 7
parameters				0.00% covered (danger)	0.00%	0 / 1	42.00	0.00% covered (danger)	0.00%	0 / 14
parametersInfo				0.00% covered (danger)	0.00%	0 / 1	72.00	0.00% covered (danger)	0.00%	0 / 19
defaultValueDisplay				0.00% covered (danger)	0.00%	0 / 1	156.00	0.00% covered (danger)	0.00%	0 / 19
deduceParameterTypeFromDockBlock				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 6
deduceReturnTypeFromDockBlock				0.00% covered (danger)	0.00%	0 / 1	6.00	0.00% covered (danger)	0.00%	0 / 4
calls				0.00% covered (danger)	0.00%	0 / 1	156.00	0.00% covered (danger)	0.00%	0 / 17
class_parents				0.00% covered (danger)	0.00%	0 / 1	6.00	0.00% covered (danger)	0.00%	0 / 4
class_implements				0.00% covered (danger)	0.00%	0 / 1	6.00	0.00% covered (danger)	0.00%	0 / 4
class_uses_deep				0.00% covered (danger)	0.00%	0 / 1	12.00	0.00% covered (danger)	0.00%	0 / 10
relations				0.00% covered (danger)	0.00%	0 / 1	72.00	0.00% covered (danger)	0.00%	0 / 21
expandKeyToArray				0.00% covered (danger)	0.00%	0 / 1	30.00	0.00% covered (danger)	0.00%	0 / 16
methodDocBlockProtected				0.00% covered (danger)	0.00%	0 / 1	6.00	0.00% covered (danger)	0.00%	0 / 5

1	<?php
2	namespace ia\DocumentIt;
3
4	use DateTime;
5	use DateTimeImmutable;
6	use Exception;
7	use ReflectionClass;
8	use ReflectionException;
9	use ReflectionFunction;
10	use ReflectionMethod;
11	use ReflectionParameter;
12
13	//use ReflectionParameter;
14
15
16	class DocumentIt {
17
18	/**
19	* Genertes documentation for $classNam
20	*
21	* @param string $className
22	* @return string
23	*/
24	public static function document_class($className)
25	{
26	try {
27	/** @var ReflectionClass $ref */
28	$ref = new ReflectionClass($className);
29	} catch (ReflectionException $e) {
30	return "\Reflection error, correct \$ia_example['title'], $className";
31	}
32
33	$final = $ref->isFinal() ? 'final' : '';
34	$abstract = $ref->isAbstract() ? 'abstract' : '';
35	$es = 'class';
36	if ($ref->isInterface()) {
37	$es = 'interface';
38	}
39	if ($ref->isTrait()) {
40	$es = 'trait';
41	}
42	$ret = "<h2>" . trim("$final $abstract $es $className") . "</h2>";
43
44	$ret .= "<ul>";
45
46	$classDocBlock = $ref->getDocComment();
47	if (!empty($classDocBlock)) {
48	$ret .= "<li><code>$classDocBlock</code>";
49	}
50
51	if ($ref->getNamespaceName())
52	$ret .= "<li><b>namespace</b>: " . $ref->getNamespaceName();
53
54	// extends, parents
55	$extends = self::class_parents($ref, false);
56	if (!empty($extends)) {
57	$ret .= "<li><b>Extends</b>: " . implode(", ", $extends);
58	}
59
60	// interfaces
61	$interfaces = self::class_implements($ref, false);
62	if (!empty($interfaces)) {
63	$ret .= "<li><b>Implements</b>: " . implode(', ' , $interfaces);
64	}
65
66	// traits
67	$traits = self::class_uses_deep($ref, false);
68	if (!empty($traits)) {
69	$ret .= "<li><b>Traits</b>: " . implode(', ' , $traits);
70	}
71
72	$ret .= self::document_public_methods($ref);
73
74	$ret .= self::document_properties($ref);
75
76	$ret .= self::document_constants($ref);
77
78	$relations = self::calls($ref->getFileName());
79	if(!empty($relations)) {
80	asort($relations, SORT_NATURAL);
81	$ret .= "<li><b>Calls</b>:<ol><li>".implode('<li>', $relations)."</ol>";
82	}
83	$ret .= "</ul>";
84	return $ret;
85	}
86
87	/**
88	* @param ReflectionClass $ref
89	* @return string
90	*/
91	private static function document_public_methods($ref) {
92	$ret = "<p><li><b>Public Methods</b><ol>";
93	foreach ($ref->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
94	try {
95	$functionDocBlock = $ref->getMethod($method->name)->getDocComment();
96	} catch (ReflectionException $e) {
97	$functionDocBlock = "/** Error retrieving docblock */";
98	}
99	$parameters = implode(', ', self::parameters($method, $functionDocBlock) );
100	// $parameters = implode(', ', array_column($method->getParameters(), 'name'));
101	$returnType = '<span class="type"> : ' .
102	($method->hasReturnType() ?
103	$method->getReturnType() :
104	self::deduceReturnTypeFromDockBlock($functionDocBlock)
105	) . '</span>';
106
107	$ret .= "<li><b>" .
108	($method->isStatic() ? 'static ' : '') .
109	"$method->name( $parameters ) $returnType</b><br><code>$functionDocBlock</code><hr class='light'>";
110	}
111	return $ret . "</ol>";
112	}
113
114	/**
115	* @param ReflectionClass $ref
116	* @return string
117	*/
118	private static function document_properties($ref) {
119	$ret = '';
120	/** @var ReflectionParameter $properties */
121	$properties = $ref->getProperties(ReflectionMethod::IS_PUBLIC);
122	if (!empty($properties)) {
123	$ret .= "<p><li><b>Public Properties</b><ol>";
124	foreach ($properties as $property) {
125	try {
126	$functionDocBlock = $ref->getProperty($property->name)->getDocComment();
127	} catch (ReflectionException $e) {
128	$functionDocBlock = "/** Error retrieving docblock */";
129	}
130	$ret .= "<li><b>" . ($property->isStatic() ? 'static ' : '') .
131	"$property->name</b><br><code>$functionDocBlock</code>";
132	}
133	$ret .= "</ol>";
134	}
135	return $ret;
136	}
137
138	/**
139	* @param ReflectionClass $ref
140	* @return string
141	*/
142	private static function document_constants($ref) {
143	if(empty($ref->getConstants())) {
144	return '';
145	}
146	$ret = "<li><b>Constants</b><ol>";
147	foreach ($ref->getConstants() as $constant => $value) {
148	$ret .= "<li><b>$constant</b> = $value";
149	}
150	$ret .= "</ol>";
151	return $ret;
152	}
153
154	/**
155	*
156	* @param ReflectionFunction\|ReflectionMethod $function
157	* @param $functionDocBlock string docBlock for the function or method
158	* @return array
159	*/
160	public static function parameters($function, $functionDocBlock) {
161	$parameters = [];
162	foreach($function->getParameters() as $p) {
163	try {
164	$defaultType = ($p->isOptional() ?
165	' <span class="default">= ' . self::defaultValueDisplay($p->getDefaultValue()) . '</span>' : ''
166	);
167	} catch(ReflectionException $e) {
168	$defaultType = '?';
169	}
170	$param = '<span class="type">' .
171	($p->hasType() ?
172	$p->getType() :
173	self::deduceParameterTypeFromDockBlock($p->getName(), $functionDocBlock)
174	) . '</span> ' .
175	($p->isPassedByReference() ? '&' : '') .
176	'$' . $p->getName() . $defaultType;
177	$parameters[] = $param;
178	}
179	return $parameters;
180	}
181
182	/**
183	*
184	* @param ReflectionFunction\|ReflectionMethod $function
185	* @param $functionDocBlock string docBlock for the function or method
186	* @return array
187	* @throws ReflectionException
188	*/
189	public static function parametersInfo($function, $functionDocBlock) {
190	$parameters = [];
191	foreach($function->getParameters() as $p) {
192	try {
193	$defaultType = $p->isOptional() ?
194	' <span class="default">= ' . self::defaultValueDisplay($p->getDefaultValue()) . '</span>' : ''
195	;
196	} catch(ReflectionException $e) {
197	$defaultType = '?';
198	}
199
200	$param = '<span class="type">' .
201	($p->hasType() ?
202	$p->getType() :
203	self::deduceParameterTypeFromDockBlock($p->getName(), $functionDocBlock)
204	) . '</span> ' .
205	($p->isPassedByReference() ? '&' : '') .
206	'$' . $p->getName() . $defaultType;
207	$parameters[] = [
208	'name'=>$p->getName(),
209	'type'=> $p->hasType() ? $p->getType() : self::deduceParameterTypeFromDockBlock($p->getName(), $functionDocBlock),
210	'isOptional' => $p->isOptional(),
211	'default' => $p->isOptional() ? self::defaultValueDisplay($p->getDefaultValue()) : '',
212	'prototype' => $param
213	];
214	}
215	return $parameters;
216	}
217
218	/**
219	* @param $d
220	* @return string
221	*/
222	private static function defaultValueDisplay($d) {
223	if($d === true) return 'true';
224	if($d === false) return 'false';
225	if($d === null) return 'null';
226	if(is_string($d)) return "'$d'";
227	if(is_numeric($d)) return $d;
228	if(is_array($d)) {
229	if(empty($d)) {
230	return '[]';
231	}
232	$array = str_ireplace(['Array (','Array('], '[', print_r($d, true));
233	if(substr($array, -1) === ')') {
234	$array = substr($array, 0, -1).'[';
235	}
236	return $array;
237	}
238	if($d instanceof DateTimeImmutable) {
239	return "new DateTimeImmutable()";
240	}
241	if($d instanceof DateTime) {
242	return "new DateTime()";
243	}
244	if(is_object($d)) {
245	return "new ".get_class($d)."()";
246	}
247	return print_r($d, true);
248	}
249
250	/**
251	* @param string $paramName
252	* @param string $functionDocBlock
253	* @return string
254	*/
255	private static function deduceParameterTypeFromDockBlock($paramName, $functionDocBlock) {
256	$regExp = '/\@param\s+(.*)\s+\${0,1}'.$paramName.'[\s\.\;\:]/miu';
257	if(preg_match_all($regExp, $functionDocBlock, $matches, PREG_PATTERN_ORDER, 0) == 0) {
258	$regExp = '/\@param\s+\${0,1}'.$paramName.'[\s\.\;\:]+(.*)/miu';
259	if(preg_match_all($regExp, $functionDocBlock, $matches, PREG_PATTERN_ORDER, 0) == 0) {
260	return '';
261	}
262	}
263	return $matches[1][0];
264	}
265
266	/**
267	* @param string $functionDocBlock
268	* @return string
269	*/
270	public static function deduceReturnTypeFromDockBlock($functionDocBlock) {
271	$regExp = '/\@return\s+([a-z0-9_\|\\\\]*)[\s\.\;\:\"\'\-]/miu';
272	if(preg_match_all($regExp, $functionDocBlock, $matches, PREG_PATTERN_ORDER, 0) == 0) {
273	return '';
274	}
275	return $matches[1][0];
276	}
277
278	/**
279	* @param string $fileName
280	* @return array string names of use ..., and classes used with new or :: (statically)
281	*/
282	private static function calls($fileName) {
283	// https://stackoverflow.com/questions/30308137/get-use-statement-from-class
284	// https://github.com/Kdyby/ParseUseStatements
285	$code = file_get_contents($fileName);
286
287	$replaced = preg_replace('/(\/\[\s\S]\*\/)/miU', " ", $code);
288	if($replaced !== null) {
289	$code = $replaced;
290	}
291	$replaced = preg_replace('/(\/\/.*$)/miU', " ", $code);
292	if($replaced !== null) {
293	$code = $replaced;
294	}
295	$return = [];
296
297	if(preg_match_all('/\bnew\s+([a-z0-9_\\\\]+)/miu', $code, $matches,PREG_PATTERN_ORDER) > 0) {
298	foreach($matches[1] as $u) {
299	if($u !== 'this' && $u !== 'parent') {
300	$return[$u] = $u;
301	}
302	}
303	}
304
305	if(preg_match_all('/([a-z0-9_\\\\]+)::/miu', $code, $matches,PREG_PATTERN_ORDER) > 0) {
306	foreach($matches[1] as $u) {
307	if($u !== 'self' && $u !== 'static' && $u !== 'parent') {
308	$return[$u] = $u;
309	}
310	}
311	}
312	return $return;
313	}
314
315	private static function class_parents($reflectionClass, $autoload = false) {
316	$parents = class_parents($reflectionClass, $autoload);
317	if(!empty($parents['Reflector'])) {
318	unset($parents['Reflector']);
319	}
320	return $parents;
321	}
322
323	private static function class_implements($reflectionClass, $autoload = false) {
324	$parents = class_implements($reflectionClass, $autoload);
325	if(!empty($parents['Reflector'])) {
326	unset($parents['Reflector']);
327	}
328	return $parents;
329	}
330
331	/**
332	* @param ReflectionClass $reflectionClass
333	* @return array
334	*/
335	private static function class_uses_deep($class, $autoload = false) {
336	// https://www.php.net/manual/en/function.class-uses.php
337	$traits = [];
338	do {
339	$traits = array_merge(class_uses($class, $autoload), $traits);
340	} while($class = get_parent_class($class));
341	// Get traits of all parent traits
342	$traits_to_search = $traits;
343	while (!empty($traits_to_search)) {
344	$new_traits = class_uses(array_pop($traits_to_search), $autoload);
345	$traits = array_merge($new_traits, $traits);
346	$traits_to_search = array_merge($new_traits, $traits_to_search);
347	};
348	ksort($traits, SORT_NATURAL \| SORT_FLAG_CASE);
349	return array_unique($traits);
350	}
351
352	public static function relations($classes) {
353	$classUses = [];
354	$classUsedBy = [];
355
356	foreach($classes as $className => $fileName) {
357	try {
358	$reflectionClass = new ReflectionClass($className);
359	$classStructure = array_merge(
360	self::class_parents($className, false),
361	self::class_implements($className, false),
362	//self::class_uses_deep($className, false),
363	self::calls($reflectionClass->getFilename())
364	);
365	if(!empty($classStructure)) {
366	ksort($classStructure, SORT_NATURAL \| SORT_FLAG_CASE);
367	$classUses[$className] = $classStructure;
368	foreach($classUses[$className] as $usedBy) {
369	if($usedBy !== 'Reflector' && $usedBy !== 'static') {
370	$classUsedBy[$usedBy][$className] = $className;
371	}
372	}
373	if(!empty($classUsedBy[$usedBy])) {
374	ksort($classUsedBy[$usedBy], SORT_NATURAL \| SORT_FLAG_CASE);
375	}
376	}
377
378	} catch (Exception $e) { $classUses[$className][] = "<span class='error'>reflection error</span>"; }
379	}
380	ksort($classUses, SORT_NATURAL \| SORT_FLAG_CASE);
381	ksort($classUsedBy, SORT_NATURAL \| SORT_FLAG_CASE);
382	return [
383	'uses' => $classUses,
384	'usedBy' => $classUsedBy
385	];
386	}
387
388	/**
389	* @param array $array
390	* @param string $separator
391	* @param string $baseWebPath
392	* @return array
393	*/
394	public static function expandKeyToArray($array, $separator, $baseWebPath) {
395	$ret = [];
396	ksort($array, SORT_NATURAL \| SORT_FLAG_CASE);
397	foreach($array as $k => $d) {
398	$pointer = &$ret;
399	$path = explode($separator, $k );
400	$len = count($path);
401	$i=0;
402	foreach($path as $p) {
403	++$i;
404	if($i === $len) {
405	$urlencode = urlencode($k);
406	$pointer[] = "<a href='$baseWebPath/showDoc.php?fqn=$urlencode' >$p</a> <a class=nodecoration href='$baseWebPath/showToolbox.php?fqn=$urlencode' ><sup>🔧</sup></a>";
407	} else {
408	if(!array_key_exists($p, $pointer)) {
409	$pointer[$p] = [];
410	}
411	$pointer = &$pointer[$p];
412	}
413	}
414	}
415	return $ret;
416	}
417
418	public static function methodDocBlockProtected($className, $methodName) {
419	try {
420	$ref = new ReflectionClass($className);
421	$method = $ref->getMethod($methodName);
422	return str_replace('$',"\\$", $method->getDocComment());
423	} catch(Exception $e) {
424	return '/** Exception finding docblock '.$e->getMessage().' */';
425	}
426	}
427	}