FullyQualifiedClassCache::readUseStatements() - Code Metrics - consolidation/annotated-command - Measure and Improve Code Quality continuously with Scrutinizer

FullyQualifiedClassCache::readUseStatements() A
last analyzed 2020-08-10 23:41 UTC

↳ Parent: FullyQualifiedClassCache

Complexity

Conditions	5
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	20
rs	9.2888
c	0
b	0
f	0
cc	5
nc	4
nop	1

<?php
namespace Consolidation\AnnotatedCommand\Parser\Internal;

class FullyQualifiedClassCache
{
    protected $classCache = [];
    protected $namespaceCache = [];

    public function qualify($filename, $className)
    {
        $this->primeCache($filename, $className);
        return $this->cached($filename, $className);
    }

    protected function cached($filename, $className)
    {
        return isset($this->classCache[$filename][$className]) ? $this->classCache[$filename][$className] : $className;
    }

    protected function primeCache($filename, $className)
    {
        // If the cache has already been primed, do no further work
        if (isset($this->namespaceCache[$filename])) {
            return false;
        }

        $handle = fopen($filename, "r");
        if (!$handle) {
            return false;
        }

        $namespaceName = $this->primeNamespaceCache($filename, $handle);
        $this->primeUseCache($filename, $handle);

        // If there is no 'use' statement for the className, then
        // generate an effective classname from the namespace
        if (!isset($this->classCache[$filename][$className])) {
            $this->classCache[$filename][$className] = $namespaceName . '\\' . $className;
        }

        fclose($handle);
    }

    protected function primeNamespaceCache($filename, $handle)
    {
        $namespaceName = $this->readNamespace($handle);
        if (!$namespaceName) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return false;
        }
        $this->namespaceCache[$filename] = $namespaceName;
        return $namespaceName;
    }

    protected function primeUseCache($filename, $handle)
    {
        $usedClasses = $this->readUseStatements($handle);
        if (empty($usedClasses)) {
            return false;
        }
        $this->classCache[$filename] = $usedClasses;
    }

    protected function readNamespace($handle)
    {
        $namespaceRegex = '#^\s*namespace\s+#';
        $line = $this->readNextRelevantLine($handle);
        if (!$line || !preg_match($namespaceRegex, $line)) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            return false;
        }

        $namespaceName = preg_replace($namespaceRegex, '', $line);
        $namespaceName = rtrim($namespaceName, ';');
        return $namespaceName;
    }

    protected function readUseStatements($handle)
    {
        $useRegex = '#^\s*use\s+#';
        $result = [];
        while (true) {
            $line = $this->readNextRelevantLine($handle);
            if (!$line || !preg_match($useRegex, $line)) {
                return $result;
            }
            $usedClass = preg_replace($useRegex, '', $line);
            $usedClass = rtrim($usedClass, ';');
            $unqualifiedClass = preg_replace('#.*\\\\#', '', $usedClass);
            // If this is an aliased class, 'use \Foo\Bar as Baz', then adjust
            if (strpos($usedClass, ' as ')) {
                $unqualifiedClass = preg_replace('#.*\sas\s+#', '', $usedClass);
                $usedClass = preg_replace('#[a-zA-Z0-9]+\s+as\s+#', '', $usedClass);
            }
            $result[$unqualifiedClass] = $usedClass;
        }
    }

    protected function readNextRelevantLine($handle)
    {
        while (($line = fgets($handle)) !== false) {
            if (preg_match('#^\s*\w#', $line)) {
                return trim($line);
            }
        }
        return false;
    }
}


1			<?php
2			namespace Consolidation\AnnotatedCommand\Parser\Internal;
3
4			class FullyQualifiedClassCache
5			{
6			protected $classCache = [];
7			protected $namespaceCache = [];
8
9			public function qualify($filename, $className)
10			{
11			$this->primeCache($filename, $className);
12			return $this->cached($filename, $className);
13			}
14
15			protected function cached($filename, $className)
16			{
17			return isset($this->classCache[$filename][$className]) ? $this->classCache[$filename][$className] : $className;
18			}
19
20			protected function primeCache($filename, $className)
21			{
22			// If the cache has already been primed, do no further work
23			if (isset($this->namespaceCache[$filename])) {
24			return false;
25			}
26
27			$handle = fopen($filename, "r");
28			if (!$handle) {
29			return false;
30			}
31
32			$namespaceName = $this->primeNamespaceCache($filename, $handle);
33			$this->primeUseCache($filename, $handle);
34
35			// If there is no 'use' statement for the className, then
36			// generate an effective classname from the namespace
37			if (!isset($this->classCache[$filename][$className])) {
38			$this->classCache[$filename][$className] = $namespaceName . '\\' . $className;
39			}
40
41			fclose($handle);
42			}
43
44			protected function primeNamespaceCache($filename, $handle)
45			{
46			$namespaceName = $this->readNamespace($handle);
47			if (!$namespaceName) {
			0 ignored issues – show Bug Best Practice introduced 2017-10-13 05:00 UTC by Report Bug Copy Issue Report The expression `$namespaceName` of type `false\|string` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
48			return false;
49			}
50			$this->namespaceCache[$filename] = $namespaceName;
51			return $namespaceName;
52			}
53
54			protected function primeUseCache($filename, $handle)
55			{
56			$usedClasses = $this->readUseStatements($handle);
57			if (empty($usedClasses)) {
58			return false;
59			}
60			$this->classCache[$filename] = $usedClasses;
61			}
62
63			protected function readNamespace($handle)
64			{
65			$namespaceRegex = '#^\s*namespace\s+#';
66			$line = $this->readNextRelevantLine($handle);
67			if (!$line \|\| !preg_match($namespaceRegex, $line)) {
			0 ignored issues – show Bug Best Practice introduced 2017-10-13 05:00 UTC by Report Bug Copy Issue Report The expression `$line` of type `string\|false` is loosely compared to `false`; this is ambiguous if the string can be empty. You might want to explicitly use `=== false` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `string` values, the empty string `''` is a special case, in particular the following results might be unexpected: '' == false // true '' == null // true 'ab' == false // false 'ab' == null // false // It is often better to use strict comparison '' === false // false '' === null // false Loading history...
68			return false;
69			}
70
71			$namespaceName = preg_replace($namespaceRegex, '', $line);
72			$namespaceName = rtrim($namespaceName, ';');
73			return $namespaceName;
74			}
75
76			protected function readUseStatements($handle)
77			{
78			$useRegex = '#^\s*use\s+#';
79			$result = [];
80			while (true) {
81			$line = $this->readNextRelevantLine($handle);
82			if (!$line \|\| !preg_match($useRegex, $line)) {
83			return $result;
84			}
85			$usedClass = preg_replace($useRegex, '', $line);
86			$usedClass = rtrim($usedClass, ';');
87			$unqualifiedClass = preg_replace('#.*\\\\#', '', $usedClass);
88			// If this is an aliased class, 'use \Foo\Bar as Baz', then adjust
89			if (strpos($usedClass, ' as ')) {
90			$unqualifiedClass = preg_replace('#.*\sas\s+#', '', $usedClass);
91			$usedClass = preg_replace('#[a-zA-Z0-9]+\s+as\s+#', '', $usedClass);
92			}
93			$result[$unqualifiedClass] = $usedClass;
94			}
95			}
96
97			protected function readNextRelevantLine($handle)
98			{
99			while (($line = fgets($handle)) !== false) {
100			if (preg_match('#^\s*\w#', $line)) {
101			return trim($line);
102			}
103			}
104			return false;
105			}
106			}
107

consolidation / annotated-command

FullyQualifiedClassCache::readUseStatements() A last analyzed 2020-08-10 23:41 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

FullyQualifiedClassCache::readUseStatements() A
last analyzed 2020-08-10 23:41 UTC