ReflectionUtility::isPropertyTaggedWith() - Code Metrics - Inspection of "PHP CS fixer" - lochmueller/autoloader - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dfd5cb...5cac00 )

by Tim

created 2019-01-23 19:44 UTC

ReflectionUtility::isPropertyTaggedWith() A

↳ Parent: ReflectionUtility

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

/**
 * Reflection helper.
 */
declare(strict_types=1);

namespace HDNET\Autoloader\Utility;

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\VersionNumberUtility;
use TYPO3\CMS\Extbase\Object\ObjectManager;
use TYPO3\CMS\Extbase\Reflection\ClassReflection;
use TYPO3\CMS\Extbase\Reflection\ReflectionService;

/**
 * Reflection helper.
 */
class ReflectionUtility
{
    /**
     * Create a new class reflection. Do not use the makeInstance or objectManager
     * because the reflection API is also used in front of the caching framework.
     *
     * @param string $className
     *
     * @return ClassReflection
     *
     * @deprecated
     */
    public static function createReflectionClass($className)
    {
        return new ClassReflection($className);
    }

    /**
     * Check if the given class is instantiable.
     *
     * @param string $className
     *
     * @return bool
     */
    public static function isInstantiable($className): bool
    {
        if (self::is9orHigher()) {
            $reflectionClass = new \ReflectionClass($className);

            return (bool) $reflectionClass->isInstantiable();
        }

        return (bool) self::createReflectionClass($className)

            ->isInstantiable();
    }

    /**
     * Get the name of the parent class.
     *
     * @param string $className
     *
     * @return string
     */
    public static function getParentClassName($className)
    {
        if (self::is9orHigher()) {
            $reflectionClass = new \ReflectionClass($className);

            return $reflectionClass->getParentClass()->getName();
        }

        return self::createReflectionClass($className)

            ->getParentClass()
            ->getName();
    }

    /**
     * Get first class tag information.
     * The trimmed value if the tag exists and FALSE if the tag do not exists.
     *
     * @param string $className
     * @param string $tag
     *
     * @return string|bool
     */
    public static function getFirstTagValue(string $className, string $tag)
    {
        if (self::is9orHigher()) {
            $rc = new \ReflectionClass($className);
            if (false === \mb_strpos($rc->getDocComment(), '@' . $tag)) {
                return false;
            }

            $reflectionService = self::getReflectionService();
            $values = $reflectionService->getClassTagValues($className, $tag);

        } else {
            $classReflection = self::createReflectionClass($className);

            if (!$classReflection->isTaggedWith($tag)) {
                return false;
            }
            $values = $classReflection->getTagValues($tag);
        }

        if (\is_array($values)) {
            return \trim((string) $values[0]);
        }

        return false;
    }

    /**
     * Get the tag configuration from this method and respect multiple line and space configuration.
     *
     * @param string $className
     * @param        $methodName
     * @param array  $tagNames
     *
     * @return array
     */
    public static function getTagConfigurationForMethod($className, $methodName, array $tagNames): array
    {
        $reflectionService = self::getReflectionService();
        $tags = $reflectionService->getMethodTagsValues($className, $methodName);


        $configuration = [];
        foreach ($tagNames as $tagName) {
            $configuration[$tagName] = [];
            if (!\is_array($tags[$tagName])) {
                continue;
            }
            foreach ($tags[$tagName] as $c) {
                $configuration[$tagName] = \array_merge(
                    $configuration[$tagName],
                    GeneralUtility::trimExplode(' ', $c, true)
                );
            }
        }

        return $configuration;
    }

    /**
     * Get the tag configuration from this method and respect multiple line and space configuration.
     *
     * @param string $className
     * @param array  $tagNames
     *
     * @return array
     */
    public static function getTagConfigurationForClass(string $className, array $tagNames): array
    {
        $reflectionService = self::getReflectionService();
        $tags = $reflectionService->getClassTagsValues($className);


        $configuration = [];
        foreach ($tagNames as $tagName) {
            $configuration[$tagName] = [];
            if (!\is_array($tags[$tagName])) {
                continue;
            }
            foreach ($tags[$tagName] as $c) {
                $configuration[$tagName] = \array_merge(
                    $configuration[$tagName],
                    GeneralUtility::trimExplode(' ', $c, true)
                );
            }
        }

        return $configuration;
    }

    /**
     * Get the tag configuration from this method and respect multiple line and space configuration.
     *
     * @param string $className
     * @param string $property
     * @param array  $tagNames
     *
     * @return array
     */
    public static function getTagConfigurationForProperty(string $className, string $property, array $tagNames): array
    {
        $reflectionService = self::getReflectionService();
        if (self::is9orHigher()) {
            $tags = $reflectionService->getClassSchema($className)->getProperty($property)['tags'];
        } else {
            $tags = $reflectionService->getPropertyTagsValues($className, $property);

        }

        $configuration = [];
        foreach ($tagNames as $tagName) {
            if (!\is_array($tags[$tagName])) {
                continue;
            }
            $configuration[$tagName] = '';
            foreach ($tags[$tagName] as $c) {
                $configuration[$tagName] = \trim($configuration[$tagName] . ' ' . $c);
            }
        }

        return $configuration;
    }

    /**
     * Get public method names.
     *
     * @param string $className
     *
     * @return array
     */
    public static function getPropertyNames(string $className): array
    {
        $reflectionService = self::getReflectionService();

        return \array_keys($reflectionService->getClassSchema($className)->getProperties());
    }

    /**
     * @param string $className
     * @param string $tag
     *
     * @throws \ReflectionException
     *
     * @return array
     */
    public static function getPropertiesTaggedWith(string $className, string $tag): array
    {
        $classReflection = new \ReflectionClass($className);
        $props = $classReflection->getProperties();
        $result = [];
        foreach ($props as $prop) {
            /** @var $prop \ReflectionProperty */
            if (false !== \mb_strpos($prop->getDocComment(), '@' . $tag)) {
                $result[] = $prop->getName();
            }
        }

        return $result;
    }

    /**
     * Get public method names.
     *
     * @param string $className
     *
     * @return array
     */
    public static function getPublicMethodNames(string $className): array
    {
        $methodNames = [];

        if (self::is9orHigher()) {
            $reflectionService = self::getReflectionService();
            $schema = $reflectionService->getClassSchema($className);
            $methods = $schema->getMethods();
            foreach ($methods as $key => $method) {
                if ($method['public']) {
                    $methodNames[] = $key;
                }
            }

            return $methodNames;
        }

        $methods = self::createReflectionClass($className)

            ->getMethods(\ReflectionMethod::IS_PUBLIC);
        foreach ($methods as $method) {
            $methodNames[] = $method->getName();
        }

        return $methodNames;
    }

    /**
     * Get properties of the given class, that are als declared in the given class.
     *
     * @param string $className
     *
     * @return array
     */
    public static function getDeclaringProperties(string $className)
    {
        $classReflection = new \ReflectionClass($className);
        $own = \array_filter($classReflection->getProperties(), function ($property) use ($className) {
            return \trim((string) $property->class, '\\') === \trim($className, '\\');
        });

        return \array_map(function ($item) {
            return (string) $item->name;
        }, $own);
    }

    /**
     * Is 9 or higher.
     *
     * @return bool
     */
    public static function is9orHigher(): bool
    {
        return VersionNumberUtility::convertVersionNumberToInteger(TYPO3_branch) >= VersionNumberUtility::convertVersionNumberToInteger('9.0');
    }

    /**
     * Check if the method is tagged with the given tag (no value checked).
     *
     * @param string $className
     * @param string $methodName
     * @param string $tagName
     *
     * @return bool
     */
    public static function isMethodTaggedWith($className, $methodName, $tagName): bool
    {
        $reflectionService = self::getReflectionService();
        $tags = $reflectionService->getMethodTagsValues($className, $methodName);


        return \array_key_exists($tagName, $tags);
    }

    /**
     * Check if the property is tagged with the given tag (no value checked).
     *
     * @param string $className
     * @param string $propertyName
     * @param string $tagName
     *
     * @return bool
     */
    public static function isPropertyTaggedWith($className, $propertyName, $tagName): bool
    {
        $properties = self::getPropertiesTaggedWith($className, $tagName);

        return \in_array($propertyName, $properties, true);
    }

    /**
     * Create reflection service.
     *
     * @return ReflectionService
     */
    protected static function getReflectionService()
    {
        $objectManager = new ObjectManager();

        return $objectManager->get(ReflectionService::class);
    }
}


1			<?php
2
3			/**
4			* Reflection helper.
5			*/
6			declare(strict_types=1);
7
8			namespace HDNET\Autoloader\Utility;
9
10			use TYPO3\CMS\Core\Utility\GeneralUtility;
11			use TYPO3\CMS\Core\Utility\VersionNumberUtility;
12			use TYPO3\CMS\Extbase\Object\ObjectManager;
13			use TYPO3\CMS\Extbase\Reflection\ClassReflection;
14			use TYPO3\CMS\Extbase\Reflection\ReflectionService;
15
16			/**
17			* Reflection helper.
18			*/
19			class ReflectionUtility
20			{
21			/**
22			* Create a new class reflection. Do not use the makeInstance or objectManager
23			* because the reflection API is also used in front of the caching framework.
24			*
25			* @param string $className
26			*
27			* @return ClassReflection
28			*
29			* @deprecated
30			*/
31			public static function createReflectionClass($className)
32			{
33			return new ClassReflection($className);
34			}
35
36			/**
37			* Check if the given class is instantiable.
38			*
39			* @param string $className
40			*
41			* @return bool
42			*/
43			public static function isInstantiable($className): bool
44			{
45			if (self::is9orHigher()) {
46			$reflectionClass = new \ReflectionClass($className);
47
48			return (bool) $reflectionClass->isInstantiable();
49			}
50
51			return (bool) self::createReflectionClass($className)
			0 ignored issues – show Deprecated Code introduced 2018-10-08 19:01 UTC by Report Bug Copy Issue Report The method `HDNET\Autoloader\Utility...createReflectionClass()` has been deprecated. This method has been deprecated. Loading history...
52			->isInstantiable();
53			}
54
55			/**
56			* Get the name of the parent class.
57			*
58			* @param string $className
59			*
60			* @return string
61			*/
62			public static function getParentClassName($className)
63			{
64			if (self::is9orHigher()) {
65			$reflectionClass = new \ReflectionClass($className);
66
67			return $reflectionClass->getParentClass()->getName();
68			}
69
70			return self::createReflectionClass($className)
			0 ignored issues – show Deprecated Code introduced 2018-10-08 19:01 UTC by Report Bug Copy Issue Report The method `HDNET\Autoloader\Utility...createReflectionClass()` has been deprecated. This method has been deprecated. Loading history...
71			->getParentClass()
72			->getName();
73			}
74
75			/**
76			* Get first class tag information.
77			* The trimmed value if the tag exists and FALSE if the tag do not exists.
78			*
79			* @param string $className
80			* @param string $tag
81			*
82			* @return string\|bool
83			*/
84			public static function getFirstTagValue(string $className, string $tag)
85			{
86			if (self::is9orHigher()) {
87			$rc = new \ReflectionClass($className);
88			if (false === \mb_strpos($rc->getDocComment(), '@' . $tag)) {
89			return false;
90			}
91
92			$reflectionService = self::getReflectionService();
93			$values = $reflectionService->getClassTagValues($className, $tag);
			0 ignored issues – show Deprecated Code introduced 2018-10-11 18:15 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Reflec...ce::getClassTagValues()` has been deprecated with message: since TYPO3 v9, will be removed in TYPO3 v10.0. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
94			} else {
95			$classReflection = self::createReflectionClass($className);
			0 ignored issues – show Deprecated Code introduced 2018-10-08 19:01 UTC by Report Bug Copy Issue Report The method `HDNET\Autoloader\Utility...createReflectionClass()` has been deprecated. This method has been deprecated. Loading history...
96			if (!$classReflection->isTaggedWith($tag)) {
97			return false;
98			}
99			$values = $classReflection->getTagValues($tag);
100			}
101
102			if (\is_array($values)) {
103			return \trim((string) $values[0]);
104			}
105
106			return false;
107			}
108
109			/**
110			* Get the tag configuration from this method and respect multiple line and space configuration.
111			*
112			* @param string $className
113			* @param $methodName
114			* @param array $tagNames
115			*
116			* @return array
117			*/
118			public static function getTagConfigurationForMethod($className, $methodName, array $tagNames): array
119			{
120			$reflectionService = self::getReflectionService();
121			$tags = $reflectionService->getMethodTagsValues($className, $methodName);
			0 ignored issues – show Deprecated Code introduced 2018-10-11 18:15 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Reflec...::getMethodTagsValues()` has been deprecated with message: since TYPO3 v9, will be removed in TYPO3 v10.0. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
122
123			$configuration = [];
124			foreach ($tagNames as $tagName) {
125			$configuration[$tagName] = [];
126			if (!\is_array($tags[$tagName])) {
127			continue;
128			}
129			foreach ($tags[$tagName] as $c) {
130			$configuration[$tagName] = \array_merge(
131			$configuration[$tagName],
132			GeneralUtility::trimExplode(' ', $c, true)
133			);
134			}
135			}
136
137			return $configuration;
138			}
139
140			/**
141			* Get the tag configuration from this method and respect multiple line and space configuration.
142			*
143			* @param string $className
144			* @param array $tagNames
145			*
146			* @return array
147			*/
148			public static function getTagConfigurationForClass(string $className, array $tagNames): array
149			{
150			$reflectionService = self::getReflectionService();
151			$tags = $reflectionService->getClassTagsValues($className);
			0 ignored issues – show Deprecated Code introduced 2018-10-11 18:15 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Reflec...e::getClassTagsValues()` has been deprecated with message: since TYPO3 v9, will be removed in TYPO3 v10.0. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
152
153			$configuration = [];
154			foreach ($tagNames as $tagName) {
155			$configuration[$tagName] = [];
156			if (!\is_array($tags[$tagName])) {
157			continue;
158			}
159			foreach ($tags[$tagName] as $c) {
160			$configuration[$tagName] = \array_merge(
161			$configuration[$tagName],
162			GeneralUtility::trimExplode(' ', $c, true)
163			);
164			}
165			}
166
167			return $configuration;
168			}
169
170			/**
171			* Get the tag configuration from this method and respect multiple line and space configuration.
172			*
173			* @param string $className
174			* @param string $property
175			* @param array $tagNames
176			*
177			* @return array
178			*/
179			public static function getTagConfigurationForProperty(string $className, string $property, array $tagNames): array
180			{
181			$reflectionService = self::getReflectionService();
182			if (self::is9orHigher()) {
183			$tags = $reflectionService->getClassSchema($className)->getProperty($property)['tags'];
184			} else {
185			$tags = $reflectionService->getPropertyTagsValues($className, $property);
			0 ignored issues – show Deprecated Code introduced 2018-11-08 07:12 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Reflec...getPropertyTagsValues()` has been deprecated with message: since TYPO3 v9, will be removed in TYPO3 v10.0. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
186			}
187
188			$configuration = [];
189			foreach ($tagNames as $tagName) {
190			if (!\is_array($tags[$tagName])) {
191			continue;
192			}
193			$configuration[$tagName] = '';
194			foreach ($tags[$tagName] as $c) {
195			$configuration[$tagName] = \trim($configuration[$tagName] . ' ' . $c);
196			}
197			}
198
199			return $configuration;
200			}
201
202			/**
203			* Get public method names.
204			*
205			* @param string $className
206			*
207			* @return array
208			*/
209			public static function getPropertyNames(string $className): array
210			{
211			$reflectionService = self::getReflectionService();
212
213			return \array_keys($reflectionService->getClassSchema($className)->getProperties());
214			}
215
216			/**
217			* @param string $className
218			* @param string $tag
219			*
220			* @throws \ReflectionException
221			*
222			* @return array
223			*/
224			public static function getPropertiesTaggedWith(string $className, string $tag): array
225			{
226			$classReflection = new \ReflectionClass($className);
227			$props = $classReflection->getProperties();
228			$result = [];
229			foreach ($props as $prop) {
230			/** @var $prop \ReflectionProperty */
231			if (false !== \mb_strpos($prop->getDocComment(), '@' . $tag)) {
232			$result[] = $prop->getName();
233			}
234			}
235
236			return $result;
237			}
238
239			/**
240			* Get public method names.
241			*
242			* @param string $className
243			*
244			* @return array
245			*/
246			public static function getPublicMethodNames(string $className): array
247			{
248			$methodNames = [];
249
250			if (self::is9orHigher()) {
251			$reflectionService = self::getReflectionService();
252			$schema = $reflectionService->getClassSchema($className);
253			$methods = $schema->getMethods();
254			foreach ($methods as $key => $method) {
255			if ($method['public']) {
256			$methodNames[] = $key;
257			}
258			}
259
260			return $methodNames;
261			}
262
263			$methods = self::createReflectionClass($className)
			0 ignored issues – show Deprecated Code introduced 2018-10-08 19:01 UTC by Report Bug Copy Issue Report The method `HDNET\Autoloader\Utility...createReflectionClass()` has been deprecated. This method has been deprecated. Loading history...
264			->getMethods(\ReflectionMethod::IS_PUBLIC);
265			foreach ($methods as $method) {
266			$methodNames[] = $method->getName();
267			}
268
269			return $methodNames;
270			}
271
272			/**
273			* Get properties of the given class, that are als declared in the given class.
274			*
275			* @param string $className
276			*
277			* @return array
278			*/
279			public static function getDeclaringProperties(string $className)
280			{
281			$classReflection = new \ReflectionClass($className);
282			$own = \array_filter($classReflection->getProperties(), function ($property) use ($className) {
283			return \trim((string) $property->class, '\\') === \trim($className, '\\');
284			});
285
286			return \array_map(function ($item) {
287			return (string) $item->name;
288			}, $own);
289			}
290
291			/**
292			* Is 9 or higher.
293			*
294			* @return bool
295			*/
296			public static function is9orHigher(): bool
297			{
298			return VersionNumberUtility::convertVersionNumberToInteger(TYPO3_branch) >= VersionNumberUtility::convertVersionNumberToInteger('9.0');
299			}
300
301			/**
302			* Check if the method is tagged with the given tag (no value checked).
303			*
304			* @param string $className
305			* @param string $methodName
306			* @param string $tagName
307			*
308			* @return bool
309			*/
310			public static function isMethodTaggedWith($className, $methodName, $tagName): bool
311			{
312			$reflectionService = self::getReflectionService();
313			$tags = $reflectionService->getMethodTagsValues($className, $methodName);
			0 ignored issues – show Deprecated Code introduced 2019-01-23 19:31 UTC by Report Bug Copy Issue Report The method `TYPO3\CMS\Extbase\Reflec...::getMethodTagsValues()` has been deprecated with message: since TYPO3 v9, will be removed in TYPO3 v10.0. This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead. Loading history...
314
315			return \array_key_exists($tagName, $tags);
316			}
317
318			/**
319			* Check if the property is tagged with the given tag (no value checked).
320			*
321			* @param string $className
322			* @param string $propertyName
323			* @param string $tagName
324			*
325			* @return bool
326			*/
327			public static function isPropertyTaggedWith($className, $propertyName, $tagName): bool
328			{
329			$properties = self::getPropertiesTaggedWith($className, $tagName);
330
331			return \in_array($propertyName, $properties, true);
332			}
333
334			/**
335			* Create reflection service.
336			*
337			* @return ReflectionService
338			*/
339			protected static function getReflectionService()
340			{
341			$objectManager = new ObjectManager();
342
343			return $objectManager->get(ReflectionService::class);
344			}
345			}
346

lochmueller / autoloader

Push — master ( dfd5cb...5cac00 )

ReflectionUtility::isPropertyTaggedWith() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like