ViewHelperResolver::resolveViewHelperName() - Code Metrics - Inspection of "[FEATURE] Support Vendor.Package as namespace name" - TYPO3/Fluid - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#329)

by Claus

created 2017-07-30 15:12 UTC

ViewHelperResolver::resolveViewHelperName() C

↳ Parent: ViewHelperResolver

Complexity

Conditions	7
Paths	16

Size

Total Lines	47
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	7
eloc	32
nc	16
nop	2
dl	0
loc	47
rs	6.7272
c	0
b	0
f	0

<?php
namespace TYPO3Fluid\Fluid\Core\ViewHelper;

/*
 * This file belongs to the package "TYPO3 Fluid".
 * See LICENSE.txt that was shipped with this package.
 */

use TYPO3Fluid\Fluid\Core\Parser\Exception as ParserException;
use TYPO3Fluid\Fluid\Core\Parser\Patterns;

/**
 * Class ViewHelperResolver
 *
 * Responsible for resolving instances of ViewHelpers and for
 * interacting with ViewHelpers; to translate ViewHelper names
 * into actual class names and resolve their ArgumentDefinitions.
 *
 * Replacing this class in for example a framework allows that
 * framework to be responsible for creating ViewHelper instances
 * and detecting possible arguments.
 */
class ViewHelperResolver
{

    /**
     * @var array
     */
    protected $resolvedViewHelperClassNames = [];

    /**
     * Namespaces requested by the template being rendered,
     * in [shortname => phpnamespace] format.
     *
     * @var array
     */
    protected $namespaces = [
        'f' => ['TYPO3Fluid\\Fluid\\ViewHelpers']
    ];

    /**
     * @return array
     */
    public function getNamespaces()
    {
        return $this->namespaces;
    }

    /**
     * Add a PHP namespace where ViewHelpers can be found and give
     * it an alias/identifier.
     *
     * The provided namespace can be either a single namespace or
     * an array of namespaces, as strings. The identifier/alias is
     * always a single, alpha-numeric ASCII string.
     *
     * Calling this method multiple times with different PHP namespaces
     * for the same alias causes that namespace to be *extended*,
     * meaning that the PHP namespace you provide second, third etc.
     * are also used in lookups and are used *first*, so that if any
     * of the namespaces you add contains a class placed and named the
     * same way as one that exists in an earlier namespace, then your
     * class gets used instead of the earlier one.
     *
     * Example:
     *
     * $resolver->addNamespace('my', 'My\Package\ViewHelpers');
     * // Any ViewHelpers under this namespace can now be accessed using for example {my:example()}
     * // Now, assuming you also have an ExampleViewHelper class in a different
     * // namespace and wish to make that ExampleViewHelper override the other:
     * $resolver->addNamespace('my', 'My\OtherPackage\ViewHelpers');
     * // Now, since ExampleViewHelper exists in both places but the
     * // My\OtherPackage\ViewHelpers namespace was added *last*, Fluid
     * // will find and use My\OtherPackage\ViewHelpers\ExampleViewHelper.
     *
     * Alternatively, setNamespaces() can be used to reset and redefine
     * all previously added namespaces - which is great for cases where
     * you need to remove or replace previously added namespaces. Be aware
     * that setNamespaces() also removes the default "f" namespace, so
     * when you use this method you should always include the "f" namespace.
     *
     * @param string $identifier
     * @param string|array $phpNamespace
     * @return void
     */
    public function addNamespace($identifier, $phpNamespace)
    {
        if (!array_key_exists($identifier, $this->namespaces) || $this->namespaces[$identifier] === null) {
            $this->namespaces[$identifier] = $phpNamespace === null ? null : (array) $phpNamespace;
        } elseif (is_array($phpNamespace)) {
            $this->namespaces[$identifier] = array_unique(array_merge($this->namespaces[$identifier], $phpNamespace));
        } elseif (isset($this->namespaces[$identifier]) && !in_array($phpNamespace, $this->namespaces[$identifier])) {
            $this->namespaces[$identifier][] = $phpNamespace;
        }
    }

    /**
     * Wrapper to allow adding namespaces in bulk *without* first
     * clearing the already added namespaces. Utility method mainly
     * used in compiled templates, where some namespaces can be added
     * from outside and some can be added from compiled values.
     *
     * @param array $namespaces
     * @return void
     */
    public function addNamespaces(array $namespaces)
    {
        foreach ($namespaces as $identifier => $namespace) {
            $this->addNamespace($identifier, $namespace);
        }
    }

    /**
     * Resolves the PHP namespace based on the Fluid xmlns namespace,
     * which can be either a URL matching the Patterns::NAMESPACEPREFIX
     * and Patterns::NAMESPACESUFFIX rules, or a PHP namespace. When
     * namespace is a PHP namespace it is optional to suffix it with
     * the "\ViewHelpers" segment, e.g. "My\Package" is as valid to
     * use as "My\Package\ViewHelpers" is.
     *
     * @param string $fluidNamespace
     * @return string
     */
    public function resolvePhpNamespaceFromFluidNamespace($fluidNamespace)
    {
        $namespace = $fluidNamespace;
        $suffixLength = strlen(Patterns::NAMESPACESUFFIX);
        $phpNamespaceSuffix = str_replace('/', '\\', Patterns::NAMESPACESUFFIX);
        $extractedSuffix = substr($fluidNamespace, 0 - $suffixLength);
        if (strpos($fluidNamespace, Patterns::NAMESPACEPREFIX) === 0 && $extractedSuffix === Patterns::NAMESPACESUFFIX) {
            // convention assumed: URL starts with prefix and ends with suffix
            $namespace = substr($fluidNamespace, strlen(Patterns::NAMESPACEPREFIX));
        }
        $namespace = str_replace('/', '\\', $namespace);
        if (substr($namespace, 0 - strlen($phpNamespaceSuffix)) !== $phpNamespaceSuffix) {
            $namespace .= $phpNamespaceSuffix;
        }
        return $namespace;
    }

    /**
     * Set all namespaces as an array of ['identifier' => ['Php\Namespace1', 'Php\Namespace2']]
     * namespace definitions. For convenience and legacy support, a
     * format of ['identifier' => 'Only\Php\Namespace'] is allowed,
     * but will internally convert the namespace to an array and
     * allow it to be extended by addNamespace().
     *
     * Note that when using this method the default "f" namespace is
     * also removed and so must be included in $namespaces or added
     * after using addNamespace(). Or, add the PHP namespaces that
     * belonged to "f" as a new alias and use that in your templates.
     *
     * Use getNamespaces() to get an array of currently added namespaces.
     *
     * @param array $namespaces
     * @return void
     */
    public function setNamespaces(array $namespaces)
    {
        $this->namespaces = [];
        foreach ($namespaces as $identifier => $phpNamespace) {
            $this->namespaces[$identifier] = $phpNamespace === null ? null : (array) $phpNamespace;
        }
    }

    /**
     * Validates the given namespaceIdentifier and returns FALSE
     * if the namespace is unknown, causing the tag to be rendered
     * without processing.
     *
     * @param string $namespaceIdentifier
     * @return boolean TRUE if the given namespace is valid, otherwise FALSE
     */
    public function isNamespaceValid($namespaceIdentifier)
    {
        if (strpos($namespaceIdentifier, '.')) {
            return true;
        }

        if (!array_key_exists($namespaceIdentifier, $this->namespaces)) {
            return false;
        }

        return $this->namespaces[$namespaceIdentifier] !== null;
    }

    /**
     * Validates the given namespaceIdentifier and returns FALSE
     * if the namespace is unknown and not ignored
     *
     * @param string $namespaceIdentifier
     * @return boolean TRUE if the given namespace is valid, otherwise FALSE
     */
    public function isNamespaceValidOrIgnored($namespaceIdentifier)
    {
        if ($this->isNamespaceValid($namespaceIdentifier) === true) {
            return true;
        }

        if (array_key_exists($namespaceIdentifier, $this->namespaces)) {
            return true;
        }

        if ($this->isNamespaceIgnored($namespaceIdentifier)) {
            return true;
        }

        return false;
    }

    /**
     * @param string $namespaceIdentifier
     * @return boolean
     */
    public function isNamespaceIgnored($namespaceIdentifier)
    {
        if (array_key_exists($namespaceIdentifier, $this->namespaces) && $this->namespaces[$namespaceIdentifier] === null) {
            return true;
        }
        foreach (array_keys($this->namespaces) as $existingNamespaceIdentifier) {
            if (strpos($existingNamespaceIdentifier, '*') === false) {
                continue;
            }
            $pattern = '/' . str_replace(['.', '*'], ['\\.', '[a-zA-Z0-9\.]*'], $existingNamespaceIdentifier) . '/';
            if (preg_match($pattern, $namespaceIdentifier) === 1) {
                return true;
            }
        }
        return false;
    }

    /**
     * Resolves a ViewHelper class name by namespace alias and
     * Fluid-format identity, e.g. "f" and "format.htmlspecialchars".
     *
     * Looks in all PHP namespaces which have been added for the
     * provided alias, starting in the last added PHP namespace. If
     * a ViewHelper class exists in multiple PHP namespaces Fluid
     * will detect and use whichever one was added last.
     *
     * If no ViewHelper class can be detected in any of the added
     * PHP namespaces a Fluid Parser Exception is thrown.
     *
     * @param string $namespaceIdentifier
     * @param string $methodIdentifier
     * @return string|NULL
     * @throws ParserException
     */
    public function resolveViewHelperClassName($namespaceIdentifier, $methodIdentifier)
    {
        if (!isset($this->resolvedViewHelperClassNames[$namespaceIdentifier][$methodIdentifier])) {
            $this->resolvedViewHelperClassNames[$namespaceIdentifier][$methodIdentifier] =
                $this->resolveViewHelperName($namespaceIdentifier, $methodIdentifier);
        }
        return $this->$resolvedViewHelperClassNames[$namespaceIdentifier][$methodIdentifier];

    }

    /**
     * Can be overridden by custom implementations to change the way
     * classes are loaded when the class is a ViewHelper - for
     * example making it possible to use a DI-aware class loader.
     *
     * @param string $namespace
     * @param string $viewHelperShortName
     * @return ViewHelperInterface
     */
    public function createViewHelperInstance($namespace, $viewHelperShortName)
    {
        $className = $this->resolveViewHelperClassName($namespace, $viewHelperShortName);
        return $this->createViewHelperInstanceFromClassName($className);
    }

    /**
     * Wrapper to create a ViewHelper instance by class name. This is
     * the final method called when creating ViewHelper classes -
     * overriding this method allows custom constructors, dependency
     * injections etc. to be performed on the ViewHelper instance.
     *
     * @param string $viewHelperClassName
     * @return ViewHelperInterface
     */
    public function createViewHelperInstanceFromClassName($viewHelperClassName)
    {
        return new $viewHelperClassName();
    }

    /**
     * Return an array of ArgumentDefinition instances which describe
     * the arguments that the ViewHelper supports. By default, the
     * arguments are simply fetched from the ViewHelper - but custom
     * implementations can if necessary add/remove/replace arguments
     * which will be passed to the ViewHelper.
     *
     * @param ViewHelperInterface $viewHelper
     * @return ArgumentDefinition[]
     */
    public function getArgumentDefinitionsForViewHelper(ViewHelperInterface $viewHelper)
    {
        return $viewHelper->prepareArguments();
    }

    /**
     * Resolve a viewhelper name.
     *
     * @param string $namespaceIdentifier Namespace identifier for the view helper.
     * @param string $methodIdentifier Method identifier, might be hierarchical like "link.url"
     * @return string The fully qualified class name of the viewhelper
     */
    protected function resolveViewHelperName($namespaceIdentifier, $methodIdentifier)
    {
        $explodedViewHelperName = explode('.', $methodIdentifier);
        if (count($explodedViewHelperName) > 1) {
            $className = implode('\\', array_map('ucfirst', $explodedViewHelperName));
        } else {
            $className = ucfirst($explodedViewHelperName[0]);
        }
        $classNames = [
            $className . 'ViewHelper',
            $className
        ];

        if ($this->namespaces[$namespaceIdentifier] ?? false) {
            $namespaces = (array) $this->namespaces[$namespaceIdentifier];
        } else {
            $namespacePrefix = $this->namespaces[$namespaceIdentifier] = str_replace('.', '\\', $namespaceIdentifier);
            $namespaces = [
                $namespacePrefix . '\\ViewHelpers',
                $namespacePrefix
            ];
        }

        $checked = [];
        foreach (array_reverse($namespaces) as $namespace) {
            $namespace = rtrim($namespace, '\\');
            foreach ($classNames as $className) {
                $name = $namespace . '\\' . $className;
                if (class_exists($name) && is_a($name, ViewHelperInterface::class, true)) {
                    return $name;
                }
                $checked[] = $name;
            }
        }

        throw new ParserException(
            sprintf(
                'The ViewHelper "%s:%s" could not be resolved. Fluid checked for "%s" but none of those classes exist.',
                $namespaceIdentifier,
                $methodIdentifier,
                implode(', ', $checked)
            ),
            1407060572
        );

        return $name;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
    }
}


1			<?php
2			namespace TYPO3Fluid\Fluid\Core\ViewHelper;
3
4			/*
5			* This file belongs to the package "TYPO3 Fluid".
6			* See LICENSE.txt that was shipped with this package.
7			*/
8
9			use TYPO3Fluid\Fluid\Core\Parser\Exception as ParserException;
10			use TYPO3Fluid\Fluid\Core\Parser\Patterns;
11
12			/**
13			* Class ViewHelperResolver
14			*
15			* Responsible for resolving instances of ViewHelpers and for
16			* interacting with ViewHelpers; to translate ViewHelper names
17			* into actual class names and resolve their ArgumentDefinitions.
18			*
19			* Replacing this class in for example a framework allows that
20			* framework to be responsible for creating ViewHelper instances
21			* and detecting possible arguments.
22			*/
23			class ViewHelperResolver
24			{
25
26			/**
27			* @var array
28			*/
29			protected $resolvedViewHelperClassNames = [];
30
31			/**
32			* Namespaces requested by the template being rendered,
33			* in [shortname => phpnamespace] format.
34			*
35			* @var array
36			*/
37			protected $namespaces = [
38			'f' => ['TYPO3Fluid\\Fluid\\ViewHelpers']
39			];
40
41			/**
42			* @return array
43			*/
44			public function getNamespaces()
45			{
46			return $this->namespaces;
47			}
48
49			/**
50			* Add a PHP namespace where ViewHelpers can be found and give
51			* it an alias/identifier.
52			*
53			* The provided namespace can be either a single namespace or
54			* an array of namespaces, as strings. The identifier/alias is
55			* always a single, alpha-numeric ASCII string.
56			*
57			* Calling this method multiple times with different PHP namespaces
58			* for the same alias causes that namespace to be extended,
59			* meaning that the PHP namespace you provide second, third etc.
60			* are also used in lookups and are used first, so that if any
61			* of the namespaces you add contains a class placed and named the
62			* same way as one that exists in an earlier namespace, then your
63			* class gets used instead of the earlier one.
64			*
65			* Example:
66			*
67			* $resolver->addNamespace('my', 'My\Package\ViewHelpers');
68			* // Any ViewHelpers under this namespace can now be accessed using for example {my:example()}
69			* // Now, assuming you also have an ExampleViewHelper class in a different
70			* // namespace and wish to make that ExampleViewHelper override the other:
71			* $resolver->addNamespace('my', 'My\OtherPackage\ViewHelpers');
72			* // Now, since ExampleViewHelper exists in both places but the
73			* // My\OtherPackage\ViewHelpers namespace was added last, Fluid
74			* // will find and use My\OtherPackage\ViewHelpers\ExampleViewHelper.
75			*
76			* Alternatively, setNamespaces() can be used to reset and redefine
77			* all previously added namespaces - which is great for cases where
78			* you need to remove or replace previously added namespaces. Be aware
79			* that setNamespaces() also removes the default "f" namespace, so
80			* when you use this method you should always include the "f" namespace.
81			*
82			* @param string $identifier
83			* @param string\|array $phpNamespace
84			* @return void
85			*/
86			public function addNamespace($identifier, $phpNamespace)
87			{
88			if (!array_key_exists($identifier, $this->namespaces) \|\| $this->namespaces[$identifier] === null) {
89			$this->namespaces[$identifier] = $phpNamespace === null ? null : (array) $phpNamespace;
90			} elseif (is_array($phpNamespace)) {
91			$this->namespaces[$identifier] = array_unique(array_merge($this->namespaces[$identifier], $phpNamespace));
92			} elseif (isset($this->namespaces[$identifier]) && !in_array($phpNamespace, $this->namespaces[$identifier])) {
93			$this->namespaces[$identifier][] = $phpNamespace;
94			}
95			}
96
97			/**
98			* Wrapper to allow adding namespaces in bulk without first
99			* clearing the already added namespaces. Utility method mainly
100			* used in compiled templates, where some namespaces can be added
101			* from outside and some can be added from compiled values.
102			*
103			* @param array $namespaces
104			* @return void
105			*/
106			public function addNamespaces(array $namespaces)
107			{
108			foreach ($namespaces as $identifier => $namespace) {
109			$this->addNamespace($identifier, $namespace);
110			}
111			}
112
113			/**
114			* Resolves the PHP namespace based on the Fluid xmlns namespace,
115			* which can be either a URL matching the Patterns::NAMESPACEPREFIX
116			* and Patterns::NAMESPACESUFFIX rules, or a PHP namespace. When
117			* namespace is a PHP namespace it is optional to suffix it with
118			* the "\ViewHelpers" segment, e.g. "My\Package" is as valid to
119			* use as "My\Package\ViewHelpers" is.
120			*
121			* @param string $fluidNamespace
122			* @return string
123			*/
124			public function resolvePhpNamespaceFromFluidNamespace($fluidNamespace)
125			{
126			$namespace = $fluidNamespace;
127			$suffixLength = strlen(Patterns::NAMESPACESUFFIX);
128			$phpNamespaceSuffix = str_replace('/', '\\', Patterns::NAMESPACESUFFIX);
129			$extractedSuffix = substr($fluidNamespace, 0 - $suffixLength);
130			if (strpos($fluidNamespace, Patterns::NAMESPACEPREFIX) === 0 && $extractedSuffix === Patterns::NAMESPACESUFFIX) {
131			// convention assumed: URL starts with prefix and ends with suffix
132			$namespace = substr($fluidNamespace, strlen(Patterns::NAMESPACEPREFIX));
133			}
134			$namespace = str_replace('/', '\\', $namespace);
135			if (substr($namespace, 0 - strlen($phpNamespaceSuffix)) !== $phpNamespaceSuffix) {
136			$namespace .= $phpNamespaceSuffix;
137			}
138			return $namespace;
139			}
140
141			/**
142			* Set all namespaces as an array of ['identifier' => ['Php\Namespace1', 'Php\Namespace2']]
143			* namespace definitions. For convenience and legacy support, a
144			* format of ['identifier' => 'Only\Php\Namespace'] is allowed,
145			* but will internally convert the namespace to an array and
146			* allow it to be extended by addNamespace().
147			*
148			* Note that when using this method the default "f" namespace is
149			* also removed and so must be included in $namespaces or added
150			* after using addNamespace(). Or, add the PHP namespaces that
151			* belonged to "f" as a new alias and use that in your templates.
152			*
153			* Use getNamespaces() to get an array of currently added namespaces.
154			*
155			* @param array $namespaces
156			* @return void
157			*/
158			public function setNamespaces(array $namespaces)
159			{
160			$this->namespaces = [];
161			foreach ($namespaces as $identifier => $phpNamespace) {
162			$this->namespaces[$identifier] = $phpNamespace === null ? null : (array) $phpNamespace;
163			}
164			}
165
166			/**
167			* Validates the given namespaceIdentifier and returns FALSE
168			* if the namespace is unknown, causing the tag to be rendered
169			* without processing.
170			*
171			* @param string $namespaceIdentifier
172			* @return boolean TRUE if the given namespace is valid, otherwise FALSE
173			*/
174			public function isNamespaceValid($namespaceIdentifier)
175			{
176			if (strpos($namespaceIdentifier, '.')) {
177			return true;
178			}
179
180			if (!array_key_exists($namespaceIdentifier, $this->namespaces)) {
181			return false;
182			}
183
184			return $this->namespaces[$namespaceIdentifier] !== null;
185			}
186
187			/**
188			* Validates the given namespaceIdentifier and returns FALSE
189			* if the namespace is unknown and not ignored
190			*
191			* @param string $namespaceIdentifier
192			* @return boolean TRUE if the given namespace is valid, otherwise FALSE
193			*/
194			public function isNamespaceValidOrIgnored($namespaceIdentifier)
195			{
196			if ($this->isNamespaceValid($namespaceIdentifier) === true) {
197			return true;
198			}
199
200			if (array_key_exists($namespaceIdentifier, $this->namespaces)) {
201			return true;
202			}
203
204			if ($this->isNamespaceIgnored($namespaceIdentifier)) {
205			return true;
206			}
207
208			return false;
209			}
210
211			/**
212			* @param string $namespaceIdentifier
213			* @return boolean
214			*/
215			public function isNamespaceIgnored($namespaceIdentifier)
216			{
217			if (array_key_exists($namespaceIdentifier, $this->namespaces) && $this->namespaces[$namespaceIdentifier] === null) {
218			return true;
219			}
220			foreach (array_keys($this->namespaces) as $existingNamespaceIdentifier) {
221			if (strpos($existingNamespaceIdentifier, '*') === false) {
222			continue;
223			}
224			$pattern = '/' . str_replace(['.', ''], ['\\.', '[a-zA-Z0-9\.]'], $existingNamespaceIdentifier) . '/';
225			if (preg_match($pattern, $namespaceIdentifier) === 1) {
226			return true;
227			}
228			}
229			return false;
230			}
231
232			/**
233			* Resolves a ViewHelper class name by namespace alias and
234			* Fluid-format identity, e.g. "f" and "format.htmlspecialchars".
235			*
236			* Looks in all PHP namespaces which have been added for the
237			* provided alias, starting in the last added PHP namespace. If
238			* a ViewHelper class exists in multiple PHP namespaces Fluid
239			* will detect and use whichever one was added last.
240			*
241			* If no ViewHelper class can be detected in any of the added
242			* PHP namespaces a Fluid Parser Exception is thrown.
243			*
244			* @param string $namespaceIdentifier
245			* @param string $methodIdentifier
246			* @return string\|NULL
247			* @throws ParserException
248			*/
249			public function resolveViewHelperClassName($namespaceIdentifier, $methodIdentifier)
250			{
251			if (!isset($this->resolvedViewHelperClassNames[$namespaceIdentifier][$methodIdentifier])) {
252			$this->resolvedViewHelperClassNames[$namespaceIdentifier][$methodIdentifier] =
253			$this->resolveViewHelperName($namespaceIdentifier, $methodIdentifier);
254			}
255			return $this->$resolvedViewHelperClassNames[$namespaceIdentifier][$methodIdentifier];
			0 ignored issues – show Bug introduced 2017-07-30 15:14 UTC by Report Bug Copy Issue Report The variable `$resolvedViewHelperClassNames` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history...
256			}
257
258			/**
259			* Can be overridden by custom implementations to change the way
260			* classes are loaded when the class is a ViewHelper - for
261			* example making it possible to use a DI-aware class loader.
262			*
263			* @param string $namespace
264			* @param string $viewHelperShortName
265			* @return ViewHelperInterface
266			*/
267			public function createViewHelperInstance($namespace, $viewHelperShortName)
268			{
269			$className = $this->resolveViewHelperClassName($namespace, $viewHelperShortName);
270			return $this->createViewHelperInstanceFromClassName($className);
271			}
272
273			/**
274			* Wrapper to create a ViewHelper instance by class name. This is
275			* the final method called when creating ViewHelper classes -
276			* overriding this method allows custom constructors, dependency
277			* injections etc. to be performed on the ViewHelper instance.
278			*
279			* @param string $viewHelperClassName
280			* @return ViewHelperInterface
281			*/
282			public function createViewHelperInstanceFromClassName($viewHelperClassName)
283			{
284			return new $viewHelperClassName();
285			}
286
287			/**
288			* Return an array of ArgumentDefinition instances which describe
289			* the arguments that the ViewHelper supports. By default, the
290			* arguments are simply fetched from the ViewHelper - but custom
291			* implementations can if necessary add/remove/replace arguments
292			* which will be passed to the ViewHelper.
293			*
294			* @param ViewHelperInterface $viewHelper
295			* @return ArgumentDefinition[]
296			*/
297			public function getArgumentDefinitionsForViewHelper(ViewHelperInterface $viewHelper)
298			{
299			return $viewHelper->prepareArguments();
300			}
301
302			/**
303			* Resolve a viewhelper name.
304			*
305			* @param string $namespaceIdentifier Namespace identifier for the view helper.
306			* @param string $methodIdentifier Method identifier, might be hierarchical like "link.url"
307			* @return string The fully qualified class name of the viewhelper
308			*/
309			protected function resolveViewHelperName($namespaceIdentifier, $methodIdentifier)
310			{
311			$explodedViewHelperName = explode('.', $methodIdentifier);
312			if (count($explodedViewHelperName) > 1) {
313			$className = implode('\\', array_map('ucfirst', $explodedViewHelperName));
314			} else {
315			$className = ucfirst($explodedViewHelperName[0]);
316			}
317			$classNames = [
318			$className . 'ViewHelper',
319			$className
320			];
321
322			if ($this->namespaces[$namespaceIdentifier] ?? false) {
323			$namespaces = (array) $this->namespaces[$namespaceIdentifier];
324			} else {
325			$namespacePrefix = $this->namespaces[$namespaceIdentifier] = str_replace('.', '\\', $namespaceIdentifier);
326			$namespaces = [
327			$namespacePrefix . '\\ViewHelpers',
328			$namespacePrefix
329			];
330			}
331
332			$checked = [];
333			foreach (array_reverse($namespaces) as $namespace) {
334			$namespace = rtrim($namespace, '\\');
335			foreach ($classNames as $className) {
336			$name = $namespace . '\\' . $className;
337			if (class_exists($name) && is_a($name, ViewHelperInterface::class, true)) {
338			return $name;
339			}
340			$checked[] = $name;
341			}
342			}
343
344			throw new ParserException(
345			sprintf(
346			'The ViewHelper "%s:%s" could not be resolved. Fluid checked for "%s" but none of those classes exist.',
347			$namespaceIdentifier,
348			$methodIdentifier,
349			implode(', ', $checked)
350			),
351			1407060572
352			);
353
354			return $name;
			0 ignored issues – show Unused Code introduced 2017-07-30 15:14 UTC by Report Bug Copy Issue Report `return $name;` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
355			}
356			}
357

TYPO3 / Fluid

Pull Request — master (#329)

ViewHelperResolver::resolveViewHelperName() C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like