1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
|
<?php declare(strict_types=1);
/*
* This file is part of phpunit/php-code-coverage.
*
* (c) Sebastian Bergmann <[email protected]>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace SebastianBergmann\CodeCoverage\Node;
use const DIRECTORY_SEPARATOR;
use function array_merge;
use function str_replace;
use function substr;
use Countable;
use SebastianBergmann\CodeCoverage\Util\Percentage;
/**
* @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
*/
abstract class AbstractNode implements Countable
{
/**
* @var string
*/
private $name;
/**
* @var string
*/
private $pathAsString;
/**
* @var array
*/
private $pathAsArray;
/**
* @var AbstractNode
*/
private $parent;
/**
* @var string
*/
private $id;
public function __construct(string $name, self $parent = null)
{
if (substr($name, -1) === DIRECTORY_SEPARATOR) {
$name = substr($name, 0, -1);
}
$this->name = $name;
$this->parent = $parent;
}
public function name(): string
{
return $this->name;
}
public function id(): string
{
if ($this->id === null) {
$parent = $this->parent();
if ($parent === null) {
$this->id = 'index';
} else {
$parentId = $parent->id();
if ($parentId === 'index') {
$this->id = str_replace(':', '_', $this->name);
} else {
$this->id = $parentId . '/' . $this->name;
}
}
}
return $this->id;
}
public function pathAsString(): string
{
if ($this->pathAsString === null) {
if ($this->parent === null) {
$this->pathAsString = $this->name;
} else {
$this->pathAsString = $this->parent->pathAsString() . DIRECTORY_SEPARATOR . $this->name;
}
}
return $this->pathAsString;
}
public function pathAsArray(): array
{
if ($this->pathAsArray === null) {
if ($this->parent === null) {
$this->pathAsArray = [];
} else {
$this->pathAsArray = $this->parent->pathAsArray();
}
$this->pathAsArray[] = $this;
}
return $this->pathAsArray;
}
public function parent(): ?self
{
return $this->parent;
}
public function percentageOfTestedClasses(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfTestedClasses(),
$this->numberOfClasses(),
);
}
public function percentageOfTestedTraits(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfTestedTraits(),
$this->numberOfTraits(),
);
}
public function percentageOfTestedClassesAndTraits(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfTestedClassesAndTraits(),
$this->numberOfClassesAndTraits(),
);
}
public function percentageOfTestedFunctions(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfTestedFunctions(),
$this->numberOfFunctions(),
);
}
public function percentageOfTestedMethods(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfTestedMethods(),
$this->numberOfMethods(),
);
}
public function percentageOfTestedFunctionsAndMethods(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfTestedFunctionsAndMethods(),
$this->numberOfFunctionsAndMethods(),
);
}
public function percentageOfExecutedLines(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfExecutedLines(),
$this->numberOfExecutableLines(),
);
}
public function percentageOfExecutedBranches(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfExecutedBranches(),
$this->numberOfExecutableBranches()
);
}
public function percentageOfExecutedPaths(): Percentage
{
return Percentage::fromFractionAndTotal(
$this->numberOfExecutedPaths(),
$this->numberOfExecutablePaths()
);
}
public function numberOfClassesAndTraits(): int
{
return $this->numberOfClasses() + $this->numberOfTraits();
}
public function numberOfTestedClassesAndTraits(): int
{
return $this->numberOfTestedClasses() + $this->numberOfTestedTraits();
}
public function classesAndTraits(): array
{
return array_merge($this->classes(), $this->traits());
}
public function numberOfFunctionsAndMethods(): int
{
return $this->numberOfFunctions() + $this->numberOfMethods();
}
public function numberOfTestedFunctionsAndMethods(): int
{
return $this->numberOfTestedFunctions() + $this->numberOfTestedMethods();
}
abstract public function classes(): array;
abstract public function traits(): array;
abstract public function functions(): array;
/**
* @psalm-return array{linesOfCode: int, commentLinesOfCode: int, nonCommentLinesOfCode: int}
*/
abstract public function linesOfCode(): array;
abstract public function numberOfExecutableLines(): int;
abstract public function numberOfExecutedLines(): int;
abstract public function numberOfExecutableBranches(): int;
abstract public function numberOfExecutedBranches(): int;
abstract public function numberOfExecutablePaths(): int;
abstract public function numberOfExecutedPaths(): int;
abstract public function numberOfClasses(): int;
abstract public function numberOfTestedClasses(): int;
abstract public function numberOfTraits(): int;
abstract public function numberOfTestedTraits(): int;
abstract public function numberOfMethods(): int;
abstract public function numberOfTestedMethods(): int;
abstract public function numberOfFunctions(): int;
abstract public function numberOfTestedFunctions(): int;
}
|
