ReflectionClassConstant::__debugInfo() - Code Metrics - Inspection of "Library cleaning" - goaop/parser-reflection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#107)

by Alexander

created 2020-09-27 21:40 UTC

ReflectionClassConstant::__debugInfo() A

↳ Parent: ReflectionClassConstant

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php
/**
 * Parser Reflection API
 *
 * @copyright Copyright 2019, Lisachenko Alexander <[email protected]>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */
declare(strict_types=1);

namespace Go\ParserReflection;

use Go\ParserReflection\Traits\InternalPropertiesEmulationTrait;
use Go\ParserReflection\ValueResolver\NodeExpressionResolver;
use PhpParser\Node\Const_;
use PhpParser\Node\Stmt\ClassConst;
use PhpParser\Node\Stmt\ClassLike;
use Reflection;
use ReflectionClassConstant as BaseReflectionClassConstant;

class ReflectionClassConstant extends BaseReflectionClassConstant
{
    use InternalPropertiesEmulationTrait;

    /**
     * Concrete class constant node
     *
     * @var ClassConst
     */
    private $classConstantNode;

    /**
     * @var Const_
     */
    private $constNode;

    /**
     * Name of the class
     *
     * @var string
     */
    private $className;

    /**
     * Parses class constants from the concrete class node
     *
     * @param ClassLike $classLikeNode Class-like node
     * @param string $reflectionClassName FQN of the class
     *
     * @return array|ReflectionClassConstant[]
     */
    public static function collectFromClassNode(ClassLike $classLikeNode, string $reflectionClassName): array
    {
        $classConstants = [];

        foreach ($classLikeNode->stmts as $classLevelNode) {
            if ($classLevelNode instanceof ClassConst) {
                foreach ($classLevelNode->consts as $const) {
                    $classConstName = $const->name->toString();
                    $classConstants[$classConstName] = new ReflectionClassConstant(
                        $reflectionClassName,
                        $classConstName,
                        $classLevelNode,
                        $const
                    );
                }
            }
        }

        return $classConstants;
    }

    /**
     * Initializes a reflection for the class constant
     *
     * @param string      $className         Name of the class
     * @param string      $classConstantName Name of the class constant to reflect
     * @param ?ClassConst $classConstNode    ClassConstant definition node

     * @param Const_|null $constNode         Concrete const definition node
     */
    public function __construct(
        string $className,
        string $classConstantName,
        ClassConst $classConstNode = null,
        Const_ $constNode = null
    ) {
        $this->className = ltrim($className, '\\');

        if (!$classConstNode || !$constNode) {
            [$classConstNode, $constNode] = ReflectionEngine::parseClassConstant($className, $classConstantName);
        }
        // Let's unset original read-only property to have a control over it via __get
        unset($this->name, $this->class);

        $this->classConstantNode = $classConstNode;
        $this->constNode = $constNode;
    }

    /**
     * Emulating original behaviour of reflection
     */
    public function __debugInfo(): array
    {
        return [
            'name' => $this->getName(),
            'class' => $this->className
        ];
    }

    /**
     * @inheritDoc
     */
    public function getDeclaringClass()
    {
        return new ReflectionClass($this->className);
    }

    /**
     * @inheritDoc
     */
    public function getDocComment()
    {
        $docBlock = $this->classConstantNode->getDocComment();

        return $docBlock ? $docBlock->getText() : false;
    }

    /**
     * @inheritDoc
     */
    public function getModifiers()
    {
        $modifiers = 0;
        if ($this->isPublic()) {
            $modifiers += ReflectionMethod::IS_PUBLIC;
        }
        if ($this->isProtected()) {
            $modifiers += ReflectionMethod::IS_PROTECTED;
        }
        if ($this->isPrivate()) {
            $modifiers += ReflectionMethod::IS_PRIVATE;
        }

        return $modifiers;
    }

    /**
     * @inheritDoc
     */
    public function getName()
    {
        return $this->constNode->name->toString();
    }

    /**
     * @inheritDoc
     */
    public function getValue()
    {
        $solver = new NodeExpressionResolver($this->getDeclaringClass());
        $solver->process($this->constNode->value);
        return $solver->getValue();
    }

    /**
     * @inheritDoc
     */
    public function isPrivate()
    {
        return $this->classConstantNode->isPrivate();
    }

    /**
     * @inheritDoc
     */
    public function isProtected()
    {
        return $this->classConstantNode->isProtected();
    }

    /**
     * @inheritDoc
     */
    public function isPublic()
    {
        return $this->classConstantNode->isPublic();
    }

    /**
     * @inheritDoc
     */
    public function __toString()
    {
        # Starting from PHP7.3 gettype returns different names, need to remap them
        static $typeMap = [
            'integer' => 'int',
            'boolean' => 'bool',
            'double'  => 'float',
        ];
        $value = $this->getValue();
        $type  = gettype($value);
        if (PHP_VERSION_ID >= 70300 && isset($typeMap[$type])) {
            $type = $typeMap[$type];
        }
        $valueType = new ReflectionType($type, null, true);

        return sprintf(
            "Constant [ %s %s %s ] { %s }\n",
            implode(' ', Reflection::getModifierNames($this->getModifiers())),
            strtolower((string) ReflectionType::convertToDisplayType($valueType)),
            $this->getName(),
            (string) $value
        );
    }
}


1		<?php
2		/**
3		* Parser Reflection API
4		*
5		* @copyright Copyright 2019, Lisachenko Alexander <[email protected]>
6		*
7		* This source file is subject to the license that is bundled
8		* with this source code in the file LICENSE.
9		*/
10		declare(strict_types=1);
11
12		namespace Go\ParserReflection;
13
14		use Go\ParserReflection\Traits\InternalPropertiesEmulationTrait;
15		use Go\ParserReflection\ValueResolver\NodeExpressionResolver;
16		use PhpParser\Node\Const_;
17		use PhpParser\Node\Stmt\ClassConst;
18		use PhpParser\Node\Stmt\ClassLike;
19		use Reflection;
20		use ReflectionClassConstant as BaseReflectionClassConstant;
21
22		class ReflectionClassConstant extends BaseReflectionClassConstant
23		{
24		use InternalPropertiesEmulationTrait;
25
26		/**
27		* Concrete class constant node
28		*
29		* @var ClassConst
30		*/
31		private $classConstantNode;
32
33		/**
34		* @var Const_
35		*/
36		private $constNode;
37
38		/**
39		* Name of the class
40		*
41		* @var string
42		*/
43		private $className;
44
45		/**
46		* Parses class constants from the concrete class node
47		*
48		* @param ClassLike $classLikeNode Class-like node
49		* @param string $reflectionClassName FQN of the class
50		*
51		* @return array\|ReflectionClassConstant[]
52		*/
53	8	public static function collectFromClassNode(ClassLike $classLikeNode, string $reflectionClassName): array
54		{
55	8	$classConstants = [];
56
57	8	foreach ($classLikeNode->stmts as $classLevelNode) {
58	8	if ($classLevelNode instanceof ClassConst) {
59	7	foreach ($classLevelNode->consts as $const) {
60	7	$classConstName = $const->name->toString();
61	7	$classConstants[$classConstName] = new ReflectionClassConstant(
62	7	$reflectionClassName,
63		$classConstName,
64		$classLevelNode,
65		$const
66		);
67		}
68		}
69		}
70
71	8	return $classConstants;
72		}
73
74		/**
75		* Initializes a reflection for the class constant
76		*
77		* @param string $className Name of the class
78		* @param string $classConstantName Name of the class constant to reflect
79		* @param ?ClassConst $classConstNode ClassConstant definition node
		0 ignored issues – show Documentation introduced 2020-09-27 21:44 UTC by Report Bug Copy Issue Report The doc-type `?ClassConst` could not be parsed: Unknown type name "?ClassConst" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
80		* @param Const_\|null $constNode Concrete const definition node
81		*/
82	7	public function __construct(
83		string $className,
84		string $classConstantName,
85		ClassConst $classConstNode = null,
86		Const_ $constNode = null
87		) {
88	7	$this->className = ltrim($className, '\\');
89
90	7	if (!$classConstNode \|\| !$constNode) {
91		[$classConstNode, $constNode] = ReflectionEngine::parseClassConstant($className, $classConstantName);
92		}
93		// Let's unset original read-only property to have a control over it via __get
94	7	unset($this->name, $this->class);
95
96	7	$this->classConstantNode = $classConstNode;
97	7	$this->constNode = $constNode;
98	7	}
99
100		/**
101		* Emulating original behaviour of reflection
102		*/
103	1	public function __debugInfo(): array
104		{
105		return [
106	1	'name' => $this->getName(),
107	1	'class' => $this->className
108		];
109		}
110
111		/**
112		* @inheritDoc
113		*/
114	2	public function getDeclaringClass()
115		{
116	2	return new ReflectionClass($this->className);
117		}
118
119		/**
120		* @inheritDoc
121		*/
122	1	public function getDocComment()
123		{
124	1	$docBlock = $this->classConstantNode->getDocComment();
125
126	1	return $docBlock ? $docBlock->getText() : false;
127		}
128
129		/**
130		* @inheritDoc
131		*/
132	2	public function getModifiers()
133		{
134	2	$modifiers = 0;
135	2	if ($this->isPublic()) {
136	2	$modifiers += ReflectionMethod::IS_PUBLIC;
137		}
138	2	if ($this->isProtected()) {
139	1	$modifiers += ReflectionMethod::IS_PROTECTED;
140		}
141	2	if ($this->isPrivate()) {
142	1	$modifiers += ReflectionMethod::IS_PRIVATE;
143		}
144
145	2	return $modifiers;
146		}
147
148		/**
149		* @inheritDoc
150		*/
151	4	public function getName()
152		{
153	4	return $this->constNode->name->toString();
154		}
155
156		/**
157		* @inheritDoc
158		*/
159	2	public function getValue()
160		{
161	2	$solver = new NodeExpressionResolver($this->getDeclaringClass());
162	2	$solver->process($this->constNode->value);
163	2	return $solver->getValue();
164		}
165
166		/**
167		* @inheritDoc
168		*/
169	2	public function isPrivate()
170		{
171	2	return $this->classConstantNode->isPrivate();
172		}
173
174		/**
175		* @inheritDoc
176		*/
177	2	public function isProtected()
178		{
179	2	return $this->classConstantNode->isProtected();
180		}
181
182		/**
183		* @inheritDoc
184		*/
185	2	public function isPublic()
186		{
187	2	return $this->classConstantNode->isPublic();
188		}
189
190		/**
191		* @inheritDoc
192		*/
193	2	public function __toString()
194		{
195		# Starting from PHP7.3 gettype returns different names, need to remap them
196	2	static $typeMap = [
197		'integer' => 'int',
198		'boolean' => 'bool',
199		'double' => 'float',
200		];
201	2	$value = $this->getValue();
202	2	$type = gettype($value);
203	2	if (PHP_VERSION_ID >= 70300 && isset($typeMap[$type])) {
204	2	$type = $typeMap[$type];
205		}
206	2	$valueType = new ReflectionType($type, null, true);
207
208	2	return sprintf(
209	2	"Constant [ %s %s %s ] { %s }\n",
210	2	implode(' ', Reflection::getModifierNames($this->getModifiers())),
211	2	strtolower((string) ReflectionType::convertToDisplayType($valueType)),
212	2	$this->getName(),
213	2	(string) $value
214		);
215		}
216		}
217

goaop / parser-reflection

Pull Request — master (#107)

ReflectionClassConstant::__debugInfo() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like