CoverageReportTask

Complexity

Total Complexity

57

Size/Duplication

Total Lines	542
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes	1
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	setGeshiPath()	0	3	1
B	highlightSourceFile()	0	50	6
A	setOutfile()	0	3	1
A	stripDiv()	0	12	1
A	__construct()	0	7	1
A	createReport()	0	6	1
A	setGeshiLanguagesPath()	0	3	1
A	main()	0	28	4
A	addSubpackageToPackage()	0	17	3
A	getSubpackageElement()	0	11	3
B	calculateStatistics()	0	80	5
A	addClassToSubpackage()	0	13	2
A	addClassToPackage()	0	11	2
A	getPackageElement()	0	11	3
F	transformCoverageInformation()	0	124	20
A	transformSourceFile()	0	34	3

<?php
/**
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information please see
 * <http://phing.info>.
 */

/**
 * Transforms information in a code coverage database to XML
 *
 * @author  Michiel Rook <mrook@php.net>
 * @package phing.tasks.ext.coverage
 * @since   2.1.0
 */
class CoverageReportTask extends Task
{
    use ClasspathAware;

    private $outfile = "coverage.xml";

    private $transformers = [];

    /**
     * the path to the GeSHi library (optional)
     */
    private $geshipath = "";

    /**
     * the path to the GeSHi language files (optional)
     */
    private $geshilanguagespath = "";

    /**
     * @var DOMDocument
     */
    private $doc;

    /**
     * @param $path
     */
    public function setGeshiPath($path)
    {
        $this->geshipath = $path;
    }

    /**
     * @param $path
     */
    public function setGeshiLanguagesPath($path)
    {
        $this->geshilanguagespath = $path;
    }

    /**
     *
     */
    public function __construct()
    {
        parent::__construct();
        $this->doc = new DOMDocument();
        $this->doc->encoding = 'UTF-8';
        $this->doc->formatOutput = true;
        $this->doc->appendChild($this->doc->createElement('snapshot'));
    }

    /**
     * @param $outfile
     */
    public function setOutfile($outfile)
    {
        $this->outfile = $outfile;
    }

    /**
     * Generate a report based on the XML created by this task
     */
    public function createReport()
    {
        $transformer = new CoverageReportTransformer($this);
        $this->transformers[] = $transformer;

        return $transformer;
    }

    /**
     * @param $packageName
     * @return null
     */
    protected function getPackageElement($packageName)
    {
        $packages = $this->doc->documentElement->getElementsByTagName('package');

        foreach ($packages as $package) {
            if ($package->getAttribute('name') == $packageName) {
                return $package;
            }
        }

        return null;
    }

    /**
     * @param $packageName
     * @param $element
     */
    protected function addClassToPackage($packageName, $element)
    {
        $package = $this->getPackageElement($packageName);

Are you sure the assignment to $package is correct as $this->getPackageElement($packageName) targeting CoverageReportTask::getPackageElement() seems to always return null.

        if ($package === null) {

The condition $package === null is always true.

            $package = $this->doc->createElement('package');
            $package->setAttribute('name', $packageName);
            $this->doc->documentElement->appendChild($package);
        }

        $package->appendChild($element);
    }

    /**
     * Adds a subpackage to their package
     *
     * @param string $packageName The name of the package
     * @param string $subpackageName The name of the subpackage
     *
     * @author Benjamin Schultz <bschultz@proqrent.de>
     * @return void
     */
    protected function addSubpackageToPackage($packageName, $subpackageName)
    {
        $package = $this->getPackageElement($packageName);

Are you sure the assignment to $package is correct as $this->getPackageElement($packageName) targeting CoverageReportTask::getPackageElement() seems to always return null.

        $subpackage = $this->getSubpackageElement($subpackageName);

        if ($package === null) {

The condition $package === null is always true.

            $package = $this->doc->createElement('package');
            $package->setAttribute('name', $packageName);
            $this->doc->documentElement->appendChild($package);
        }

        if ($subpackage === null) {
            $subpackage = $this->doc->createElement('subpackage');
            $subpackage->setAttribute('name', $subpackageName);
        }

        $package->appendChild($subpackage);
    }

    /**
     * Returns the subpackage element
     *
     * @param string $subpackageName The name of the subpackage
     *
     * @author Benjamin Schultz <bschultz@proqrent.de>
     * @return DOMNode|null null when no DOMNode with the given name exists
     */
    protected function getSubpackageElement($subpackageName)
    {
        $subpackages = $this->doc->documentElement->getElementsByTagName('subpackage');

        foreach ($subpackages as $subpackage) {
            if ($subpackage->getAttribute('name') == $subpackageName) {
                return $subpackage;
            }
        }

        return null;
    }

    /**
     * Adds a class to their subpackage
     *
     * @param string $classname The name of the class
     * @param DOMNode $element The dom node to append to the subpackage element
     *
     * @author Benjamin Schultz <bschultz@proqrent.de>
     * @return void
     */
    protected function addClassToSubpackage($classname, $element)
    {
        $subpackageName = PHPUnitUtil::getSubpackageName($classname);

        $subpackage = $this->getSubpackageElement($subpackageName);

        if ($subpackage === null) {
            $subpackage = $this->doc->createElement('subpackage');
            $subpackage->setAttribute('name', $subpackageName);
            $this->doc->documentElement->appendChild($subpackage);
        }

        $subpackage->appendChild($element);
    }

    /**
     * @param $source
     * @return string
     */
    protected function stripDiv($source)
    {
        $openpos = strpos($source, "<div");
        $closepos = strpos($source, ">", $openpos);

        $line = substr($source, $closepos + 1);

        $tagclosepos = strpos($line, "</div>");

        $line = substr($line, 0, $tagclosepos);

        return $line;
    }

    /**
     * @param $filename
     * @return array
     */
    protected function highlightSourceFile($filename)
    {
        if ($this->geshipath) {
            include_once $this->geshipath . '/geshi.php';

            $source = file_get_contents($filename);

            $geshi = new GeSHi($source, 'php', $this->geshilanguagespath);

The type GeSHi was not found. Maybe you did not declare it correctly or list all dependencies?

            $geshi->enable_line_numbers(GESHI_NORMAL_LINE_NUMBERS);

The constant GESHI_NORMAL_LINE_NUMBERS was not found. Maybe you did not declare it correctly or list all dependencies?

            $geshi->enable_strict_mode(true);

            $geshi->enable_classes(true);

            $geshi->set_url_for_keyword_group(3, '');

            $html = $geshi->parse_code();

            $lines = preg_split("#</?li>#", $html);

            // skip first and last line
            array_pop($lines);

It seems like $lines can also be of type false; however, parameter $array of array_pop() does only seem to accept array, maybe add an additional type check?

            array_shift($lines);

            $lines = array_filter($lines);

            $lines = array_map([$this, 'stripDiv'], $lines);

            return $lines;
        } else {
            $lines = file($filename);

            for ($i = 0; $i < count($lines); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

It seems like $lines can also be of type false; however, parameter $var of count() does only seem to accept Countable|array, maybe add an additional type check?

                $line = $lines[$i];

                $line = rtrim($line);

                if (function_exists('mb_check_encoding') && mb_check_encoding($line, 'UTF-8')) {
                    $lines[$i] = $line;
                } else {
                    if (function_exists('mb_convert_encoding')) {
                        $lines[$i] = mb_convert_encoding($line, 'UTF-8');
                    } else {
                        $lines[$i] = utf8_encode($line);
                    }
                }
            }

            return $lines;

The expression return $lines could also return false which is incompatible with the documented return type array. Did you maybe forget to handle an error condition?

        }
    }

    /**
     * @param $filename
     * @param $coverageInformation
     * @param int $classStartLine
     * @return DOMElement
     */
    protected function transformSourceFile($filename, $coverageInformation, $classStartLine = 1)
    {
        $sourceElement = $this->doc->createElement('sourcefile');
        $sourceElement->setAttribute('name', basename($filename));

        /**
         * Add original/full filename to document
         */
        $sourceElement->setAttribute('sourcefile', $filename);

        $filelines = $this->highlightSourceFile($filename);

        $linenr = 1;

        foreach ($filelines as $line) {
            $lineElement = $this->doc->createElement('sourceline');
            $lineElement->setAttribute(
                'coveredcount',
                ($coverageInformation[$linenr] ?? '0')
            );

            if ($linenr == $classStartLine) {
                $lineElement->setAttribute('startclass', 1);
            }

            $textnode = $this->doc->createTextNode($line);
            $lineElement->appendChild($textnode);

            $sourceElement->appendChild($lineElement);

            $linenr++;
        }

        return $sourceElement;
    }

    /**
     * Transforms the coverage information
     *
     * @param string $filename The filename
     * @param array $coverageInformation Array with covergae information
     *
     * @author Michiel Rook <mrook@php.net>
     * @author Benjamin Schultz <bschultz@proqrent.de>
     * @return void
     */
    protected function transformCoverageInformation($filename, $coverageInformation)
    {
        $classes = PHPUnitUtil::getDefinedClasses($filename, $this->classpath);

        if (is_array($classes)) {

The condition is_array($classes) is always true.

            foreach ($classes as $classname) {
                $reflection = new ReflectionClass($classname);
                $methods = $reflection->getMethods();

                if (method_exists($reflection, 'getShortName')) {
                    $className = $reflection->getShortName();
                } else {
                    $className = $reflection->getName();
                }

                $classElement = $this->doc->createElement('class');
                $classElement->setAttribute('name', $className);

                $packageName = PHPUnitUtil::getPackageName($reflection->getName());
                $subpackageName = PHPUnitUtil::getSubpackageName($reflection->getName());

                if ($subpackageName !== null) {
                    $this->addSubpackageToPackage($packageName, $subpackageName);
                    $this->addClassToSubpackage($reflection->getName(), $classElement);
                } else {
                    $this->addClassToPackage($packageName, $classElement);
                }

                $classStartLine = $reflection->getStartLine();

                $methodscovered = 0;
                $methodcount = 0;

                // Strange PHP5 reflection bug, classes without parent class or implemented interfaces seem to start one line off
                if ($reflection->getParentClass() == null && count($reflection->getInterfaces()) == 0) {
                    unset($coverageInformation[$classStartLine + 1]);
                } else {
                    unset($coverageInformation[$classStartLine]);
                }

                // Remove out-of-bounds info
                unset($coverageInformation[0]);

                reset($coverageInformation);

                foreach ($methods as $method) {
                    // PHP5 reflection considers methods of a parent class to be part of a subclass, we don't
                    if ($method->getDeclaringClass()->getName() != $reflection->getName()) {
                        continue;
                    }

                    // small fix for XDEBUG_CC_UNUSED
                    if (isset($coverageInformation[$method->getStartLine()])) {
                        unset($coverageInformation[$method->getStartLine()]);
                    }

                    if (isset($coverageInformation[$method->getEndLine()])) {
                        unset($coverageInformation[$method->getEndLine()]);
                    }

                    if ($method->isAbstract()) {
                        continue;
                    }

                    $linenr = key($coverageInformation);

                    while ($linenr !== null && $linenr < $method->getStartLine()) {
                        next($coverageInformation);
                        $linenr = key($coverageInformation);
                    }

                    $methodCoveredCount = 0;
                    $methodTotalCount = 0;

                    $methodHasCoveredLine = false;

                    while ($linenr !== null && $linenr <= $method->getEndLine()) {
                        $methodTotalCount++;
                        $methodHasCoveredLine = true;

                        // set covered when CODE is other than -1 (not executed)
                        if ($coverageInformation[$linenr] > 0 || $coverageInformation[$linenr] == -2) {
                            $methodCoveredCount++;
                        }

                        next($coverageInformation);
                        $linenr = key($coverageInformation);
                    }

                    if (($methodTotalCount == $methodCoveredCount) && $methodHasCoveredLine) {
                        $methodscovered++;
                    }

                    $methodcount++;
                }

                $statementcount = count(
                    array_filter(
                        $coverageInformation,
                        function ($var) {
                            return ($var != -2);
                        }
                    )
                );

                $statementscovered = count(
                    array_filter(
                        $coverageInformation,
                        function ($var) {
                            return ($var >= 0);
                        }
                    )
                );

                $classElement->appendChild(
                    $this->transformSourceFile($filename, $coverageInformation, $classStartLine)
                );

                $classElement->setAttribute('methodcount', $methodcount);
                $classElement->setAttribute('methodscovered', $methodscovered);
                $classElement->setAttribute('statementcount', $statementcount);
                $classElement->setAttribute('statementscovered', $statementscovered);
                $classElement->setAttribute('totalcount', $methodcount + $statementcount);
                $classElement->setAttribute('totalcovered', $methodscovered + $statementscovered);
            }
        }
    }

    protected function calculateStatistics()
    {
        $packages = $this->doc->documentElement->getElementsByTagName('package');

        $totalmethodcount = 0;
        $totalmethodscovered = 0;

        $totalstatementcount = 0;
        $totalstatementscovered = 0;

        foreach ($packages as $package) {
            $methodcount = 0;
            $methodscovered = 0;

            $statementcount = 0;
            $statementscovered = 0;

            $subpackages = $package->getElementsByTagName('subpackage');

            foreach ($subpackages as $subpackage) {
                $subpackageMethodCount = 0;
                $subpackageMethodsCovered = 0;

                $subpackageStatementCount = 0;
                $subpackageStatementsCovered = 0;

                $subpackageClasses = $subpackage->getElementsByTagName('class');

                foreach ($subpackageClasses as $subpackageClass) {
                    $subpackageMethodCount += $subpackageClass->getAttribute('methodcount');
                    $subpackageMethodsCovered += $subpackageClass->getAttribute('methodscovered');

                    $subpackageStatementCount += $subpackageClass->getAttribute('statementcount');
                    $subpackageStatementsCovered += $subpackageClass->getAttribute('statementscovered');
                }

                $subpackage->setAttribute('methodcount', $subpackageMethodCount);
                $subpackage->setAttribute('methodscovered', $subpackageMethodsCovered);

                $subpackage->setAttribute('statementcount', $subpackageStatementCount);
                $subpackage->setAttribute('statementscovered', $subpackageStatementsCovered);

                $subpackage->setAttribute('totalcount', $subpackageMethodCount + $subpackageStatementCount);
                $subpackage->setAttribute('totalcovered', $subpackageMethodsCovered + $subpackageStatementsCovered);
            }

            $classes = $package->getElementsByTagName('class');

            foreach ($classes as $class) {
                $methodcount += $class->getAttribute('methodcount');
                $methodscovered += $class->getAttribute('methodscovered');

                $statementcount += $class->getAttribute('statementcount');
                $statementscovered += $class->getAttribute('statementscovered');
            }

            $package->setAttribute('methodcount', $methodcount);
            $package->setAttribute('methodscovered', $methodscovered);

            $package->setAttribute('statementcount', $statementcount);
            $package->setAttribute('statementscovered', $statementscovered);

            $package->setAttribute('totalcount', $methodcount + $statementcount);
            $package->setAttribute('totalcovered', $methodscovered + $statementscovered);

            $totalmethodcount += $methodcount;
            $totalmethodscovered += $methodscovered;

            $totalstatementcount += $statementcount;
            $totalstatementscovered += $statementscovered;
        }

        $this->doc->documentElement->setAttribute('methodcount', $totalmethodcount);
        $this->doc->documentElement->setAttribute('methodscovered', $totalmethodscovered);

        $this->doc->documentElement->setAttribute('statementcount', $totalstatementcount);
        $this->doc->documentElement->setAttribute('statementscovered', $totalstatementscovered);

        $this->doc->documentElement->setAttribute('totalcount', $totalmethodcount + $totalstatementcount);
        $this->doc->documentElement->setAttribute('totalcovered', $totalmethodscovered + $totalstatementscovered);
    }

    public function main()
    {
        $coverageDatabase = $this->project->getProperty('coverage.database');

        if (!$coverageDatabase) {
            throw new BuildException("Property coverage.database is not set - please include coverage-setup in your build file");
        }

        $database = new PhingFile($coverageDatabase);

        $this->log("Transforming coverage report");

        $props = new Properties();
        $props->load($database);

        foreach ($props->keys() as $filename) {
            $file = unserialize($props->getProperty($filename));

            $this->transformCoverageInformation($file['fullname'], $file['coverage']);
        }

        $this->calculateStatistics();

        $this->doc->save($this->outfile);

        foreach ($this->transformers as $transformer) {
            $transformer->setXmlDocument($this->doc);
            $transformer->transform();
        }
    }
}