13566190336

Committed 27 Feb 2025 12:18PM UTC coverage: 72.127% (-0.6%) from 72.746%

Build # 13566190336

Build Type

push

github

Committed by

NamelessCoder

Commit Message

[TER] 7.1.0

Run Details

5649 of 7832 relevant lines covered (72.13%)

20.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.82

/Classes/ViewHelpers/DebugViewHelper.php

<?php
namespace FluidTYPO3\Vhs\ViewHelpers;

/*
 * This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
 *
 * For the full copyright and license information, please read the
 * LICENSE.md file that was distributed with this source code.
 */

use TYPO3\CMS\Extbase\Reflection\Exception\PropertyNotAccessibleException;
use TYPO3\CMS\Extbase\Reflection\ObjectAccess;
use TYPO3\CMS\Extbase\Utility\DebuggerUtility;
use TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\NodeInterface;
use TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\ObjectAccessorNode;
use TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\ViewHelperNode;
use TYPO3Fluid\Fluid\Core\ViewHelper\AbstractViewHelper;

/**
 * ### ViewHelper Debug ViewHelper (sic)
 *
 * Debugs instances of other ViewHelpers and language
 * structures. Use in conjunction with other ViewHelpers
 * to inspect their current and possible arguments and
 * render their documentation:
 *
 * ```
 * <v:debug><f:format.html>{variable}</f:format.html></v:debug>
 * ```
 *
 * Or the same expression in inline syntax:
 *
 * ```
 * {variable -> f:format.html() -> v:debug()}
 * ```
 *
 * Can also be used to inspect `ObjectAccessor` instances
 * (e.g. variables you try to access) and rather than just
 * dumping the entire contents of the variable as is done
 * by `<f:debug />`, this ViewHelper makes a very simple
 * dump with a warning if the variable is not defined. If
 * an object is encountered (for example a domain object)
 * this ViewHelper will not dump the object but instead
 * will scan it for accessible properties (e.g. properties
 * which have a getter method!) and only present those
 * properties which can be accessed, along with the type
 * of variable that property currently contains:
 *
 * ```
 * {domainObject -> v:debug()}
 * ```
 *
 * Assuming that `{domainObject}` is an instance of an
 * object which has two methods: `getUid()` and `getTitle()`,
 * debugging that instance will render something like this
 * in plain text:
 *
 * ```
 * Path: {domainObject}
 * Value type: object
 * Accessible properties on {domainObject}:
 *    {form.uid} (integer)
 *    {form.title} (string)
 * ```
 *
 * The class itself can contain any number of protected
 * properties, but only those which have a getter method
 * can be accessed by Fluid and as therefore we only dump
 * those properties which you **can in fact access**.
 */
class DebugViewHelper extends AbstractViewHelper
{
    /**
     * @var ViewHelperNode[]
     */
    protected array $childViewHelperNodes = [];

    /**
     * @var ObjectAccessorNode[]
     */
    protected array $childObjectAccessorNodes = [];

    /**
     * @var boolean
     */
    protected $escapeOutput = false;

    /**
     * @var boolean
     */
    protected $escapeChildren = false;

    /**
     * @return string
     */
    public function render()
    {
        $nodes = [];
        foreach ($this->childViewHelperNodes as $viewHelperNode) {
            $viewHelper = $viewHelperNode->getUninitializedViewHelper();
            $arguments = $viewHelper->prepareArguments();
            $givenArguments = $viewHelperNode->getArguments();
            $viewHelperReflection = new \ReflectionClass($viewHelper);
            $viewHelperDescription = $viewHelperReflection->getDocComment();
            $viewHelperDescription = htmlentities((string) $viewHelperDescription);
            $viewHelperDescription = '[CLASS DOC]' . LF . $viewHelperDescription . LF;
            $renderMethodDescription = $viewHelperReflection->getMethod('render')->getDocComment();
            $renderMethodDescription = htmlentities((string) $renderMethodDescription);
            $renderMethodDescription = implode(LF, array_map('trim', explode(LF, $renderMethodDescription)));
            $renderMethodDescription = '[RENDER METHOD DOC]' . LF . $renderMethodDescription . LF;
            $argumentDefinitions = [];
            foreach ($arguments as $argument) {
                $name = $argument->getName();
                $argumentDefinitions[$name] = ObjectAccess::getGettableProperties($argument);
            }
            $sections = [
                $viewHelperDescription,
                DebuggerUtility::var_dump($argumentDefinitions, '[ARGUMENTS]', 4, true, false, true),
                DebuggerUtility::var_dump($givenArguments, '[CURRENT ARGUMENTS]', 4, true, false, true),
                $renderMethodDescription
            ];
            $nodes[] = implode(LF, $sections);
        }
        if (0 < count($this->childObjectAccessorNodes)) {
            $nodes[] = '[VARIABLE ACCESSORS]';
            /** @var array|object $templateVariables */
            $templateVariables = $this->renderingContext->getVariableProvider()->getAll();
            foreach ($this->childObjectAccessorNodes as $objectAccessorNode) {
                $path = $objectAccessorNode->getObjectPath();
                $segments = explode('.', $path);
                try {
                    $value = ObjectAccess::getProperty($templateVariables, array_shift($segments));
                    foreach ($segments as $segment) {
                        if (!is_array($value) && !is_object($value)) {
                            break;
                        }
                        $value = ObjectAccess::getProperty($value, $segment);
                    }
                    $type = gettype($value);
                } catch (PropertyNotAccessibleException $error) {
                    $value = null;
                    $type = 'UNDEFINED/INACCESSIBLE';
                }
                $sections = [
                    'Path: {' . $path . '}',
                    'Value type: ' . $type,
                ];
                if (is_object($value)) {
                    $sections[] = 'Accessible properties on {' . $path . '}:';
                    $gettable = ObjectAccess::getGettablePropertyNames($value);
                    unset($gettable[0]);
                    foreach ($gettable as $gettableProperty) {
                        $sections[] = '   {' . $path . '.' . $gettableProperty . '} (' .
                            gettype(ObjectAccess::getProperty($value, $gettableProperty)) . ')';
                    }
                } elseif (null !== $value) {
                    $sections[] = DebuggerUtility::var_dump(
                        $value,
                        'Dump of variable "' . $path . '"',
                        4,
                        true,
                        false,
                        true
                    );
                }
                $nodes[] = implode(LF, $sections);
            }
        }
        return '<pre>' . implode(LF . LF, $nodes) . '</pre>';
    }

    /**
     * Sets the direct child nodes of the current syntax tree node.
     *
     * @param NodeInterface[] $childNodes
     */
    public function setChildNodes(array $childNodes): void
    {
        foreach ($childNodes as $childNode) {
            if ($childNode instanceof ViewHelperNode) {
                $this->childViewHelperNodes[] = $childNode;
            } elseif ($childNode instanceof ObjectAccessorNode) {
                $this->childObjectAccessorNodes[] = $childNode;
            }
        }
    }
}

1	<?php
2	namespace FluidTYPO3\Vhs\ViewHelpers;
3
4	/*
5	* This file is part of the FluidTYPO3/Vhs project under GPLv2 or later.
6	*
7	* For the full copyright and license information, please read the
8	* LICENSE.md file that was distributed with this source code.
9	*/
10
11	use TYPO3\CMS\Extbase\Reflection\Exception\PropertyNotAccessibleException;
12	use TYPO3\CMS\Extbase\Reflection\ObjectAccess;
13	use TYPO3\CMS\Extbase\Utility\DebuggerUtility;
14	use TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\NodeInterface;
15	use TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\ObjectAccessorNode;
16	use TYPO3Fluid\Fluid\Core\Parser\SyntaxTree\ViewHelperNode;
17	use TYPO3Fluid\Fluid\Core\ViewHelper\AbstractViewHelper;
18
19	/**
20	* ### ViewHelper Debug ViewHelper (sic)
21	*
22	* Debugs instances of other ViewHelpers and language
23	* structures. Use in conjunction with other ViewHelpers
24	* to inspect their current and possible arguments and
25	* render their documentation:
26	*
27	* ```
28	* <v:debug><f:format.html>{variable}</f:format.html></v:debug>
29	* ```
30	*
31	* Or the same expression in inline syntax:
32	*
33	* ```
34	* {variable -> f:format.html() -> v:debug()}
35	* ```
36	*
37	* Can also be used to inspect `ObjectAccessor` instances
38	* (e.g. variables you try to access) and rather than just
39	* dumping the entire contents of the variable as is done
40	* by `<f:debug />`, this ViewHelper makes a very simple
41	* dump with a warning if the variable is not defined. If
42	* an object is encountered (for example a domain object)
43	* this ViewHelper will not dump the object but instead
44	* will scan it for accessible properties (e.g. properties
45	* which have a getter method!) and only present those
46	* properties which can be accessed, along with the type
47	* of variable that property currently contains:
48	*
49	* ```
50	* {domainObject -> v:debug()}
51	* ```
52	*
53	* Assuming that `{domainObject}` is an instance of an
54	* object which has two methods: `getUid()` and `getTitle()`,
55	* debugging that instance will render something like this
56	* in plain text:
57	*
58	* ```
59	* Path: {domainObject}
60	* Value type: object
61	* Accessible properties on {domainObject}:
62	* {form.uid} (integer)
63	* {form.title} (string)
64	* ```
65	*
66	* The class itself can contain any number of protected
67	* properties, but only those which have a getter method
68	* can be accessed by Fluid and as therefore we only dump
69	* those properties which you can in fact access.
70	*/
71	class DebugViewHelper extends AbstractViewHelper
72	{
73	/**
74	* @var ViewHelperNode[]
75	*/
76	protected array $childViewHelperNodes = [];
77
78	/**
79	* @var ObjectAccessorNode[]
80	*/
81	protected array $childObjectAccessorNodes = [];
82
83	/**
84	* @var boolean
85	*/
86	protected $escapeOutput = false;
87
88	/**
89	* @var boolean
90	*/
91	protected $escapeChildren = false;
92
93	/**
94	* @return string
95	*/
96	public function render()
97	{
98	$nodes = [];	14✔
99	foreach ($this->childViewHelperNodes as $viewHelperNode) {	14✔
100	$viewHelper = $viewHelperNode->getUninitializedViewHelper();	7✔
101	$arguments = $viewHelper->prepareArguments();	7✔
102	$givenArguments = $viewHelperNode->getArguments();	7✔
103	$viewHelperReflection = new \ReflectionClass($viewHelper);	7✔
104	$viewHelperDescription = $viewHelperReflection->getDocComment();	7✔
105	$viewHelperDescription = htmlentities((string) $viewHelperDescription);	7✔
106	$viewHelperDescription = '[CLASS DOC]' . LF . $viewHelperDescription . LF;	7✔
107	$renderMethodDescription = $viewHelperReflection->getMethod('render')->getDocComment();	7✔
108	$renderMethodDescription = htmlentities((string) $renderMethodDescription);	7✔
109	$renderMethodDescription = implode(LF, array_map('trim', explode(LF, $renderMethodDescription)));	7✔
110	$renderMethodDescription = '[RENDER METHOD DOC]' . LF . $renderMethodDescription . LF;	7✔
111	$argumentDefinitions = [];	7✔
112	foreach ($arguments as $argument) {	7✔
113	$name = $argument->getName();	×
114	$argumentDefinitions[$name] = ObjectAccess::getGettableProperties($argument);	×
115	}
116	$sections = [	7✔
117	$viewHelperDescription,	7✔
118	DebuggerUtility::var_dump($argumentDefinitions, '[ARGUMENTS]', 4, true, false, true),	7✔
119	DebuggerUtility::var_dump($givenArguments, '[CURRENT ARGUMENTS]', 4, true, false, true),	7✔
120	$renderMethodDescription	7✔
121	];	7✔
122	$nodes[] = implode(LF, $sections);	7✔
123	}
124	if (0 < count($this->childObjectAccessorNodes)) {	14✔
125	$nodes[] = '[VARIABLE ACCESSORS]';	7✔
126	/** @var array\|object $templateVariables */
127	$templateVariables = $this->renderingContext->getVariableProvider()->getAll();	7✔
128	foreach ($this->childObjectAccessorNodes as $objectAccessorNode) {	7✔
129	$path = $objectAccessorNode->getObjectPath();	7✔
130	$segments = explode('.', $path);	7✔
131	try {
132	$value = ObjectAccess::getProperty($templateVariables, array_shift($segments));	7✔
133	foreach ($segments as $segment) {	7✔
134	if (!is_array($value) && !is_object($value)) {	7✔
135	break;	×
136	}
137	$value = ObjectAccess::getProperty($value, $segment);	7✔
138	}
139	$type = gettype($value);	7✔
140	} catch (PropertyNotAccessibleException $error) {	×
141	$value = null;	×
142	$type = 'UNDEFINED/INACCESSIBLE';	×
143	}
144	$sections = [	7✔
145	'Path: {' . $path . '}',	7✔
146	'Value type: ' . $type,	7✔
147	];	7✔
148	if (is_object($value)) {	7✔
149	$sections[] = 'Accessible properties on {' . $path . '}:';	×
150	$gettable = ObjectAccess::getGettablePropertyNames($value);	×
151	unset($gettable[0]);	×
152	foreach ($gettable as $gettableProperty) {	×
153	$sections[] = ' {' . $path . '.' . $gettableProperty . '} (' .	×
154	gettype(ObjectAccess::getProperty($value, $gettableProperty)) . ')';	×
155	}
156	} elseif (null !== $value) {	7✔
157	$sections[] = DebuggerUtility::var_dump(	7✔
158	$value,	7✔
159	'Dump of variable "' . $path . '"',	7✔
160	4,	7✔
161	true,	7✔
162	false,	7✔
163	true	7✔
164	);	7✔
165	}
166	$nodes[] = implode(LF, $sections);	7✔
167	}
168	}
169	return '<pre>' . implode(LF . LF, $nodes) . '</pre>';	14✔
170	}
171
172	/**
173	* Sets the direct child nodes of the current syntax tree node.
174	*
175	* @param NodeInterface[] $childNodes
176	*/
177	public function setChildNodes(array $childNodes): void
178	{
179	foreach ($childNodes as $childNode) {	14✔
180	if ($childNode instanceof ViewHelperNode) {	14✔
181	$this->childViewHelperNodes[] = $childNode;	7✔
182	} elseif ($childNode instanceof ObjectAccessorNode) {	7✔
183	$this->childObjectAccessorNodes[] = $childNode;	7✔
184	}
185	}
186	}
187	}

FluidTYPO3 / vhs / 13566190336

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous