<form method="POST">
    <h3>Editing: Facade.php</h3>
    <textarea name="content" rows="20" cols="80">&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\Report\Xml;

use const DIRECTORY_SEPARATOR;
use const PHP_EOL;
use function count;
use function dirname;
use function file_get_contents;
use function file_put_contents;
use function is_array;
use function is_dir;
use function is_file;
use function is_writable;
use function libxml_clear_errors;
use function libxml_get_errors;
use function libxml_use_internal_errors;
use function sprintf;
use function strlen;
use function substr;
use DateTimeImmutable;
use DOMDocument;
use SebastianBergmann\CodeCoverage\CodeCoverage;
use SebastianBergmann\CodeCoverage\Driver\PathExistsButIsNotDirectoryException;
use SebastianBergmann\CodeCoverage\Driver\WriteOperationFailedException;
use SebastianBergmann\CodeCoverage\Node\AbstractNode;
use SebastianBergmann\CodeCoverage\Node\Directory as DirectoryNode;
use SebastianBergmann\CodeCoverage\Node\File as FileNode;
use SebastianBergmann\CodeCoverage\Util\Filesystem as DirectoryUtil;
use SebastianBergmann\CodeCoverage\Version;
use SebastianBergmann\CodeCoverage\XmlException;
use SebastianBergmann\Environment\Runtime;

final class Facade
{
    /**
     * @var string
     */
    private $target;

    /**
     * @var Project
     */
    private $project;

    /**
     * @var string
     */
    private $phpUnitVersion;

    public function __construct(string $version)
    {
        $this-&gt;phpUnitVersion = $version;
    }

    /**
     * @throws XmlException
     */
    public function process(CodeCoverage $coverage, string $target): void
    {
        if (substr($target, -1, 1) !== DIRECTORY_SEPARATOR) {
            $target .= DIRECTORY_SEPARATOR;
        }

        $this-&gt;target = $target;
        $this-&gt;initTargetDirectory($target);

        $report = $coverage-&gt;getReport();

        $this-&gt;project = new Project(
            $coverage-&gt;getReport()-&gt;name()
        );

        $this-&gt;setBuildInformation();
        $this-&gt;processTests($coverage-&gt;getTests());
        $this-&gt;processDirectory($report, $this-&gt;project);

        $this-&gt;saveDocument($this-&gt;project-&gt;asDom(), 'index');
    }

    private function setBuildInformation(): void
    {
        $buildNode = $this-&gt;project-&gt;buildInformation();
        $buildNode-&gt;setRuntimeInformation(new Runtime);
        $buildNode-&gt;setBuildTime(new DateTimeImmutable);
        $buildNode-&gt;setGeneratorVersions($this-&gt;phpUnitVersion, Version::id());
    }

    /**
     * @throws PathExistsButIsNotDirectoryException
     * @throws WriteOperationFailedException
     */
    private function initTargetDirectory(string $directory): void
    {
        if (is_file($directory)) {
            if (!is_dir($directory)) {
                throw new PathExistsButIsNotDirectoryException($directory);
            }

            if (!is_writable($directory)) {
                throw new WriteOperationFailedException($directory);
            }
        }

        DirectoryUtil::createDirectory($directory);
    }

    /**
     * @throws XmlException
     */
    private function processDirectory(DirectoryNode $directory, Node $context): void
    {
        $directoryName = $directory-&gt;name();

        if ($this-&gt;project-&gt;projectSourceDirectory() === $directoryName) {
            $directoryName = '/';
        }

        $directoryObject = $context-&gt;addDirectory($directoryName);

        $this-&gt;setTotals($directory, $directoryObject-&gt;totals());

        foreach ($directory-&gt;directories() as $node) {
            $this-&gt;processDirectory($node, $directoryObject);
        }

        foreach ($directory-&gt;files() as $node) {
            $this-&gt;processFile($node, $directoryObject);
        }
    }

    /**
     * @throws XmlException
     */
    private function processFile(FileNode $file, Directory $context): void
    {
        $fileObject = $context-&gt;addFile(
            $file-&gt;name(),
            $file-&gt;id() . '.xml'
        );

        $this-&gt;setTotals($file, $fileObject-&gt;totals());

        $path = substr(
            $file-&gt;pathAsString(),
            strlen($this-&gt;project-&gt;projectSourceDirectory())
        );

        $fileReport = new Report($path);

        $this-&gt;setTotals($file, $fileReport-&gt;totals());

        foreach ($file-&gt;classesAndTraits() as $unit) {
            $this-&gt;processUnit($unit, $fileReport);
        }

        foreach ($file-&gt;functions() as $function) {
            $this-&gt;processFunction($function, $fileReport);
        }

        foreach ($file-&gt;lineCoverageData() as $line =&gt; $tests) {
            if (!is_array($tests) || count($tests) === 0) {
                continue;
            }

            $coverage = $fileReport-&gt;lineCoverage((string) $line);

            foreach ($tests as $test) {
                $coverage-&gt;addTest($test);
            }

            $coverage-&gt;finalize();
        }

        $fileReport-&gt;source()-&gt;setSourceCode(
            file_get_contents($file-&gt;pathAsString())
        );

        $this-&gt;saveDocument($fileReport-&gt;asDom(), $file-&gt;id());
    }

    private function processUnit(array $unit, Report $report): void
    {
        if (isset($unit['className'])) {
            $unitObject = $report-&gt;classObject($unit['className']);
        } else {
            $unitObject = $report-&gt;traitObject($unit['traitName']);
        }

        $unitObject-&gt;setLines(
            $unit['startLine'],
            $unit['executableLines'],
            $unit['executedLines']
        );

        $unitObject-&gt;setCrap((float) $unit['crap']);
        $unitObject-&gt;setNamespace($unit['namespace']);

        foreach ($unit['methods'] as $method) {
            $methodObject = $unitObject-&gt;addMethod($method['methodName']);
            $methodObject-&gt;setSignature($method['signature']);
            $methodObject-&gt;setLines((string) $method['startLine'], (string) $method['endLine']);
            $methodObject-&gt;setCrap($method['crap']);
            $methodObject-&gt;setTotals(
                (string) $method['executableLines'],
                (string) $method['executedLines'],
                (string) $method['coverage']
            );
        }
    }

    private function processFunction(array $function, Report $report): void
    {
        $functionObject = $report-&gt;functionObject($function['functionName']);

        $functionObject-&gt;setSignature($function['signature']);
        $functionObject-&gt;setLines((string) $function['startLine']);
        $functionObject-&gt;setCrap($function['crap']);
        $functionObject-&gt;setTotals((string) $function['executableLines'], (string) $function['executedLines'], (string) $function['coverage']);
    }

    private function processTests(array $tests): void
    {
        $testsObject = $this-&gt;project-&gt;tests();

        foreach ($tests as $test =&gt; $result) {
            $testsObject-&gt;addTest($test, $result);
        }
    }

    private function setTotals(AbstractNode $node, Totals $totals): void
    {
        $loc = $node-&gt;linesOfCode();

        $totals-&gt;setNumLines(
            $loc['linesOfCode'],
            $loc['commentLinesOfCode'],
            $loc['nonCommentLinesOfCode'],
            $node-&gt;numberOfExecutableLines(),
            $node-&gt;numberOfExecutedLines()
        );

        $totals-&gt;setNumClasses(
            $node-&gt;numberOfClasses(),
            $node-&gt;numberOfTestedClasses()
        );

        $totals-&gt;setNumTraits(
            $node-&gt;numberOfTraits(),
            $node-&gt;numberOfTestedTraits()
        );

        $totals-&gt;setNumMethods(
            $node-&gt;numberOfMethods(),
            $node-&gt;numberOfTestedMethods()
        );

        $totals-&gt;setNumFunctions(
            $node-&gt;numberOfFunctions(),
            $node-&gt;numberOfTestedFunctions()
        );
    }

    private function targetDirectory(): string
    {
        return $this-&gt;target;
    }

    /**
     * @throws XmlException
     */
    private function saveDocument(DOMDocument $document, string $name): void
    {
        $filename = sprintf('%s/%s.xml', $this-&gt;targetDirectory(), $name);

        $document-&gt;formatOutput       = true;
        $document-&gt;preserveWhiteSpace = false;
        $this-&gt;initTargetDirectory(dirname($filename));

        file_put_contents($filename, $this-&gt;documentAsString($document));
    }

    /**
     * @throws XmlException
     *
     * @see https://bugs.php.net/bug.php?id=79191
     */
    private function documentAsString(DOMDocument $document): string
    {
        $xmlErrorHandling = libxml_use_internal_errors(true);
        $xml              = $document-&gt;saveXML();

        if ($xml === false) {
            $message = 'Unable to generate the XML';

            foreach (libxml_get_errors() as $error) {
                $message .= PHP_EOL . $error-&gt;message;
            }

            throw new XmlException($message);
        }

        libxml_clear_errors();
        libxml_use_internal_errors($xmlErrorHandling);

        return $xml;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>