ACIL FM

Pilih semua

Nama	Ukuran	Aksi
BuildInformation.php	2.36 MB	View DL Edit
Coverage.php	1.75 MB	View DL Edit
Directory.php	479 B	View DL Edit
Facade.php	8.83 MB	View DL Edit
File.php	2.04 MB	View DL Edit
Method.php	1.56 MB	View DL Edit
Node.php	2.16 MB	View DL Edit
Project.php	2.41 MB	View DL Edit
Report.php	2.55 MB	View DL Edit
Source.php	1.11 MB	View DL Edit
Tests.php	1.19 MB	View DL Edit
Totals.php	4.24 MB	View DL Edit
Unit.php	2.08 MB	View DL Edit

Edit file: /opt/cpanel/ea-wappspector/vendor/phpunit/php-code-coverage/src/Report/Xml/Facade.php

<?php declare(strict_types=1);
/*
 * This file is part of phpunit/php-code-coverage.
 *
 * (c) Sebastian Bergmann <sebastian@phpunit.de>
 *
 * 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
{
    private string $target;
    private Project $project;
    private readonly string $phpUnitVersion;

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

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

$this->target = $target;
        $this->initTargetDirectory($target);

$report = $coverage->getReport();

$this->project = new Project(
            $coverage->getReport()->name(),
        );

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

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

private function setBuildInformation(): void
    {
        $buildNode = $this->project->buildInformation();
        $buildNode->setRuntimeInformation(new Runtime);
        $buildNode->setBuildTime(new DateTimeImmutable);
        $buildNode->setGeneratorVersions($this->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->name();

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

$directoryObject = $context->addDirectory($directoryName);

$this->setTotals($directory, $directoryObject->totals());

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

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

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

$this->setTotals($file, $fileObject->totals());

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

$fileReport = new Report($path);

$this->setTotals($file, $fileReport->totals());

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

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

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

$coverage = $fileReport->lineCoverage((string) $line);

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

$coverage->finalize();
        }

$fileReport->source()->setSourceCode(
            file_get_contents($file->pathAsString()),
        );

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

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

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

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

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

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

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

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

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

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

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

$totals->setNumClasses(
            $node->numberOfClasses(),
            $node->numberOfTestedClasses(),
        );

$totals->setNumTraits(
            $node->numberOfTraits(),
            $node->numberOfTestedTraits(),
        );

$totals->setNumMethods(
            $node->numberOfMethods(),
            $node->numberOfTestedMethods(),
        );

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

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

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

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

file_put_contents($filename, $this->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->saveXML();

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

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

throw new XmlException($message);
        }

libxml_clear_errors();
        libxml_use_internal_errors($xmlErrorHandling);

return $xml;
    }
}

Batal

Isi Zip:

Create