ReflectionFile   A
last analyzed

Complexity

Total Complexity 18

Size/Duplication

Total Lines 155
Duplicated Lines 0 %

Coupling/Cohesion

Components 1
Dependencies 7

Test Coverage

Coverage 95.45%

Importance

Changes 0
Metric Value
wmc 18
lcom 1
cbo 7
dl 0
loc 155
ccs 42
cts 44
cp 0.9545
rs 10
c 0
b 0
f 0

8 Methods

Rating   Name   Duplication   Size   Complexity  
A __construct() 0 14 3
A getFileNamespace() 0 8 2
A getFileNamespaces() 0 8 2
A getName() 0 4 1
A getNodes() 0 4 1
A hasFileNamespace() 0 6 1
A isStrictMode() 0 15 4
A findFileNamespaces() 0 19 4
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 3047
    public function __construct($fileName, $topLevelNodes = null)
52
    {
53 3047
        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 3047
        $fileName            = PathResolver::realpath($fileName);
62 3047
        $this->fileName      = $fileName;
0 ignored issues
show
Documentation Bug introduced by Lisachenko Alexander
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 3047
        $this->topLevelNodes = $topLevelNodes ?: ReflectionEngine::parseFile($fileName);
64 3047
    }
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 3029
    public function getFileNamespace($namespaceName)
74
    {
75 3029
        if ($this->hasFileNamespace($namespaceName)) {
76 3029
            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 3038
    public function getFileNamespaces()
88
    {
89 3038
        if (!isset($this->fileNamespaces)) {
90 3038
            $this->fileNamespaces = $this->findFileNamespaces();
91
        }
92
93 3038
        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 3030
    public function hasFileNamespace($namespaceName)
124
    {
125 3030
        $namespaces = $this->getFileNamespaces();
126
127 3030
        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->toString() === '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 3038
    private function findFileNamespaces()
157
    {
158 3038
        $namespaces = array();
159
160
        // namespaces can be only top-level nodes, so we can scan them directly
161 3038
        foreach ($this->topLevelNodes as $topLevelNode) {
162 3038
            if ($topLevelNode instanceof Namespace_) {
163 3038
                $namespaceName = $topLevelNode->name ? $topLevelNode->name->toString() : '';
164
165 3038
                $namespaces[$namespaceName] = new ReflectionFileNamespace(
166 3038
                    $this->fileName,
167 3038
                    $namespaceName,
168 3038
                    $topLevelNode
169
                );
170
            }
171
        }
172
173 3038
        return $namespaces;
174
    }
175
}
176