<h2>Editing File: /home/xaimptsg/public_html/src/vendor/phpunit/php-code-coverage/src/Data/RawCodeCoverageData.php</h2><form method='post'><textarea name='content' class='file-edit'>&lt;?php declare(strict_types=1);
/*
 * This file is part of phpunit/php-code-coverage.
 *
 * (c) Sebastian Bergmann &lt;sebastian@phpunit.de&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace SebastianBergmann\CodeCoverage\Data;

use function array_diff;
use function array_diff_key;
use function array_flip;
use function array_intersect;
use function array_intersect_key;
use function count;
use function explode;
use function file_get_contents;
use function in_array;
use function is_file;
use function preg_replace;
use function range;
use function str_ends_with;
use function str_starts_with;
use function trim;
use SebastianBergmann\CodeCoverage\Driver\Driver;
use SebastianBergmann\CodeCoverage\StaticAnalysis\FileAnalyser;

/**
 * @internal This class is not covered by the backward compatibility promise for phpunit/php-code-coverage
 *
 * @psalm-import-type XdebugFunctionsCoverageType from \SebastianBergmann\CodeCoverage\Driver\XdebugDriver
 * @psalm-import-type XdebugCodeCoverageWithoutPathCoverageType from \SebastianBergmann\CodeCoverage\Driver\XdebugDriver
 * @psalm-import-type XdebugCodeCoverageWithPathCoverageType from \SebastianBergmann\CodeCoverage\Driver\XdebugDriver
 */
final class RawCodeCoverageData
{
    /**
     * @var array&lt;string, array&lt;int&gt;&gt;
     */
    private static array $emptyLineCache = [];

    /**
     * @psalm-var XdebugCodeCoverageWithoutPathCoverageType
     */
    private array $lineCoverage;

    /**
     * @psalm-var array&lt;string, XdebugFunctionsCoverageType&gt;
     */
    private array $functionCoverage;

    /**
     * @psalm-param XdebugCodeCoverageWithoutPathCoverageType $rawCoverage
     */
    public static function fromXdebugWithoutPathCoverage(array $rawCoverage): self
    {
        return new self($rawCoverage, []);
    }

    /**
     * @psalm-param XdebugCodeCoverageWithPathCoverageType $rawCoverage
     */
    public static function fromXdebugWithPathCoverage(array $rawCoverage): self
    {
        $lineCoverage     = [];
        $functionCoverage = [];

        foreach ($rawCoverage as $file =&gt; $fileCoverageData) {
            // Xdebug annotates the function name of traits, strip that off
            foreach ($fileCoverageData['functions'] as $existingKey =&gt; $data) {
                if (str_ends_with($existingKey, '}') &amp;&amp; !str_starts_with($existingKey, '{')) { // don't want to catch {main}
                    $newKey                                 = preg_replace('/\{.*}$/', '', $existingKey);
                    $fileCoverageData['functions'][$newKey] = $data;
                    unset($fileCoverageData['functions'][$existingKey]);
                }
            }

            $lineCoverage[$file]     = $fileCoverageData['lines'];
            $functionCoverage[$file] = $fileCoverageData['functions'];
        }

        return new self($lineCoverage, $functionCoverage);
    }

    public static function fromUncoveredFile(string $filename, FileAnalyser $analyser): self
    {
        $lineCoverage = [];

        foreach ($analyser-&gt;executableLinesIn($filename) as $line =&gt; $branch) {
            $lineCoverage[$line] = Driver::LINE_NOT_EXECUTED;
        }

        return new self([$filename =&gt; $lineCoverage], []);
    }

    /**
     * @psalm-param XdebugCodeCoverageWithoutPathCoverageType $lineCoverage
     * @psalm-param array&lt;string, XdebugFunctionsCoverageType&gt; $functionCoverage
     */
    private function __construct(array $lineCoverage, array $functionCoverage)
    {
        $this-&gt;lineCoverage     = $lineCoverage;
        $this-&gt;functionCoverage = $functionCoverage;

        $this-&gt;skipEmptyLines();
    }

    public function clear(): void
    {
        $this-&gt;lineCoverage = $this-&gt;functionCoverage = [];
    }

    /**
     * @psalm-return XdebugCodeCoverageWithoutPathCoverageType
     */
    public function lineCoverage(): array
    {
        return $this-&gt;lineCoverage;
    }

    /**
     * @psalm-return array&lt;string, XdebugFunctionsCoverageType&gt;
     */
    public function functionCoverage(): array
    {
        return $this-&gt;functionCoverage;
    }

    public function removeCoverageDataForFile(string $filename): void
    {
        unset($this-&gt;lineCoverage[$filename], $this-&gt;functionCoverage[$filename]);
    }

    /**
     * @param int[] $lines
     */
    public function keepLineCoverageDataOnlyForLines(string $filename, array $lines): void
    {
        if (!isset($this-&gt;lineCoverage[$filename])) {
            return;
        }

        $this-&gt;lineCoverage[$filename] = array_intersect_key(
            $this-&gt;lineCoverage[$filename],
            array_flip($lines),
        );
    }

    /**
     * @param int[] $linesToBranchMap
     */
    public function markExecutableLineByBranch(string $filename, array $linesToBranchMap): void
    {
        if (!isset($this-&gt;lineCoverage[$filename])) {
            return;
        }

        $linesByBranch = [];

        foreach ($linesToBranchMap as $line =&gt; $branch) {
            $linesByBranch[$branch][] = $line;
        }

        foreach ($this-&gt;lineCoverage[$filename] as $line =&gt; $lineStatus) {
            if (!isset($linesToBranchMap[$line])) {
                continue;
            }

            $branch = $linesToBranchMap[$line];

            if (!isset($linesByBranch[$branch])) {
                continue;
            }

            foreach ($linesByBranch[$branch] as $lineInBranch) {
                $this-&gt;lineCoverage[$filename][$lineInBranch] = $lineStatus;
            }

            if (Driver::LINE_EXECUTED === $lineStatus) {
                unset($linesByBranch[$branch]);
            }
        }
    }

    /**
     * @param int[] $lines
     */
    public function keepFunctionCoverageDataOnlyForLines(string $filename, array $lines): void
    {
        if (!isset($this-&gt;functionCoverage[$filename])) {
            return;
        }

        foreach ($this-&gt;functionCoverage[$filename] as $functionName =&gt; $functionData) {
            foreach ($functionData['branches'] as $branchId =&gt; $branch) {
                if (count(array_diff(range($branch['line_start'], $branch['line_end']), $lines)) &gt; 0) {
                    unset($this-&gt;functionCoverage[$filename][$functionName]['branches'][$branchId]);

                    foreach ($functionData['paths'] as $pathId =&gt; $path) {
                        if (in_array($branchId, $path['path'], true)) {
                            unset($this-&gt;functionCoverage[$filename][$functionName]['paths'][$pathId]);
                        }
                    }
                }
            }
        }
    }

    /**
     * @param int[] $lines
     */
    public function removeCoverageDataForLines(string $filename, array $lines): void
    {
        if (empty($lines)) {
            return;
        }

        if (!isset($this-&gt;lineCoverage[$filename])) {
            return;
        }

        $this-&gt;lineCoverage[$filename] = array_diff_key(
            $this-&gt;lineCoverage[$filename],
            array_flip($lines),
        );

        if (isset($this-&gt;functionCoverage[$filename])) {
            foreach ($this-&gt;functionCoverage[$filename] as $functionName =&gt; $functionData) {
                foreach ($functionData['branches'] as $branchId =&gt; $branch) {
                    if (count(array_intersect($lines, range($branch['line_start'], $branch['line_end']))) &gt; 0) {
                        unset($this-&gt;functionCoverage[$filename][$functionName]['branches'][$branchId]);

                        foreach ($functionData['paths'] as $pathId =&gt; $path) {
                            if (in_array($branchId, $path['path'], true)) {
                                unset($this-&gt;functionCoverage[$filename][$functionName]['paths'][$pathId]);
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * At the end of a file, the PHP interpreter always sees an implicit return. Where this occurs in a file that has
     * e.g. a class definition, that line cannot be invoked from a test and results in confusing coverage. This engine
     * implementation detail therefore needs to be masked which is done here by simply ensuring that all empty lines
     * are skipped over for coverage purposes.
     *
     * @see https://github.com/sebastianbergmann/php-code-coverage/issues/799
     */
    private function skipEmptyLines(): void
    {
        foreach ($this-&gt;lineCoverage as $filename =&gt; $coverage) {
            foreach ($this-&gt;getEmptyLinesForFile($filename) as $emptyLine) {
                unset($this-&gt;lineCoverage[$filename][$emptyLine]);
            }
        }
    }

    private function getEmptyLinesForFile(string $filename): array
    {
        if (!isset(self::$emptyLineCache[$filename])) {
            self::$emptyLineCache[$filename] = [];

            if (is_file($filename)) {
                $sourceLines = explode(&quot;\n&quot;, file_get_contents($filename));

                foreach ($sourceLines as $line =&gt; $source) {
                    if (trim($source) === '') {
                        self::$emptyLineCache[$filename][] = ($line + 1);
                    }
                }
            }
        }

        return self::$emptyLineCache[$filename];
    }
}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fhome%2Fxaimptsg%2Fpublic_html%2Fsrc%2Fvendor%2Fphpunit%2Fphp-code-coverage%2Fsrc%2FData'>Back to Directory</a>