exussum12\CoverageChecker\CoverageCheck

Complexity

Total Complexity

23

Size/Duplication

Total Lines	180
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes	2
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	handleFileNotFound()	0	12	3
A	findFile()	0	9	2
A	__construct()	0	10	1
A	getCoveredLines()	0	21	3
A	addUnCoveredLine()	0	8	2
A	addCoveredLine()	0	8	2
B	matchLines()	0	22	4
A	addCoveredFile()	0	6	2
A	addUnCoveredFile()	0	6	2
A	getDiff()	0	8	2

<?php
namespace exussum12\CoverageChecker;

use stdClass;

/**
 * Class CoverageCheck
 * @package exussum12\CoverageChecker
 */
class CoverageCheck
{
    /**
     * @var DiffFileLoader
     */
    protected $diff;

    /**
     * @var FileChecker
     */
    protected $fileChecker;

    /**
     * @var FileMatcher
     */
    protected $matcher;

    /**
     * @var stdClass
     */
    protected $cache;

    /**
     * @var array
     */
    protected $uncoveredLines = [];

    /**
     * @var array
     */
    protected $coveredLines = [];

    /**
     * CoverageCheck constructor.
     * This class is used for filtering the "checker" by the diff
     * For example if the checker is phpunit, this class filters the phpunit
     * output by the diff of the pull request. giving only the common lines in
     * each
     *
     * @param DiffFileLoader $diff
     * @param FileChecker $fileChecker
     * @param FileMatcher $matcher
     */
    public function __construct(
        DiffFileLoader $diff,
        FileChecker $fileChecker,
        FileMatcher $matcher
    ) {
        $this->diff = $diff;
        $this->fileChecker = $fileChecker;
        $this->matcher = $matcher;
        $this->cache = new stdClass;
    }

    /**
     * array of uncoveredLines and coveredLines
     * @return array
     */
    public function getCoveredLines()
    {
        $this->getDiff();

        $coveredFiles = $this->fileChecker->parseLines();
        $this->uncoveredLines = [];
        $this->coveredLines = [];

        $diffFiles = array_keys($this->cache->diff);
        foreach ($diffFiles as $file) {
            $matchedFile = $this->findFile($file, $coveredFiles);
            if ($matchedFile !== false) {
                $this->matchLines($file, $matchedFile);
            }
        }

        return [
            'uncoveredLines' => $this->uncoveredLines,
            'coveredLines' => $this->coveredLines,
        ];
    }

    /**
     * @param string $file the filename containing the uncovered line
     * @param int $line the number of the uncovered line
     * @param array $message a list of messages showing why its uncovered
     */
    protected function addUnCoveredLine($file, $line, $message)
    {
        if (!isset($this->uncoveredLines[$file])) {
            $this->uncoveredLines[$file] = [];
        }

        $this->uncoveredLines[$file][$line] = $message;
    }

    /**
     * @param string $file the filename containing the covered line
     * @param int $line the number of the covered line
     */
    protected function addCoveredLine($file, $line)
    {
        if (!isset($this->coveredLines[$file])) {
            $this->coveredLines[$file] = [];
        }

        $this->coveredLines[$file][] = $line;
    }

    /**
     * @param string $fileName the file name in the diff
     * @param string $matchedFile the file name of the matched file
     */
    protected function matchLines($fileName, $matchedFile)
    {
        foreach ($this->cache->diff[$fileName] as $line) {
            $messages = $this->fileChecker->getErrorsOnLine($matchedFile, $line);

            if (is_null($messages)) {
                continue;
            }

            if (count($messages) == 0) {
                $this->addCoveredLine($fileName, $line);
                continue;
            }


            $this->addUnCoveredLine(
                $fileName,
                $line,
                $messages
            );
        }
    }

    protected function addCoveredFile($file)
    {
        foreach ($this->cache->diff[$file] as $line) {
            $this->addCoveredLine($file, $line);
        }
    }

    protected function addUnCoveredFile($file)
    {
        foreach ($this->cache->diff[$file] as $line) {
            $this->addUnCoveredLine($file, $line, ['No Cover']);
        }
    }

    protected function getDiff()
    {
        if (empty($this->cache->diff)) {
            $this->cache->diff = $this->diff->getChangedLines();
        }

        return $this->cache->diff;
    }

    protected function handleFileNotFound($file)
    {
        $unMatchedFile = $this->fileChecker->handleNotFoundFile();

        if ($unMatchedFile === true) {
            $this->addCoveredFile($file);
        }

        if ($unMatchedFile === false) {
            $this->addUnCoveredFile($file);
        }
    }

    protected function findFile($file, $coveredFiles)
    {
        try {
            return $this->matcher->match($file, $coveredFiles);
        } catch (Exceptions\FileNotFound $e) {
            $this->handleFileNotFound($file);
            return false;
        }
    }
}