Debugger::getDebugInformationResource() - Code Metrics - Inspection of "Update expected result in DebuggerTest for array a..." - xicrow/php-debug - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c43d65...cb0b56 )

by Jan

created 2016-06-11 11:50 UTC

Debugger::getDebugInformationResource() A

↳ Parent: Debugger

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php
namespace Xicrow\PhpDebug;

/**
 * Class Debugger
 *
 * @package Xicrow\PhpDebug
 */
class Debugger {
	/**
	 * @var bool
	 */
	public static $output = true;

	/**
	 * @var bool
	 */
	public static $showCalledFrom = true;

	/**
	 * @var string|null
	 */
	public static $documentRoot = null;

	/**
	 * @param string $data
	 *
	 * @codeCoverageIgnore
	 */
	public static function output($data) {
		if (!self::$output || !is_string($data)) {
			return;
		}

		if (php_sapi_name() == 'cli') {
			$data = (self::$showCalledFrom ? self::getCalledFrom(2) . "\n" . $data : $data);

			echo '#################### DEBUG ####################';
			echo "\n";
			echo $data;
			echo "\n";
		} else {
			$data = (self::$showCalledFrom ? '<strong>' . self::getCalledFrom(2) . '</strong>' . "\n" . $data : $data);

			$style   = [];
			$style[] = 'margin:5px 0;';
			$style[] = 'padding:5px;';
			$style[] = 'font-family:Consolas,Courier New,​monospace;';
			$style[] = 'font-weight:normal;';
			$style[] = 'font-size:13px;';
			$style[] = 'line-height:1.2;';
			$style[] = 'color:#555;';
			$style[] = 'background:#F9F9F9;';
			$style[] = 'border:1px solid #CCC;';
			$style[] = 'display:block;';
			$style[] = 'overflow:auto;';

			echo '<pre style="' . implode(' ', $style) . '">';
			echo $data;
			echo '</pre>';
		}
	}

	/**
	 * @param mixed $data
	 *
	 * @codeCoverageIgnore
	 */
	public static function debug($data) {
		self::output(self::getDebugInformation($data));
	}

	/**
	 * @param bool $reverse
	 *
	 * @codeCoverageIgnore
	 */
	public static function showTrace($reverse = false) {
		$backtrace = ($reverse ? array_reverse(debug_backtrace()) : debug_backtrace());

		$output     = '';
		$traceIndex = ($reverse ? 1 : count($backtrace));
		foreach ($backtrace as $trace) {
			$output .= $traceIndex . ': ';
			$output .= self::getCalledFromTrace($trace);
			$output .= "\n";

			$traceIndex += ($reverse ? 1 : -1);
		}

		self::output($output);
	}

	/**
	 * @param string $class
	 * @param bool   $output
	 *
	 * @return string
	 */
	public static function reflectClass($class, $output = true) {
		$data = '';

		$reflectionClass = new \ReflectionClass($class);

		$comment = $reflectionClass->getDocComment();
		if (!empty($comment)) {
			$data .= $comment;
			$data .= "\n";
		}

		$data .= 'class ' . $reflectionClass->name . '{';
		$firstElement = true;
		foreach ($reflectionClass->getProperties() as $reflectionProperty) {
			if (!$firstElement) {
				$data .= "\n";
			}
			$firstElement = false;

			$data .= self::reflectClassProperty($class, $reflectionProperty->name, false);
		}

		foreach ($reflectionClass->getMethods() as $reflectionMethod) {
			if (!$firstElement) {
				$data .= "\n";
			}
			$firstElement = false;

			$data .= self::reflectClassMethod($class, $reflectionMethod->name, false);
		}
		$data .= "\n";
		$data .= '}';

		if ($output) {
			self::output($data);
		}

		return $data;
	}

	/**
	 * @param string $class
	 * @param string $property
	 *
	 * @return string
	 */
	public static function reflectClassProperty($class, $property, $output = true) {
		$data = '';

		$reflectionClass    = new \ReflectionClass($class);
		$reflectionProperty = new \ReflectionProperty($class, $property);

		$defaultPropertyValues = $reflectionClass->getDefaultProperties();

		$comment = $reflectionProperty->getDocComment();
		if (!empty($comment)) {
			$data .= "\n";
			$data .= "\t";
			$data .= $comment;
		}

		$data .= "\n";
		$data .= "\t";
		$data .= ($reflectionProperty->isPublic() ? 'public ' : '');
		$data .= ($reflectionProperty->isPrivate() ? 'private ' : '');
		$data .= ($reflectionProperty->isProtected() ? 'protected ' : '');
		$data .= ($reflectionProperty->isStatic() ? 'static ' : '');
		$data .= '$' . $reflectionProperty->name;
		if (isset($defaultPropertyValues[$property])) {
			$data .= ' = ' . self::getDebugInformation($defaultPropertyValues[$property]);
		}
		$data .= ';';

		if ($output) {
			self::output($data);
		}

		return $data;
	}

	/**
	 * @param string $class
	 * @param string $method
	 *
	 * @return string
	 */
	public static function reflectClassMethod($class, $method, $output = true) {
		$data = '';

		$reflectionMethod = new \ReflectionMethod($class, $method);

		$comment = $reflectionMethod->getDocComment();
		if (!empty($comment)) {
			$data .= "\n";
			$data .= "\t";
			$data .= $comment;
		}

		$data .= "\n";
		$data .= "\t";
		$data .= ($reflectionMethod->isPublic() ? 'public ' : '');
		$data .= ($reflectionMethod->isPrivate() ? 'private ' : '');
		$data .= ($reflectionMethod->isProtected() ? 'protected ' : '');
		$data .= ($reflectionMethod->isStatic() ? 'static ' : '');
		$data .= 'function ' . $reflectionMethod->name . '(';
		if ($reflectionMethod->getNumberOfParameters()) {
			foreach ($reflectionMethod->getParameters() as $reflectionMethodParameterIndex => $reflectionMethodParameter) {
				$data .= ($reflectionMethodParameterIndex > 0 ? ', ' : '');
				$data .= '$' . $reflectionMethodParameter->name;
				if ($reflectionMethodParameter->isDefaultValueAvailable()) {
					$defaultValue = self::getDebugInformation($reflectionMethodParameter->getDefaultValue());
					$defaultValue = str_replace(["\n", "\t"], '', $defaultValue);
					$data .= ' = ' . $defaultValue;
				}
			}
		}
		$data .= ') {}';

		if ($output) {
			self::output($data);
		}

		return $data;
	}

	/**
	 * @param int $index
	 *
	 * @return string
	 */
	public static function getCalledFrom($index = 0) {
		$backtrace = debug_backtrace();

		if (!isset($backtrace[$index])) {
			return 'Unknown trace with index: ' . $index;
		}

		return self::getCalledFromTrace($backtrace[$index]);
	}

	/**
	 * @param array $trace
	 *
	 * @return string
	 */
	public static function getCalledFromTrace($trace) {
		// Get file and line number
		$calledFromFile = '';
		if (isset($trace['file'])) {
			$calledFromFile .= $trace['file'] . ' line ' . $trace['line'];
			$calledFromFile = str_replace('\\', '/', $calledFromFile);
			$calledFromFile = (!empty(self::$documentRoot) ? substr($calledFromFile, strlen(self::$documentRoot)) : $calledFromFile);
			$calledFromFile = trim($calledFromFile, '/');
		}

		// Get function call
		$calledFromFunction = '';
		if (isset($trace['function'])) {
			$calledFromFunction .= (isset($trace['class']) ? $trace['class'] : '');
			$calledFromFunction .= (isset($trace['type']) ? $trace['type'] : '');
			$calledFromFunction .= $trace['function'] . '()';
		}

		if (!empty($calledFromFunction) && !empty($calledFromFile)) {
			$calledFromFunction = ' > ' . $calledFromFunction;
		}

		return $calledFromFile . $calledFromFunction;
	}

	/**
	 * @param mixed $data
	 *
	 * @return string
	 */
	public static function getDebugInformation($data, array $options = []) {
		$options = array_merge([
			'depth'  => 25,
			'indent' => 0
		], $options);

		$dataType = gettype($data);

		$methodName = 'getDebugInformation' . ucfirst(strtolower($dataType));

		$result = 'No method found supporting data type: ' . $dataType;
		if ($dataType == 'string') {
			$result = (string) '"' . $data . '"';
		} elseif (method_exists('\Xicrow\PhpDebug\Debugger', $methodName)) {
			$result = (string) self::$methodName($data, [
				'depth'  => ($options['depth'] - 1),
				'indent' => ($options['indent'] + 1)
			]);
		}

		return $result;
	}

	/**
	 * @return string
	 */
	private static function getDebugInformationNull() {
		return 'NULL';
	}

	/**
	 * @param boolean $data
	 *
	 * @return string
	 */
	private static function getDebugInformationBoolean($data) {
		return ($data ? 'TRUE' : 'FALSE');
	}

	/**
	 * @param integer $data
	 *
	 * @return string
	 */
	private static function getDebugInformationInteger($data) {
		return (string) $data;
	}

	/**
	 * @param double $data
	 *
	 * @return string
	 */
	private static function getDebugInformationDouble($data) {
		return (string) $data;
	}

	/**
	 * @param array $data
	 *
	 * @return string
	 */
	private static function getDebugInformationArray($data, array $options = []) {
		$options = array_merge([
			'depth'  => 25,
			'indent' => 0
		], $options);

		$debugInfo = "[";

		$break = $end = null;
		if (!empty($data)) {
			$break = "\n" . str_repeat("\t", $options['indent']);
			$end   = "\n" . str_repeat("\t", $options['indent'] - 1);
		}

		$datas = [];
		if ($options['depth'] >= 0) {
			foreach ($data as $key => $val) {
				// Sniff for globals as !== explodes in < 5.4
				if ($key === 'GLOBALS' && is_array($val) && isset($val['GLOBALS'])) {
					$val = '[recursion]';
				} elseif ($val !== $data) {
					$val = static::getDebugInformation($val, $options);
				}
				$datas[] = $break . static::getDebugInformation($key) . ' => ' . $val;
			}
		} else {
			$datas[] = $break . '[maximum depth reached]';
		}

		return $debugInfo . implode(',', $datas) . $end . ']';
	}

	/**
	 * @param object $data
	 *
	 * @return string
	 */
	private static function getDebugInformationObject($data, array $options = []) {
		$options = array_merge([
			'depth'  => 25,
			'indent' => 0
		], $options);

		$debugInfo = '';
		$debugInfo .= 'object(' . get_class($data) . ') {';

		$break = "\n" . str_repeat("\t", $options['indent']);
		$end   = "\n" . str_repeat("\t", $options['indent'] - 1);

		if ($options['depth'] > 0 && method_exists($data, '__debugInfo')) {
			try {
				$debugArray = static::getDebugInformationArray($data->__debugInfo(), array_merge($options, [
class YourClass
{
    private static function getTemperature() {
        return "3422 °C";
}

public static function getSomeVariable()
{
    return static::getTemperature();
}
					'depth' => ($options['depth'] - 1)
				]));
				$debugInfo .= substr($debugArray, 1, -1);

				return $debugInfo . $end . '}';
			} catch (\Exception $e) {
				$message = $e->getMessage();

				return $debugInfo . "\n(unable to export object: $message)\n }";
			}
		}

		if ($options['depth'] > 0) {
			$props      = [];
			$objectVars = get_object_vars($data);
			foreach ($objectVars as $key => $value) {
				$value   = static::getDebugInformation($value, array_merge($options, [
					'depth' => ($options['depth'] - 1)
				]));
				$props[] = "$key => " . $value;
			}

			$ref     = new \ReflectionObject($data);
			$filters = [
				\ReflectionProperty::IS_PROTECTED => 'protected',
				\ReflectionProperty::IS_PRIVATE   => 'private',
			];
			foreach ($filters as $filter => $visibility) {
				$reflectionProperties = $ref->getProperties($filter);
				foreach ($reflectionProperties as $reflectionProperty) {
					$reflectionProperty->setAccessible(true);
					$property = $reflectionProperty->getValue($data);

					$value   = static::getDebugInformation($property, array_merge($options, [
						'depth' => ($options['depth'] - 1)
					]));
					$key     = $reflectionProperty->name;
					$props[] = sprintf('[%s] %s => %s', $visibility, $key, $value);
				}
			}

			$debugInfo .= $break . implode($break, $props) . $end;
		}
		$debugInfo .= '}';

		return $debugInfo;
	}

	/**
	 * @param resource $data
	 *
	 * @return string
	 */
	private static function getDebugInformationResource($data) {
		return (string) $data . ' (' . get_resource_type($data) . ')';
	}
}


1		<?php
2		namespace Xicrow\PhpDebug;
3
4		/**
5		* Class Debugger
6		*
7		* @package Xicrow\PhpDebug
8		*/
9		class Debugger {
10		/**
11		* @var bool
12		*/
13		public static $output = true;
14
15		/**
16		* @var bool
17		*/
18		public static $showCalledFrom = true;
19
20		/**
21		* @var string\|null
22		*/
23		public static $documentRoot = null;
24
25		/**
26		* @param string $data
27		*
28		* @codeCoverageIgnore
29		*/
30		public static function output($data) {
31		if (!self::$output \|\| !is_string($data)) {
32		return;
33		}
34
35		if (php_sapi_name() == 'cli') {
36		$data = (self::$showCalledFrom ? self::getCalledFrom(2) . "\n" . $data : $data);
37
38		echo '#################### DEBUG ####################';
39		echo "\n";
40		echo $data;
41		echo "\n";
42		} else {
43		$data = (self::$showCalledFrom ? '<strong>' . self::getCalledFrom(2) . '</strong>' . "\n" . $data : $data);
44
45		$style = [];
46		$style[] = 'margin:5px 0;';
47		$style[] = 'padding:5px;';
48		$style[] = 'font-family:Consolas,Courier New,monospace;';
49		$style[] = 'font-weight:normal;';
50		$style[] = 'font-size:13px;';
51		$style[] = 'line-height:1.2;';
52		$style[] = 'color:#555;';
53		$style[] = 'background:#F9F9F9;';
54		$style[] = 'border:1px solid #CCC;';
55		$style[] = 'display:block;';
56		$style[] = 'overflow:auto;';
57
58		echo '<pre style="' . implode(' ', $style) . '">';
59		echo $data;
60		echo '</pre>';
61		}
62		}
63
64		/**
65		* @param mixed $data
66		*
67		* @codeCoverageIgnore
68		*/
69		public static function debug($data) {
70		self::output(self::getDebugInformation($data));
71		}
72
73		/**
74		* @param bool $reverse
75		*
76		* @codeCoverageIgnore
77		*/
78		public static function showTrace($reverse = false) {
79		$backtrace = ($reverse ? array_reverse(debug_backtrace()) : debug_backtrace());
80
81		$output = '';
82		$traceIndex = ($reverse ? 1 : count($backtrace));
83		foreach ($backtrace as $trace) {
84		$output .= $traceIndex . ': ';
85		$output .= self::getCalledFromTrace($trace);
86		$output .= "\n";
87
88		$traceIndex += ($reverse ? 1 : -1);
89		}
90
91		self::output($output);
92		}
93
94		/**
95		* @param string $class
96		* @param bool $output
97		*
98		* @return string
99		*/
100	1	public static function reflectClass($class, $output = true) {
101	1	$data = '';
102
103	1	$reflectionClass = new \ReflectionClass($class);
104
105	1	$comment = $reflectionClass->getDocComment();
106	1	if (!empty($comment)) {
107	1	$data .= $comment;
108	1	$data .= "\n";
109	1	}
110
111	1	$data .= 'class ' . $reflectionClass->name . '{';
112	1	$firstElement = true;
113	1	foreach ($reflectionClass->getProperties() as $reflectionProperty) {
114	1	if (!$firstElement) {
115	1	$data .= "\n";
116	1	}
117	1	$firstElement = false;
118
119	1	$data .= self::reflectClassProperty($class, $reflectionProperty->name, false);
120	1	}
121
122	1	foreach ($reflectionClass->getMethods() as $reflectionMethod) {
123	1	if (!$firstElement) {
124	1	$data .= "\n";
125	1	}
126	1	$firstElement = false;
127
128	1	$data .= self::reflectClassMethod($class, $reflectionMethod->name, false);
129	1	}
130	1	$data .= "\n";
131	1	$data .= '}';
132
133	1	if ($output) {
134	1	self::output($data);
135	1	}
136
137	1	return $data;
138		}
139
140		/**
141		* @param string $class
142		* @param string $property
143		*
144		* @return string
145		*/
146	2	public static function reflectClassProperty($class, $property, $output = true) {
147	2	$data = '';
148
149	2	$reflectionClass = new \ReflectionClass($class);
150	2	$reflectionProperty = new \ReflectionProperty($class, $property);
151
152	2	$defaultPropertyValues = $reflectionClass->getDefaultProperties();
153
154	2	$comment = $reflectionProperty->getDocComment();
155	2	if (!empty($comment)) {
156	2	$data .= "\n";
157	2	$data .= "\t";
158	2	$data .= $comment;
159	2	}
160
161	2	$data .= "\n";
162	2	$data .= "\t";
163	2	$data .= ($reflectionProperty->isPublic() ? 'public ' : '');
164	2	$data .= ($reflectionProperty->isPrivate() ? 'private ' : '');
165	2	$data .= ($reflectionProperty->isProtected() ? 'protected ' : '');
166	2	$data .= ($reflectionProperty->isStatic() ? 'static ' : '');
167	2	$data .= '$' . $reflectionProperty->name;
168	2	if (isset($defaultPropertyValues[$property])) {
169	2	$data .= ' = ' . self::getDebugInformation($defaultPropertyValues[$property]);
170	2	}
171	2	$data .= ';';
172
173	2	if ($output) {
174	1	self::output($data);
175	1	}
176
177	2	return $data;
178		}
179
180		/**
181		* @param string $class
182		* @param string $method
183		*
184		* @return string
185		*/
186	2	public static function reflectClassMethod($class, $method, $output = true) {
187	2	$data = '';
188
189	2	$reflectionMethod = new \ReflectionMethod($class, $method);
190
191	2	$comment = $reflectionMethod->getDocComment();
192	2	if (!empty($comment)) {
193	2	$data .= "\n";
194	2	$data .= "\t";
195	2	$data .= $comment;
196	2	}
197
198	2	$data .= "\n";
199	2	$data .= "\t";
200	2	$data .= ($reflectionMethod->isPublic() ? 'public ' : '');
201	2	$data .= ($reflectionMethod->isPrivate() ? 'private ' : '');
202	2	$data .= ($reflectionMethod->isProtected() ? 'protected ' : '');
203	2	$data .= ($reflectionMethod->isStatic() ? 'static ' : '');
204	2	$data .= 'function ' . $reflectionMethod->name . '(';
205	2	if ($reflectionMethod->getNumberOfParameters()) {
206	2	foreach ($reflectionMethod->getParameters() as $reflectionMethodParameterIndex => $reflectionMethodParameter) {
207	2	$data .= ($reflectionMethodParameterIndex > 0 ? ', ' : '');
208	2	$data .= '$' . $reflectionMethodParameter->name;
209	2	if ($reflectionMethodParameter->isDefaultValueAvailable()) {
210	2	$defaultValue = self::getDebugInformation($reflectionMethodParameter->getDefaultValue());
211	2	$defaultValue = str_replace(["\n", "\t"], '', $defaultValue);
212	2	$data .= ' = ' . $defaultValue;
213	2	}
214	2	}
215	2	}
216	2	$data .= ') {}';
217
218	2	if ($output) {
219	1	self::output($data);
220	1	}
221
222	2	return $data;
223		}
224
225		/**
226		* @param int $index
227		*
228		* @return string
229		*/
230	1	public static function getCalledFrom($index = 0) {
231	1	$backtrace = debug_backtrace();
232
233	1	if (!isset($backtrace[$index])) {
234	1	return 'Unknown trace with index: ' . $index;
235		}
236
237	1	return self::getCalledFromTrace($backtrace[$index]);
238		}
239
240		/**
241		* @param array $trace
242		*
243		* @return string
244		*/
245	1	public static function getCalledFromTrace($trace) {
246		// Get file and line number
247	1	$calledFromFile = '';
248	1	if (isset($trace['file'])) {
249	1	$calledFromFile .= $trace['file'] . ' line ' . $trace['line'];
250	1	$calledFromFile = str_replace('\\', '/', $calledFromFile);
251	1	$calledFromFile = (!empty(self::$documentRoot) ? substr($calledFromFile, strlen(self::$documentRoot)) : $calledFromFile);
252	1	$calledFromFile = trim($calledFromFile, '/');
253	1	}
254
255		// Get function call
256	1	$calledFromFunction = '';
257	1	if (isset($trace['function'])) {
258	1	$calledFromFunction .= (isset($trace['class']) ? $trace['class'] : '');
259	1	$calledFromFunction .= (isset($trace['type']) ? $trace['type'] : '');
260	1	$calledFromFunction .= $trace['function'] . '()';
261	1	}
262
263	1	if (!empty($calledFromFunction) && !empty($calledFromFile)) {
264	1	$calledFromFunction = ' > ' . $calledFromFunction;
265	1	}
266
267	1	return $calledFromFile . $calledFromFunction;
268		}
269
270		/**
271		* @param mixed $data
272		*
273		* @return string
274		*/
275	1	public static function getDebugInformation($data, array $options = []) {
276	1	$options = array_merge([
277	1	'depth' => 25,
278		'indent' => 0
279	1	], $options);
280
281	1	$dataType = gettype($data);
282
283	1	$methodName = 'getDebugInformation' . ucfirst(strtolower($dataType));
284
285	1	$result = 'No method found supporting data type: ' . $dataType;
286	1	if ($dataType == 'string') {
287	1	$result = (string) '"' . $data . '"';
288	1	} elseif (method_exists('\Xicrow\PhpDebug\Debugger', $methodName)) {
289	1	$result = (string) self::$methodName($data, [
290	1	'depth' => ($options['depth'] - 1),
291	1	'indent' => ($options['indent'] + 1)
292	1	]);
293	1	}
294
295	1	return $result;
296		}
297
298		/**
299		* @return string
300		*/
301	1	private static function getDebugInformationNull() {
302	1	return 'NULL';
303		}
304
305		/**
306		* @param boolean $data
307		*
308		* @return string
309		*/
310	1	private static function getDebugInformationBoolean($data) {
311	1	return ($data ? 'TRUE' : 'FALSE');
312		}
313
314		/**
315		* @param integer $data
316		*
317		* @return string
318		*/
319	1	private static function getDebugInformationInteger($data) {
320	1	return (string) $data;
321		}
322
323		/**
324		* @param double $data
325		*
326		* @return string
327		*/
328	1	private static function getDebugInformationDouble($data) {
329	1	return (string) $data;
330		}
331
332		/**
333		* @param array $data
334		*
335		* @return string
336		*/
337	1	private static function getDebugInformationArray($data, array $options = []) {
338	1	$options = array_merge([
339	1	'depth' => 25,
340		'indent' => 0
341	1	], $options);
342
343	1	$debugInfo = "[";
344
345	1	$break = $end = null;
346	1	if (!empty($data)) {
347	1	$break = "\n" . str_repeat("\t", $options['indent']);
348	1	$end = "\n" . str_repeat("\t", $options['indent'] - 1);
349	1	}
350
351	1	$datas = [];
352	1	if ($options['depth'] >= 0) {
353	1	foreach ($data as $key => $val) {
354		// Sniff for globals as !== explodes in < 5.4
355	1	if ($key === 'GLOBALS' && is_array($val) && isset($val['GLOBALS'])) {
356		$val = '[recursion]';
357	1	} elseif ($val !== $data) {
358	1	$val = static::getDebugInformation($val, $options);
359	1	}
360	1	$datas[] = $break . static::getDebugInformation($key) . ' => ' . $val;
361	1	}
362	1	} else {
363		$datas[] = $break . '[maximum depth reached]';
364		}
365
366	1	return $debugInfo . implode(',', $datas) . $end . ']';
367		}
368
369		/**
370		* @param object $data
371		*
372		* @return string
373		*/
374	1	private static function getDebugInformationObject($data, array $options = []) {
375	1	$options = array_merge([
376	1	'depth' => 25,
377		'indent' => 0
378	1	], $options);
379
380	1	$debugInfo = '';
381	1	$debugInfo .= 'object(' . get_class($data) . ') {';
382
383	1	$break = "\n" . str_repeat("\t", $options['indent']);
384	1	$end = "\n" . str_repeat("\t", $options['indent'] - 1);
385
386	1	if ($options['depth'] > 0 && method_exists($data, '__debugInfo')) {
387		try {
388		$debugArray = static::getDebugInformationArray($data->__debugInfo(), array_merge($options, [
		0 ignored issues – show Bug introduced 2016-06-08 14:03 UTC by Report Bug Copy Issue Report Since `getDebugInformationArray()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `getDebugInformationArray()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
389		'depth' => ($options['depth'] - 1)
390		]));
391		$debugInfo .= substr($debugArray, 1, -1);
392
393		return $debugInfo . $end . '}';
394		} catch (\Exception $e) {
395		$message = $e->getMessage();
396
397		return $debugInfo . "\n(unable to export object: $message)\n }";
398		}
399		}
400
401	1	if ($options['depth'] > 0) {
402	1	$props = [];
403	1	$objectVars = get_object_vars($data);
404	1	foreach ($objectVars as $key => $value) {
405	1	$value = static::getDebugInformation($value, array_merge($options, [
406	1	'depth' => ($options['depth'] - 1)
407	1	]));
408	1	$props[] = "$key => " . $value;
409	1	}
410
411	1	$ref = new \ReflectionObject($data);
412		$filters = [
413	1	\ReflectionProperty::IS_PROTECTED => 'protected',
414	1	\ReflectionProperty::IS_PRIVATE => 'private',
415	1	];
416	1	foreach ($filters as $filter => $visibility) {
417	1	$reflectionProperties = $ref->getProperties($filter);
418	1	foreach ($reflectionProperties as $reflectionProperty) {
419		$reflectionProperty->setAccessible(true);
420		$property = $reflectionProperty->getValue($data);
421
422		$value = static::getDebugInformation($property, array_merge($options, [
423		'depth' => ($options['depth'] - 1)
424		]));
425		$key = $reflectionProperty->name;
426		$props[] = sprintf('[%s] %s => %s', $visibility, $key, $value);
427	1	}
428	1	}
429
430	1	$debugInfo .= $break . implode($break, $props) . $end;
431	1	}
432	1	$debugInfo .= '}';
433
434	1	return $debugInfo;
435		}
436
437		/**
438		* @param resource $data
439		*
440		* @return string
441		*/
442	1	private static function getDebugInformationResource($data) {
443	1	return (string) $data . ' (' . get_resource_type($data) . ')';
444		}
445		}
446

xicrow / php-debug

Push — master ( c43d65...cb0b56 )

Debugger::getDebugInformationResource() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like