ReflectionFile::getNodes() - Code Metrics - Inspection of "Merge pull request #79 from goaop/feature/returnin..." - goaop/parser-reflection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 34991a...adfc38 )

by Alexander

created 2017-09-03 14:59 UTC

ReflectionFile::getNodes() A

↳ Parent: ReflectionFile

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php
/**
 * Parser Reflection API
 *
 * @copyright Copyright 2015, Lisachenko Alexander <[email protected]>
 *
 * This source file is subject to the license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Go\ParserReflection;


use Go\ParserReflection\Instrument\PathResolver;
use PhpParser\Node;
use PhpParser\Node\Stmt\Namespace_;

/**
 * AST-based reflector for the source file
 */
class ReflectionFile
{

    /**
     * Name of the file for reflectino
     *
     * @var string
     */
    protected $fileName;

    /**
     * List of namespaces in the file
     *
     * @var ReflectionFileNamespace[]|array
     */
    protected $fileNamespaces;

    /**
     * Top-level nodes for the file
     *
     * @var Node[]
     */
    private $topLevelNodes;

    /**
     * ReflectionFile constructor.
     *
     * @param string $fileName Name of the file to reflect
     * @param null|array|Node[] $topLevelNodes Optional corresponding list of AST nodes for that file
     */
    public function __construct($fileName, $topLevelNodes = null)
    {
        if (!is_string($fileName)) {
            throw new \InvalidArgumentException(
                sprintf(
                    '$fileName must be a string, but a %s was passed',
                    gettype($fileName)
                )
            );
        }
        $fileName            = PathResolver::realpath($fileName);
        $this->fileName      = $fileName;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}
        $this->topLevelNodes = $topLevelNodes ?: ReflectionEngine::parseFile($fileName);
    }

    /**
     * Returns a namespace from the file or false if no such a namespace
     *
     * @param string $namespaceName
     *
     * @return bool|ReflectionFileNamespace
     */
    public function getFileNamespace($namespaceName)
    {
        if ($this->hasFileNamespace($namespaceName)) {
            return $this->fileNamespaces[$namespaceName];
        }

        return false;
    }

    /**
     * Gets the list of namespaces in the file
     *
     * @return array|ReflectionFileNamespace[]
     */
    public function getFileNamespaces()
    {
        if (!isset($this->fileNamespaces)) {
            $this->fileNamespaces = $this->findFileNamespaces();
        }

        return $this->fileNamespaces;
    }

    /**
     * Returns the name of current reflected file
     *
     * @return string
     */
    public function getName()
    {
        return $this->fileName;
    }

    /**
     * Returns an AST-nodes for file
     *
     * @return Node[]
     */
    public function getNodes()
    {
        return $this->topLevelNodes;
    }

    /**
     * Returns the presence of namespace in the file
     *
     * @param string $namespaceName Namespace to check
     *
     * @return bool
     */
    public function hasFileNamespace($namespaceName)
    {
        $namespaces = $this->getFileNamespaces();

        return isset($namespaces[$namespaceName]);
    }

    /**
     * Checks if the current file is in strict mode
     *
     * @return bool
     */
    public function isStrictMode()
    {
        // declare statement for the strict_types can be only top-level node
        $topLevelNode = reset($this->topLevelNodes);
        if (!$topLevelNode instanceof Node\Stmt\Declare_) {
            return false;
        }

        $declareStatement = reset($topLevelNode->declares);
        $isStrictTypeKey  = $declareStatement->key === 'strict_types';
        $isScalarValue    = $declareStatement->value instanceof Node\Scalar\LNumber;
        $isStrictMode     = $isStrictTypeKey && $isScalarValue && $declareStatement->value->value === 1;

        return $isStrictMode;
    }

    /**
     * Searches for file namespaces in the given AST
     *
     * @return array|ReflectionFileNamespace[]
     */
    private function findFileNamespaces()
    {
        $namespaces = array();

        // namespaces can be only top-level nodes, so we can scan them directly
        foreach ($this->topLevelNodes as $topLevelNode) {
            if ($topLevelNode instanceof Namespace_) {
                $namespaceName = $topLevelNode->name ? $topLevelNode->name->toString() : '';

                $namespaces[$namespaceName] = new ReflectionFileNamespace(
                    $this->fileName,
                    $namespaceName,
                    $topLevelNode
                );
            }
        }

        return $namespaces;
    }
}


1		<?php
2		/**
3		* Parser Reflection API
4		*
5		* @copyright Copyright 2015, 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
11		namespace Go\ParserReflection;
12
13
14		use Go\ParserReflection\Instrument\PathResolver;
15		use PhpParser\Node;
16		use PhpParser\Node\Stmt\Namespace_;
17
18		/**
19		* AST-based reflector for the source file
20		*/
21		class ReflectionFile
22		{
23
24		/**
25		* Name of the file for reflectino
26		*
27		* @var string
28		*/
29		protected $fileName;
30
31		/**
32		* List of namespaces in the file
33		*
34		* @var ReflectionFileNamespace[]\|array
35		*/
36		protected $fileNamespaces;
37
38		/**
39		* Top-level nodes for the file
40		*
41		* @var Node[]
42		*/
43		private $topLevelNodes;
44
45		/**
46		* ReflectionFile constructor.
47		*
48		* @param string $fileName Name of the file to reflect
49		* @param null\|array\|Node[] $topLevelNodes Optional corresponding list of AST nodes for that file
50		*/
51	3046	public function __construct($fileName, $topLevelNodes = null)
52		{
53	3046	if (!is_string($fileName)) {
54	2	throw new \InvalidArgumentException(
55	2	sprintf(
56	2	'$fileName must be a string, but a %s was passed',
57	2	gettype($fileName)
58		)
59		);
60		}
61	3046	$fileName = PathResolver::realpath($fileName);
62	3046	$this->fileName = $fileName;
		0 ignored issues – show Documentation Bug introduced 2017-06-27 16:12 UTC by Report Bug Copy Issue Report It seems like `$fileName` can also be of type `array` or `boolean`. However, the property `$fileName` is declared as type `string`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
63	3046	$this->topLevelNodes = $topLevelNodes ?: ReflectionEngine::parseFile($fileName);
64	3046	}
65
66		/**
67		* Returns a namespace from the file or false if no such a namespace
68		*
69		* @param string $namespaceName
70		*
71		* @return bool\|ReflectionFileNamespace
72		*/
73	3028	public function getFileNamespace($namespaceName)
74		{
75	3028	if ($this->hasFileNamespace($namespaceName)) {
76	3028	return $this->fileNamespaces[$namespaceName];
77		}
78
79	1	return false;
80		}
81
82		/**
83		* Gets the list of namespaces in the file
84		*
85		* @return array\|ReflectionFileNamespace[]
86		*/
87	3037	public function getFileNamespaces()
88		{
89	3037	if (!isset($this->fileNamespaces)) {
90	3037	$this->fileNamespaces = $this->findFileNamespaces();
91		}
92
93	3037	return $this->fileNamespaces;
94		}
95
96		/**
97		* Returns the name of current reflected file
98		*
99		* @return string
100		*/
101	1	public function getName()
102		{
103	1	return $this->fileName;
104		}
105
106		/**
107		* Returns an AST-nodes for file
108		*
109		* @return Node[]
110		*/
111		public function getNodes()
112		{
113		return $this->topLevelNodes;
114		}
115
116		/**
117		* Returns the presence of namespace in the file
118		*
119		* @param string $namespaceName Namespace to check
120		*
121		* @return bool
122		*/
123	3029	public function hasFileNamespace($namespaceName)
124		{
125	3029	$namespaces = $this->getFileNamespaces();
126
127	3029	return isset($namespaces[$namespaceName]);
128		}
129
130		/**
131		* Checks if the current file is in strict mode
132		*
133		* @return bool
134		*/
135	4	public function isStrictMode()
136		{
137		// declare statement for the strict_types can be only top-level node
138	4	$topLevelNode = reset($this->topLevelNodes);
139	4	if (!$topLevelNode instanceof Node\Stmt\Declare_) {
140	1	return false;
141		}
142
143	3	$declareStatement = reset($topLevelNode->declares);
144	3	$isStrictTypeKey = $declareStatement->key === 'strict_types';
145	3	$isScalarValue = $declareStatement->value instanceof Node\Scalar\LNumber;
146	3	$isStrictMode = $isStrictTypeKey && $isScalarValue && $declareStatement->value->value === 1;
147
148	3	return $isStrictMode;
149		}
150
151		/**
152		* Searches for file namespaces in the given AST
153		*
154		* @return array\|ReflectionFileNamespace[]
155		*/
156	3037	private function findFileNamespaces()
157		{
158	3037	$namespaces = array();
159
160		// namespaces can be only top-level nodes, so we can scan them directly
161	3037	foreach ($this->topLevelNodes as $topLevelNode) {
162	3037	if ($topLevelNode instanceof Namespace_) {
163	3037	$namespaceName = $topLevelNode->name ? $topLevelNode->name->toString() : '';
164
165	3037	$namespaces[$namespaceName] = new ReflectionFileNamespace(
166	3037	$this->fileName,
167	3037	$namespaceName,
168	3037	$topLevelNode
169		);
170		}
171		}
172
173	3037	return $namespaces;
174		}
175		}
176

goaop / parser-reflection

Push — master ( 34991a...adfc38 )

ReflectionFile::getNodes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like