ReflectionEngine::parseFileNamespace() - Code Metrics - Inspection of "Merge remote-tracking branch 'origin/fix/resolving..." - goaop/parser-reflection - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( fdee56...483c4c )

by Alexander

created 2016-09-25 11:23 UTC

ReflectionEngine::parseFileNamespace() B

↳ Parent: ReflectionEngine

Complexity

Conditions	5
Paths	6

Size

Total Lines	16
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	5.2742

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	7
cts	9
cp	0.7778
rs	8.8571
c	0
b	0
f	0
cc	5
eloc	9
nc	6
nop	2
crap	5.2742

<?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 Go\ParserReflection\NodeVisitor\RootNamespaceNormalizer;
use PhpParser\Lexer;
use PhpParser\Node;
use PhpParser\Node\Stmt\ClassLike;
use PhpParser\Node\Stmt\ClassMethod;
use PhpParser\Node\Stmt\Namespace_;
use PhpParser\Node\Stmt\Property;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor\NameResolver;
use PhpParser\Parser;
use PhpParser\ParserFactory;

/**
 * AST-based reflection engine, powered by PHP-Parser
 */
class ReflectionEngine
{
    /**
     * @var null|LocatorInterface
     */
    protected static $locator = null;

    /**
     * @var array|Node[]
     */
    protected static $parsedFiles = array();

    /**
     * @var null|integer
     */
    protected static $maximumCachedFiles;

    /**
     * @var null|Parser
     */
    protected static $parser = null;

    /**
     * @var null|NodeTraverser
     */
    protected static $traverser = null;

    private function __construct() {}

    public static function init(LocatorInterface $locator)
    {
        $refParser   = new \ReflectionClass(Parser::class);
        $isNewParser = $refParser->isInterface();
        if (!$isNewParser) {
            self::$parser = new Parser(new Lexer(['usedAttributes' => [

                'comments', 'startLine', 'endLine', 'startTokenPos', 'endTokenPos', 'startFilePos', 'endFilePos'
            ]]));
        } else {
            self::$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
        }

        self::$traverser = $traverser = new NodeTraverser();
        $traverser->addVisitor(new NameResolver());
        $traverser->addVisitor(new RootNamespaceNormalizer());

        self::$locator = $locator;
    }

    /**
     * Limits number of files, that can be cached at any given moment
     *
     * @param integer $newLimit New limit
     *
     * @return void
     */
    public static function setMaximumCachedFiles($newLimit)
    {
        self::$maximumCachedFiles = $newLimit;
        if (count(self::$parsedFiles) > $newLimit) {
            self::$parsedFiles = array_slice(self::$parsedFiles, 0, $newLimit);
        }
    }

    /**
     * Locates a file name for class
     *
     * @param string $fullClassName Full name of the class
     *
     * @return string
     */
    public static function locateClassFile($fullClassName)
    {
        if (class_exists($fullClassName, false)
            || interface_exists($fullClassName, false)
            || trait_exists($fullClassName, false)
        ) {
            $refClass      = new \ReflectionClass($fullClassName);
            $classFileName = $refClass->getFileName();
        } else {
            $classFileName = self::$locator->locateClass($fullClassName);
        }

        if (!$classFileName) {
            throw new \InvalidArgumentException("Class $fullClassName was not found by locator");
        }

        return $classFileName;
    }

    /**
     * Tries to parse a class by name using LocatorInterface
     *
     * @param string $fullClassName Class name to load
     *
     * @return ClassLike
     */
    public static function parseClass($fullClassName)
    {
        $classFileName  = self::locateClassFile($fullClassName);
        $namespaceParts = explode('\\', $fullClassName);
        $className      = array_pop($namespaceParts);
        $namespaceName  = join('\\', $namespaceParts);

        // we have a namespace node somewhere
        $namespace      = self::parseFileNamespace($classFileName, $namespaceName);
        $namespaceNodes = $namespace->stmts;

        foreach ($namespaceNodes as $namespaceLevelNode) {
            if ($namespaceLevelNode instanceof ClassLike && $namespaceLevelNode->name == $className) {
                $namespaceLevelNode->setAttribute('fileName', $classFileName);

                return $namespaceLevelNode;
            }
        }

        throw new \InvalidArgumentException("Class $fullClassName was not found in the $classFileName");
    }

    /**
     * Parses class method
     *
     * @param string $fullClassName Name of the class
     * @param string $methodName Name of the method
     *
     * @return ClassMethod
     */
    public static function parseClassMethod($fullClassName, $methodName)
    {
        $class      = self::parseClass($fullClassName);
        $classNodes = $class->stmts;

        foreach ($classNodes as $classLevelNode) {
            if ($classLevelNode instanceof ClassMethod && $classLevelNode->name == $methodName) {
                return $classLevelNode;
            }
        }

        throw new \InvalidArgumentException("Method $methodName was not found in the $fullClassName");
    }

    /**
     * Parses class property
     *
     * @param string $fullClassName Name of the class
     * @param string $propertyName Name of the property
     *
     * @return array Pair of [Property and PropertyProperty] nodes
     */
    public static function parseClassProperty($fullClassName, $propertyName)
    {
        $class      = self::parseClass($fullClassName);
        $classNodes = $class->stmts;

        foreach ($classNodes as $classLevelNode) {
            if ($classLevelNode instanceof Property) {
                foreach ($classLevelNode->props as $classProperty) {
                    if ($classProperty->name == $propertyName) {
                        return [$classLevelNode, $classProperty];
                    }
                }
            }
        }

        throw new \InvalidArgumentException("Property $propertyName was not found in the $fullClassName");
    }

    /**
     * Parses a file and returns an AST for it
     *
     * @param string      $fileName Name of the file
     * @param string|null $fileContent Optional content of the file
     *
     * @return \PhpParser\Node[]
     */
    public static function parseFile($fileName, $fileContent = null)
    {
        $fileName = PathResolver::realpath($fileName);
        if (isset(self::$parsedFiles[$fileName])) {
            return self::$parsedFiles[$fileName];
        }

        if (isset(self::$maximumCachedFiles) && (count(self::$parsedFiles) === self::$maximumCachedFiles)) {
            array_shift(self::$parsedFiles);
        }

        if (!isset($fileContent)) {
            $fileContent = file_get_contents($fileName);
        }
        $treeNode = self::$parser->parse($fileContent);
        $treeNode = self::$traverser->traverse($treeNode);

        self::$parsedFiles[$fileName] = $treeNode;

        return $treeNode;
    }

    /**
     * Parses a file namespace and returns an AST for it
     *
     * @param string $fileName Name of the file
     * @param string $namespaceName Namespace name
     *
     * @return Namespace_
     */
    public static function parseFileNamespace($fileName, $namespaceName)
    {
        $topLevelNodes = self::parseFile($fileName);
        // namespaces can be only top-level nodes, so we can scan them directly
        foreach ($topLevelNodes as $topLevelNode) {
            if (!$topLevelNode instanceof Namespace_) {
                continue;
            }
            $topLevelNodeName = $topLevelNode->name ? $topLevelNode->name->toString() : '';
            if ($topLevelNodeName === $namespaceName) {
                return $topLevelNode;
            }
        }

        throw new ReflectionException("Namespace $namespaceName was not found in the file $fileName");
    }

}


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		use Go\ParserReflection\Instrument\PathResolver;
14		use Go\ParserReflection\NodeVisitor\RootNamespaceNormalizer;
15		use PhpParser\Lexer;
16		use PhpParser\Node;
17		use PhpParser\Node\Stmt\ClassLike;
18		use PhpParser\Node\Stmt\ClassMethod;
19		use PhpParser\Node\Stmt\Namespace_;
20		use PhpParser\Node\Stmt\Property;
21		use PhpParser\NodeTraverser;
22		use PhpParser\NodeVisitor\NameResolver;
23		use PhpParser\Parser;
24		use PhpParser\ParserFactory;
25
26		/**
27		* AST-based reflection engine, powered by PHP-Parser
28		*/
29		class ReflectionEngine
30		{
31		/**
32		* @var null\|LocatorInterface
33		*/
34		protected static $locator = null;
35
36		/**
37		* @var array\|Node[]
38		*/
39		protected static $parsedFiles = array();
40
41		/**
42		* @var null\|integer
43		*/
44		protected static $maximumCachedFiles;
45
46		/**
47		* @var null\|Parser
48		*/
49		protected static $parser = null;
50
51		/**
52		* @var null\|NodeTraverser
53		*/
54		protected static $traverser = null;
55
56		private function __construct() {}
57
58		public static function init(LocatorInterface $locator)
59		{
60		$refParser = new \ReflectionClass(Parser::class);
61		$isNewParser = $refParser->isInterface();
62		if (!$isNewParser) {
63		self::$parser = new Parser(new Lexer(['usedAttributes' => [
		0 ignored issues – show Unused Code introduced 2015-12-26 21:53 UTC by Report Bug Copy Issue Report The call to `Parser::__construct()` has too many arguments starting with `new \PhpParser\Lexer(arr...lePos', 'endFilePos')))`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
64		'comments', 'startLine', 'endLine', 'startTokenPos', 'endTokenPos', 'startFilePos', 'endFilePos'
65		]]));
66		} else {
67		self::$parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7);
68		}
69
70		self::$traverser = $traverser = new NodeTraverser();
71		$traverser->addVisitor(new NameResolver());
72		$traverser->addVisitor(new RootNamespaceNormalizer());
73
74		self::$locator = $locator;
75		}
76
77		/**
78		* Limits number of files, that can be cached at any given moment
79		*
80		* @param integer $newLimit New limit
81		*
82		* @return void
83		*/
84		public static function setMaximumCachedFiles($newLimit)
85		{
86		self::$maximumCachedFiles = $newLimit;
87		if (count(self::$parsedFiles) > $newLimit) {
88		self::$parsedFiles = array_slice(self::$parsedFiles, 0, $newLimit);
89		}
90		}
91
92		/**
93		* Locates a file name for class
94		*
95		* @param string $fullClassName Full name of the class
96		*
97		* @return string
98		*/
99	12	public static function locateClassFile($fullClassName)
100		{
101	12	if (class_exists($fullClassName, false)
102	1	\|\| interface_exists($fullClassName, false)
103	12	\|\| trait_exists($fullClassName, false)
104		) {
105	12	$refClass = new \ReflectionClass($fullClassName);
106	12	$classFileName = $refClass->getFileName();
107		} else {
108		$classFileName = self::$locator->locateClass($fullClassName);
109		}
110
111	12	if (!$classFileName) {
112		throw new \InvalidArgumentException("Class $fullClassName was not found by locator");
113		}
114
115	12	return $classFileName;
116		}
117
118		/**
119		* Tries to parse a class by name using LocatorInterface
120		*
121		* @param string $fullClassName Class name to load
122		*
123		* @return ClassLike
124		*/
125	12	public static function parseClass($fullClassName)
126		{
127	12	$classFileName = self::locateClassFile($fullClassName);
128	12	$namespaceParts = explode('\\', $fullClassName);
129	12	$className = array_pop($namespaceParts);
130	12	$namespaceName = join('\\', $namespaceParts);
131
132		// we have a namespace node somewhere
133	12	$namespace = self::parseFileNamespace($classFileName, $namespaceName);
134	12	$namespaceNodes = $namespace->stmts;
135
136	12	foreach ($namespaceNodes as $namespaceLevelNode) {
137	12	if ($namespaceLevelNode instanceof ClassLike && $namespaceLevelNode->name == $className) {
138	12	$namespaceLevelNode->setAttribute('fileName', $classFileName);
139
140	12	return $namespaceLevelNode;
141		}
142		}
143
144		throw new \InvalidArgumentException("Class $fullClassName was not found in the $classFileName");
145		}
146
147		/**
148		* Parses class method
149		*
150		* @param string $fullClassName Name of the class
151		* @param string $methodName Name of the method
152		*
153		* @return ClassMethod
154		*/
155	1	public static function parseClassMethod($fullClassName, $methodName)
156		{
157	1	$class = self::parseClass($fullClassName);
158	1	$classNodes = $class->stmts;
159
160	1	foreach ($classNodes as $classLevelNode) {
161	1	if ($classLevelNode instanceof ClassMethod && $classLevelNode->name == $methodName) {
162	1	return $classLevelNode;
163		}
164		}
165
166		throw new \InvalidArgumentException("Method $methodName was not found in the $fullClassName");
167		}
168
169		/**
170		* Parses class property
171		*
172		* @param string $fullClassName Name of the class
173		* @param string $propertyName Name of the property
174		*
175		* @return array Pair of [Property and PropertyProperty] nodes
176		*/
177	2	public static function parseClassProperty($fullClassName, $propertyName)
178		{
179	2	$class = self::parseClass($fullClassName);
180	2	$classNodes = $class->stmts;
181
182	2	foreach ($classNodes as $classLevelNode) {
183	2	if ($classLevelNode instanceof Property) {
184	2	foreach ($classLevelNode->props as $classProperty) {
185	2	if ($classProperty->name == $propertyName) {
186	2	return [$classLevelNode, $classProperty];
187		}
188		}
189		}
190		}
191
192		throw new \InvalidArgumentException("Property $propertyName was not found in the $fullClassName");
193		}
194
195		/**
196		* Parses a file and returns an AST for it
197		*
198		* @param string $fileName Name of the file
199		* @param string\|null $fileContent Optional content of the file
200		*
201		* @return \PhpParser\Node[]
202		*/
203	143	public static function parseFile($fileName, $fileContent = null)
204		{
205	143	$fileName = PathResolver::realpath($fileName);
206	143	if (isset(self::$parsedFiles[$fileName])) {
207	139	return self::$parsedFiles[$fileName];
208		}
209
210	9	if (isset(self::$maximumCachedFiles) && (count(self::$parsedFiles) === self::$maximumCachedFiles)) {
211		array_shift(self::$parsedFiles);
212		}
213
214	9	if (!isset($fileContent)) {
215	9	$fileContent = file_get_contents($fileName);
216		}
217	9	$treeNode = self::$parser->parse($fileContent);
218	9	$treeNode = self::$traverser->traverse($treeNode);
219
220	9	self::$parsedFiles[$fileName] = $treeNode;
221
222	9	return $treeNode;
223		}
224
225		/**
226		* Parses a file namespace and returns an AST for it
227		*
228		* @param string $fileName Name of the file
229		* @param string $namespaceName Namespace name
230		*
231		* @return Namespace_
232		*/
233	25	public static function parseFileNamespace($fileName, $namespaceName)
234		{
235	25	$topLevelNodes = self::parseFile($fileName);
236		// namespaces can be only top-level nodes, so we can scan them directly
237	25	foreach ($topLevelNodes as $topLevelNode) {
238	25	if (!$topLevelNode instanceof Namespace_) {
239		continue;
240		}
241	25	$topLevelNodeName = $topLevelNode->name ? $topLevelNode->name->toString() : '';
242	25	if ($topLevelNodeName === $namespaceName) {
243	25	return $topLevelNode;
244		}
245		}
246
247		throw new ReflectionException("Namespace $namespaceName was not found in the file $fileName");
248		}
249
250		}
251

goaop / parser-reflection

Push — master ( fdee56...483c4c )

ReflectionEngine::parseFileNamespace() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like