PageRenderTime 56ms CodeModel.GetById 7ms app.highlight 41ms RepoModel.GetById 2ms app.codeStats 0ms

/vendor/phpunit/php-code-coverage/src/Node/File.php

https://bitbucket.org/alan_cordova/api-sb-map
PHP | 722 lines | 425 code | 106 blank | 191 comment | 52 complexity | 05dd6b0882423cfbad353fbaf491d3d7 MD5 | raw file
  1<?php
  2/*
  3 * This file is part of the php-code-coverage package.
  4 *
  5 * (c) Sebastian Bergmann <sebastian@phpunit.de>
  6 *
  7 * For the full copyright and license information, please view the LICENSE
  8 * file that was distributed with this source code.
  9 */
 10
 11namespace SebastianBergmann\CodeCoverage\Node;
 12
 13use SebastianBergmann\CodeCoverage\InvalidArgumentException;
 14
 15/**
 16 * Represents a file in the code coverage information tree.
 17 */
 18class File extends AbstractNode
 19{
 20    /**
 21     * @var array
 22     */
 23    private $coverageData;
 24
 25    /**
 26     * @var array
 27     */
 28    private $testData;
 29
 30    /**
 31     * @var int
 32     */
 33    private $numExecutableLines = 0;
 34
 35    /**
 36     * @var int
 37     */
 38    private $numExecutedLines = 0;
 39
 40    /**
 41     * @var array
 42     */
 43    private $classes = [];
 44
 45    /**
 46     * @var array
 47     */
 48    private $traits = [];
 49
 50    /**
 51     * @var array
 52     */
 53    private $functions = [];
 54
 55    /**
 56     * @var array
 57     */
 58    private $linesOfCode = [];
 59
 60    /**
 61     * @var int
 62     */
 63    private $numClasses = null;
 64
 65    /**
 66     * @var int
 67     */
 68    private $numTestedClasses = 0;
 69
 70    /**
 71     * @var int
 72     */
 73    private $numTraits = null;
 74
 75    /**
 76     * @var int
 77     */
 78    private $numTestedTraits = 0;
 79
 80    /**
 81     * @var int
 82     */
 83    private $numMethods = null;
 84
 85    /**
 86     * @var int
 87     */
 88    private $numTestedMethods = null;
 89
 90    /**
 91     * @var int
 92     */
 93    private $numTestedFunctions = null;
 94
 95    /**
 96     * @var array
 97     */
 98    private $startLines = [];
 99
100    /**
101     * @var array
102     */
103    private $endLines = [];
104
105    /**
106     * @var bool
107     */
108    private $cacheTokens;
109
110    /**
111     * Constructor.
112     *
113     * @param string       $name
114     * @param AbstractNode $parent
115     * @param array        $coverageData
116     * @param array        $testData
117     * @param bool         $cacheTokens
118     *
119     * @throws InvalidArgumentException
120     */
121    public function __construct($name, AbstractNode $parent, array $coverageData, array $testData, $cacheTokens)
122    {
123        if (!is_bool($cacheTokens)) {
124            throw InvalidArgumentException::create(
125                1,
126                'boolean'
127            );
128        }
129
130        parent::__construct($name, $parent);
131
132        $this->coverageData = $coverageData;
133        $this->testData     = $testData;
134        $this->cacheTokens  = $cacheTokens;
135
136        $this->calculateStatistics();
137    }
138
139    /**
140     * Returns the number of files in/under this node.
141     *
142     * @return int
143     */
144    public function count()
145    {
146        return 1;
147    }
148
149    /**
150     * Returns the code coverage data of this node.
151     *
152     * @return array
153     */
154    public function getCoverageData()
155    {
156        return $this->coverageData;
157    }
158
159    /**
160     * Returns the test data of this node.
161     *
162     * @return array
163     */
164    public function getTestData()
165    {
166        return $this->testData;
167    }
168
169    /**
170     * Returns the classes of this node.
171     *
172     * @return array
173     */
174    public function getClasses()
175    {
176        return $this->classes;
177    }
178
179    /**
180     * Returns the traits of this node.
181     *
182     * @return array
183     */
184    public function getTraits()
185    {
186        return $this->traits;
187    }
188
189    /**
190     * Returns the functions of this node.
191     *
192     * @return array
193     */
194    public function getFunctions()
195    {
196        return $this->functions;
197    }
198
199    /**
200     * Returns the LOC/CLOC/NCLOC of this node.
201     *
202     * @return array
203     */
204    public function getLinesOfCode()
205    {
206        return $this->linesOfCode;
207    }
208
209    /**
210     * Returns the number of executable lines.
211     *
212     * @return int
213     */
214    public function getNumExecutableLines()
215    {
216        return $this->numExecutableLines;
217    }
218
219    /**
220     * Returns the number of executed lines.
221     *
222     * @return int
223     */
224    public function getNumExecutedLines()
225    {
226        return $this->numExecutedLines;
227    }
228
229    /**
230     * Returns the number of classes.
231     *
232     * @return int
233     */
234    public function getNumClasses()
235    {
236        if ($this->numClasses === null) {
237            $this->numClasses = 0;
238
239            foreach ($this->classes as $class) {
240                foreach ($class['methods'] as $method) {
241                    if ($method['executableLines'] > 0) {
242                        $this->numClasses++;
243
244                        continue 2;
245                    }
246                }
247            }
248        }
249
250        return $this->numClasses;
251    }
252
253    /**
254     * Returns the number of tested classes.
255     *
256     * @return int
257     */
258    public function getNumTestedClasses()
259    {
260        return $this->numTestedClasses;
261    }
262
263    /**
264     * Returns the number of traits.
265     *
266     * @return int
267     */
268    public function getNumTraits()
269    {
270        if ($this->numTraits === null) {
271            $this->numTraits = 0;
272
273            foreach ($this->traits as $trait) {
274                foreach ($trait['methods'] as $method) {
275                    if ($method['executableLines'] > 0) {
276                        $this->numTraits++;
277
278                        continue 2;
279                    }
280                }
281            }
282        }
283
284        return $this->numTraits;
285    }
286
287    /**
288     * Returns the number of tested traits.
289     *
290     * @return int
291     */
292    public function getNumTestedTraits()
293    {
294        return $this->numTestedTraits;
295    }
296
297    /**
298     * Returns the number of methods.
299     *
300     * @return int
301     */
302    public function getNumMethods()
303    {
304        if ($this->numMethods === null) {
305            $this->numMethods = 0;
306
307            foreach ($this->classes as $class) {
308                foreach ($class['methods'] as $method) {
309                    if ($method['executableLines'] > 0) {
310                        $this->numMethods++;
311                    }
312                }
313            }
314
315            foreach ($this->traits as $trait) {
316                foreach ($trait['methods'] as $method) {
317                    if ($method['executableLines'] > 0) {
318                        $this->numMethods++;
319                    }
320                }
321            }
322        }
323
324        return $this->numMethods;
325    }
326
327    /**
328     * Returns the number of tested methods.
329     *
330     * @return int
331     */
332    public function getNumTestedMethods()
333    {
334        if ($this->numTestedMethods === null) {
335            $this->numTestedMethods = 0;
336
337            foreach ($this->classes as $class) {
338                foreach ($class['methods'] as $method) {
339                    if ($method['executableLines'] > 0 &&
340                        $method['coverage'] == 100) {
341                        $this->numTestedMethods++;
342                    }
343                }
344            }
345
346            foreach ($this->traits as $trait) {
347                foreach ($trait['methods'] as $method) {
348                    if ($method['executableLines'] > 0 &&
349                        $method['coverage'] == 100) {
350                        $this->numTestedMethods++;
351                    }
352                }
353            }
354        }
355
356        return $this->numTestedMethods;
357    }
358
359    /**
360     * Returns the number of functions.
361     *
362     * @return int
363     */
364    public function getNumFunctions()
365    {
366        return count($this->functions);
367    }
368
369    /**
370     * Returns the number of tested functions.
371     *
372     * @return int
373     */
374    public function getNumTestedFunctions()
375    {
376        if ($this->numTestedFunctions === null) {
377            $this->numTestedFunctions = 0;
378
379            foreach ($this->functions as $function) {
380                if ($function['executableLines'] > 0 &&
381                    $function['coverage'] == 100) {
382                    $this->numTestedFunctions++;
383                }
384            }
385        }
386
387        return $this->numTestedFunctions;
388    }
389
390    /**
391     * Calculates coverage statistics for the file.
392     */
393    protected function calculateStatistics()
394    {
395        $classStack = $functionStack = [];
396
397        if ($this->cacheTokens) {
398            $tokens = \PHP_Token_Stream_CachingFactory::get($this->getPath());
399        } else {
400            $tokens = new \PHP_Token_Stream($this->getPath());
401        }
402
403        $this->processClasses($tokens);
404        $this->processTraits($tokens);
405        $this->processFunctions($tokens);
406        $this->linesOfCode = $tokens->getLinesOfCode();
407        unset($tokens);
408
409        for ($lineNumber = 1; $lineNumber <= $this->linesOfCode['loc']; $lineNumber++) {
410            if (isset($this->startLines[$lineNumber])) {
411                // Start line of a class.
412                if (isset($this->startLines[$lineNumber]['className'])) {
413                    if (isset($currentClass)) {
414                        $classStack[] = &$currentClass;
415                    }
416
417                    $currentClass = &$this->startLines[$lineNumber];
418                } // Start line of a trait.
419                elseif (isset($this->startLines[$lineNumber]['traitName'])) {
420                    $currentTrait = &$this->startLines[$lineNumber];
421                } // Start line of a method.
422                elseif (isset($this->startLines[$lineNumber]['methodName'])) {
423                    $currentMethod = &$this->startLines[$lineNumber];
424                } // Start line of a function.
425                elseif (isset($this->startLines[$lineNumber]['functionName'])) {
426                    if (isset($currentFunction)) {
427                        $functionStack[] = &$currentFunction;
428                    }
429
430                    $currentFunction = &$this->startLines[$lineNumber];
431                }
432            }
433
434            if (isset($this->coverageData[$lineNumber])) {
435                if (isset($currentClass)) {
436                    $currentClass['executableLines']++;
437                }
438
439                if (isset($currentTrait)) {
440                    $currentTrait['executableLines']++;
441                }
442
443                if (isset($currentMethod)) {
444                    $currentMethod['executableLines']++;
445                }
446
447                if (isset($currentFunction)) {
448                    $currentFunction['executableLines']++;
449                }
450
451                $this->numExecutableLines++;
452
453                if (count($this->coverageData[$lineNumber]) > 0) {
454                    if (isset($currentClass)) {
455                        $currentClass['executedLines']++;
456                    }
457
458                    if (isset($currentTrait)) {
459                        $currentTrait['executedLines']++;
460                    }
461
462                    if (isset($currentMethod)) {
463                        $currentMethod['executedLines']++;
464                    }
465
466                    if (isset($currentFunction)) {
467                        $currentFunction['executedLines']++;
468                    }
469
470                    $this->numExecutedLines++;
471                }
472            }
473
474            if (isset($this->endLines[$lineNumber])) {
475                // End line of a class.
476                if (isset($this->endLines[$lineNumber]['className'])) {
477                    unset($currentClass);
478
479                    if ($classStack) {
480                        end($classStack);
481                        $key          = key($classStack);
482                        $currentClass = &$classStack[$key];
483                        unset($classStack[$key]);
484                    }
485                } // End line of a trait.
486                elseif (isset($this->endLines[$lineNumber]['traitName'])) {
487                    unset($currentTrait);
488                } // End line of a method.
489                elseif (isset($this->endLines[$lineNumber]['methodName'])) {
490                    unset($currentMethod);
491                } // End line of a function.
492                elseif (isset($this->endLines[$lineNumber]['functionName'])) {
493                    unset($currentFunction);
494
495                    if ($functionStack) {
496                        end($functionStack);
497                        $key             = key($functionStack);
498                        $currentFunction = &$functionStack[$key];
499                        unset($functionStack[$key]);
500                    }
501                }
502            }
503        }
504
505        foreach ($this->traits as &$trait) {
506            foreach ($trait['methods'] as &$method) {
507                if ($method['executableLines'] > 0) {
508                    $method['coverage'] = ($method['executedLines'] /
509                            $method['executableLines']) * 100;
510                } else {
511                    $method['coverage'] = 100;
512                }
513
514                $method['crap'] = $this->crap(
515                    $method['ccn'],
516                    $method['coverage']
517                );
518
519                $trait['ccn'] += $method['ccn'];
520            }
521
522            if ($trait['executableLines'] > 0) {
523                $trait['coverage'] = ($trait['executedLines'] /
524                        $trait['executableLines']) * 100;
525
526                if ($trait['coverage'] == 100) {
527                    $this->numTestedClasses++;
528                }
529            } else {
530                $trait['coverage'] = 100;
531            }
532
533            $trait['crap'] = $this->crap(
534                $trait['ccn'],
535                $trait['coverage']
536            );
537        }
538
539        foreach ($this->classes as &$class) {
540            foreach ($class['methods'] as &$method) {
541                if ($method['executableLines'] > 0) {
542                    $method['coverage'] = ($method['executedLines'] /
543                            $method['executableLines']) * 100;
544                } else {
545                    $method['coverage'] = 100;
546                }
547
548                $method['crap'] = $this->crap(
549                    $method['ccn'],
550                    $method['coverage']
551                );
552
553                $class['ccn'] += $method['ccn'];
554            }
555
556            if ($class['executableLines'] > 0) {
557                $class['coverage'] = ($class['executedLines'] /
558                        $class['executableLines']) * 100;
559
560                if ($class['coverage'] == 100) {
561                    $this->numTestedClasses++;
562                }
563            } else {
564                $class['coverage'] = 100;
565            }
566
567            $class['crap'] = $this->crap(
568                $class['ccn'],
569                $class['coverage']
570            );
571        }
572    }
573
574    /**
575     * @param \PHP_Token_Stream $tokens
576     */
577    protected function processClasses(\PHP_Token_Stream $tokens)
578    {
579        $classes = $tokens->getClasses();
580        unset($tokens);
581
582        $link = $this->getId() . '.html#';
583
584        foreach ($classes as $className => $class) {
585            $this->classes[$className] = [
586                'className'       => $className,
587                'methods'         => [],
588                'startLine'       => $class['startLine'],
589                'executableLines' => 0,
590                'executedLines'   => 0,
591                'ccn'             => 0,
592                'coverage'        => 0,
593                'crap'            => 0,
594                'package'         => $class['package'],
595                'link'            => $link . $class['startLine']
596            ];
597
598            $this->startLines[$class['startLine']] = &$this->classes[$className];
599            $this->endLines[$class['endLine']]     = &$this->classes[$className];
600
601            foreach ($class['methods'] as $methodName => $method) {
602                $this->classes[$className]['methods'][$methodName] = $this->newMethod($methodName, $method, $link);
603
604                $this->startLines[$method['startLine']] = &$this->classes[$className]['methods'][$methodName];
605                $this->endLines[$method['endLine']]     = &$this->classes[$className]['methods'][$methodName];
606            }
607        }
608    }
609
610    /**
611     * @param \PHP_Token_Stream $tokens
612     */
613    protected function processTraits(\PHP_Token_Stream $tokens)
614    {
615        $traits = $tokens->getTraits();
616        unset($tokens);
617
618        $link = $this->getId() . '.html#';
619
620        foreach ($traits as $traitName => $trait) {
621            $this->traits[$traitName] = [
622                'traitName'       => $traitName,
623                'methods'         => [],
624                'startLine'       => $trait['startLine'],
625                'executableLines' => 0,
626                'executedLines'   => 0,
627                'ccn'             => 0,
628                'coverage'        => 0,
629                'crap'            => 0,
630                'package'         => $trait['package'],
631                'link'            => $link . $trait['startLine']
632            ];
633
634            $this->startLines[$trait['startLine']] = &$this->traits[$traitName];
635            $this->endLines[$trait['endLine']]     = &$this->traits[$traitName];
636
637            foreach ($trait['methods'] as $methodName => $method) {
638                $this->traits[$traitName]['methods'][$methodName] = $this->newMethod($methodName, $method, $link);
639
640                $this->startLines[$method['startLine']] = &$this->traits[$traitName]['methods'][$methodName];
641                $this->endLines[$method['endLine']]     = &$this->traits[$traitName]['methods'][$methodName];
642            }
643        }
644    }
645
646    /**
647     * @param \PHP_Token_Stream $tokens
648     */
649    protected function processFunctions(\PHP_Token_Stream $tokens)
650    {
651        $functions = $tokens->getFunctions();
652        unset($tokens);
653
654        $link = $this->getId() . '.html#';
655
656        foreach ($functions as $functionName => $function) {
657            $this->functions[$functionName] = [
658                'functionName'    => $functionName,
659                'signature'       => $function['signature'],
660                'startLine'       => $function['startLine'],
661                'executableLines' => 0,
662                'executedLines'   => 0,
663                'ccn'             => $function['ccn'],
664                'coverage'        => 0,
665                'crap'            => 0,
666                'link'            => $link . $function['startLine']
667            ];
668
669            $this->startLines[$function['startLine']] = &$this->functions[$functionName];
670            $this->endLines[$function['endLine']]     = &$this->functions[$functionName];
671        }
672    }
673
674    /**
675     * Calculates the Change Risk Anti-Patterns (CRAP) index for a unit of code
676     * based on its cyclomatic complexity and percentage of code coverage.
677     *
678     * @param int   $ccn
679     * @param float $coverage
680     *
681     * @return string
682     */
683    protected function crap($ccn, $coverage)
684    {
685        if ($coverage == 0) {
686            return (string) (pow($ccn, 2) + $ccn);
687        }
688
689        if ($coverage >= 95) {
690            return (string) $ccn;
691        }
692
693        return sprintf(
694            '%01.2F',
695            pow($ccn, 2) * pow(1 - $coverage/100, 3) + $ccn
696        );
697    }
698
699    /**
700     * @param string $methodName
701     * @param array  $method
702     * @param string $link
703     *
704     * @return array
705     */
706    private function newMethod($methodName, array $method, $link)
707    {
708        return [
709            'methodName'      => $methodName,
710            'visibility'      => $method['visibility'],
711            'signature'       => $method['signature'],
712            'startLine'       => $method['startLine'],
713            'endLine'         => $method['endLine'],
714            'executableLines' => 0,
715            'executedLines'   => 0,
716            'ccn'             => $method['ccn'],
717            'coverage'        => 0,
718            'crap'            => 0,
719            'link'            => $link . $method['startLine'],
720        ];
721    }
722}