exussum12\CoverageChecker\Loaders\Infection

Complexity

Total Complexity

18

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	addError()	0	13	4
A	getDescription()	0	3	1
A	updateFile()	0	13	2
A	handleNotFoundFile()	0	3	1
A	handleLine()	0	11	3
A	getErrorsOnLine()	0	7	2
A	parseLines()	0	14	2
A	updateType()	0	14	2
A	__construct()	0	3	1

<?php
namespace exussum12\CoverageChecker\Loaders;

use exussum12\CoverageChecker\FileChecker;

class Infection implements FileChecker
{

    protected $file;
    protected $errors = [];

    protected $errorTypes = [
        'Escaped mutants',
        'Errors mutants',
        'Not covered mutants',
    ];

    protected $currentFile;

    protected $currentLine;

    protected $partialError;

    protected $currentType;

    public function __construct($filePath)
    {
        $this->file = fopen($filePath, 'r');
    }

    /**
     * @return array the list of files from this change
     */
    public function parseLines(): array
    {
        $this->currentFile = '';
        $this->currentLine = 0;
        $this->partialError = '';
        $this->currentType = '';

        while (($line = fgets($this->file)) !== false) {

It seems like $this->file can also be of type boolean; however, parameter $handle of fgets() does only seem to accept resource, maybe add an additional type check?

            $this->handleLine($line);
        }
        // the last error in the file
        $this->addError();

        return array_keys($this->errors);
    }

    /**
     * Method to determine if the line is valid in the context
     * returning null does not include the line in the stats
     * Returns an array containing errors on a certain line - empty array means no errors
     *
     * @return array|null
     */
    public function getErrorsOnLine(string $file, int $lineNumber)
    {
        if (!isset($this->errors[$file][$lineNumber])) {
            return [];
        }

        return $this->errors[$file][$lineNumber];
    }

    /**
     * Method to determine what happens to files which have not been found
     * true adds as covered
     * false adds as uncovered
     * null does not include the file in the stats
     * @return bool|null
     */
    public function handleNotFoundFile()
    {
        return true;
    }

    /**
     * Shows the description of the class, used for explaining why
     * this checker would be used
     * @return string
     */
    public static function getDescription(): string
    {
        return 'Parses the infection text log format';
    }

    protected function updateType($line)
    {
        $matches = [];
        if (preg_match('/^([a-z ]+):$/i', $line, $matches)) {
            $this->addError();
            $this->currentFile = '';
            $this->currentLine = '';
            $this->partialError = '';
            $this->currentType = $matches[1];

            return true;
        }

        return false;
    }

    protected function updateFile($line)
    {
        $matches = [];
        if (preg_match('/^[0-9]+\) (.*?):([0-9]+) (.*)/i', $line, $matches)) {
            $this->addError();
            $this->currentFile = $matches[1];
            $this->currentLine = $matches[2];
            $this->partialError = '';

            return true;
        }

        return false;
    }

    protected function addError()
    {
        if (!($this->currentFile && $this->currentLine)) {
            return;
        }

        if (!in_array($this->currentType, $this->errorTypes)) {
            return;
        }

        $this->errors
            [$this->currentFile]
            [$this->currentLine][] = $this->currentType . $this->partialError;
    }

    protected function handleLine($line)
    {
        if ($this->updateType($line)) {
            return;
        }

        if ($this->updateFile($line)) {
            return;
        }

        $this->partialError .= $line;
    }
}