XmlLintTask::main() - Code Metrics - Inspection of "Move another bunch of optional tasks" - phingofficial/phing - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — main ( b7649a...398f47 )

by Michiel
created 2021-02-01 10:37 UTC
XmlLintTask::main() B

↳ Parent: XmlLintTask
Complexity

Conditions	8
Paths	4
Size

Total Lines	24
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	72
Importance

Changes
Metric	Value
eloc	16
dl	0
loc	24
ccs	0
cts	16
cp	0
rs	8.4444
c	0
b	0
f	0
cc	8
nc	4
nop	0
crap	72
<?php
/**
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the LGPL. For more information please see
 * <http://phing.info>.
 */

namespace Phing\Task\Optional;

use DOMDocument;
use Phing\Exception\BuildException;
use Phing\Io\File;
use Phing\Project;
use Phing\Task;
use Phing\Type\Element\FileSetAware;

/**
 * A XML lint task. Checking syntax of one or more XML files against an XML Schema using the DOM extension.
 *
 * @author  Knut Urdalen <[email protected]>
 * @package phing.tasks.ext
 */
class XmlLintTask extends Task
{
    use FileSetAware;

    protected $file; // the source file (from xml attribute)
    protected $schema; // the schema file (from xml attribute)
    protected $useRNG = false;

    protected $haltonfailure = true;

    /**
     * File to be performed syntax check on
     *
     * @param File $file
     */
    public function setFile(File $file)
    {
        $this->file = $file;
    }

    /**
     * XML Schema Description file to validate against
     *
     * @param File $schema
     */
    public function setSchema(File $schema)
    {
        $this->schema = $schema;
    }

    /**
     * Use RNG instead of DTD schema validation
     *
     * @param bool $bool
     */
    public function setUseRNG($bool)
    {
        $this->useRNG = (bool) $bool;
    }

    /**
     * Sets the haltonfailure attribute
     *
     * @param bool $haltonfailure
     *
     * @return void
     */
    public function setHaltonfailure(bool $haltonfailure)
    {
        $this->haltonfailure = $haltonfailure;
    }

    /**
     * Execute lint check against PhingFile or a FileSet.
     *
     * {@inheritdoc}
     *
     * @return void
     * @throws BuildException
     *
     */
    public function main()
    {
        if (isset($this->schema) && !file_exists($this->schema->getPath())) {
            throw new BuildException("Schema file not found: " . $this->schema->getPath());
        }
        if (!isset($this->file) and count($this->filesets) == 0) {
            throw new BuildException("Missing either a nested fileset or attribute 'file' set");
        }

        set_error_handler([$this, 'errorHandler']);
        if ($this->file instanceof File) {
            $this->lint($this->file->getPath());
        } else { // process filesets
            $project = $this->getProject();
            foreach ($this->filesets as $fs) {
                $ds = $fs->getDirectoryScanner($project);
                $files = $ds->getIncludedFiles();
                $dir = $fs->getDir($this->project)->getPath();
                foreach ($files as $file) {
                    $this->lint($dir . DIRECTORY_SEPARATOR . $file);
                }
            }
        }
        restore_error_handler();
    }

    /**
     * @param $message
     *
     * @return void
     *
     * @throws BuildException
     */
    protected function logError($message)
    {
        if ($this->haltonfailure) {
            throw new BuildException($message);
        }

        $this->log($message, Project::MSG_ERR);
    }

    /**
     * Performs validation
     *
     * @param string $file
     *
     * @return void
     */
    protected function lint($file)
    {
        if (file_exists($file)) {
            if (is_readable($file)) {
                $dom = new DOMDocument();
                if ($dom->load($file) === false) {
                    $error = libxml_get_last_error();

                    $this->logError($file . ' is not well-formed (See messages above)');
                } else {
                    if (isset($this->schema)) {
                        if ($this->useRNG) {
                            if ($dom->relaxNGValidate($this->schema->getPath())) {
                                $this->log($file . ' validated with RNG grammar', Project::MSG_INFO);
                            } else {
                                $this->logError($file . ' fails to validate (See messages above)');
                            }
                        } else {
                            if ($dom->schemaValidate($this->schema->getPath())) {
                                $this->log($file . ' validated with schema', Project::MSG_INFO);
                            } else {
                                $this->logError($file . ' fails to validate (See messages above)');
                            }
                        }
                    } else {
                        $this->log(
                            $file . ' is well-formed (not validated due to missing schema specification)',
                            Project::MSG_INFO
                        );
                    }
                }
            } else {
                $this->logError('Permission denied to read file: ' . $file);
            }
        } else {
            $this->logError('File not found: ' . $file);
        }
    }

    /**
     * Local error handler to catch validation errors and log them through Phing
     *
     * @param int $level
     * @param string $message
     * @param string $file
     * @param int $line
     * @param mixed $context
     *
     * @return void
     */
    public function errorHandler($level, $message, $file, $line, $context)
    public function errorHandler($level, $message, $file, $line, /** @scrutinizer ignore-unused */ $context)
    {
        $matches = [];
        preg_match('/^.*\(\): (.*)$/', $message, $matches);
        $this->log($matches[1], Project::MSG_ERR);
    }
}

phingofficial / phing

Push — main ( b7649a...398f47 )

XmlLintTask::main() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
