SchemaValidator::buildSchemas() - Code Metrics - Inspection of "Prepare version 3.0.0" - eclipxe13/XmlSchemaValidator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( add283...7568bf )

by Carlos C

created 2020-04-08 21:50 UTC

SchemaValidator::buildSchemas() A

↳ Parent: SchemaValidator

Complexity

Conditions	4
Paths	3

Size

Total Lines	21
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	4

Importance

Changes

Metric	Value
cc	4
eloc	9
c	0
b	0
f	0
nc	3
nop	0
dl	0
loc	21
ccs	10
cts	10
cp	1
crap	4
rs	9.9666

<?php

declare(strict_types=1);

namespace Eclipxe\XmlSchemaValidator;

use DOMAttr;
use DOMDocument;
use DOMNodeList;
use DOMXPath;
use Eclipxe\XmlSchemaValidator\Exceptions\SchemaLocationPartsNotEvenException;
use Eclipxe\XmlSchemaValidator\Exceptions\ValidationFailException;
use Eclipxe\XmlSchemaValidator\Exceptions\XmlContentIsEmptyException;
use Eclipxe\XmlSchemaValidator\Exceptions\XmlContentIsInvalidException;
use Eclipxe\XmlSchemaValidator\Exceptions\XmlSchemaValidatorException;
use Eclipxe\XmlSchemaValidator\Internal\LibXmlException;

/**
 * This class is an XML schema validator
 * It is needed because some XML can contain more than one external schema and DOM library fails to load it.
 */
class SchemaValidator
{
    /** @var DOMDocument */
    private $document;

    /** @var string */
    private $lastError = '';

    /**
     * SchemaValidator constructor.
     *
     * @param DOMDocument $document
     */
    public function __construct(DOMDocument $document)
    {
        $this->document = $document;
    }

    /**
     * Create a SchemaValidator instance based on a XML string
     *
     * @param string $contents
     * @return self
     * @throws XmlContentIsEmptyException when the xml contents is an empty string
     * @throws XmlContentIsInvalidException when the xml contents cannot be loaded
     */
    public static function createFromString(string $contents): self
    {
        // do not allow empty string
        if ('' === $contents) {
            throw XmlContentIsEmptyException::create();
        }

        // create and load contents throwing specific exception
        try {
            /** @var DOMDocument $document */
            $document = LibXmlException::useInternalErrors(
                function () use ($contents): DOMDocument {
                    $document = new DOMDocument();
                    $document->loadXML($contents);
                    return $document;
                }
            );
        } catch (LibXmlException $exception) {
            throw XmlContentIsInvalidException::create($exception);
        }

        return new self($document);
    }

    /**
     * Validate the content by:
     * - Create the Schemas collection from the document
     * - Validate using validateWithSchemas
     * - Populate the error property
     *
     * @return bool
     * @see validateWithSchemas
     */
    public function validate(): bool
    {
        $this->lastError = '';
        try {
            // create the schemas collection
            $schemas = $this->buildSchemas();
            // validate the document using the schema collection
            $this->validateWithSchemas($schemas);
        } catch (XmlSchemaValidatorException $ex) {
            $this->lastError = $ex->getMessage();
            return false;
        }
        return true;
    }

    /**
     * Retrieve the last error message captured on the last validate operation
     *
     * @return string
     */
    public function getLastError(): string
    {
        return $this->lastError;
    }

    /**
     * Validate against a list of schemas (if any)
     *
     * @param Schemas $schemas
     * @return void
     *
     * @throws ValidationFailException when schema validation fails
     */
    public function validateWithSchemas(Schemas $schemas): void
    {
        // early exit, do not validate if schemas collection is empty
        if (0 === $schemas->count()) {
            return;
        }

        // build the unique importing schema
        $xsd = $schemas->getImporterXsd();

        // validate and trap LibXmlException
        try {
            LibXmlException::useInternalErrors(function () use ($xsd): void {
                $this->document->schemaValidateSource($xsd);
            });
        } catch (LibXmlException $exception) {
            throw ValidationFailException::create($exception);
        }
    }

    /**
     * Retrieve a list of namespaces based on the schemaLocation attributes
     *
     * @return Schemas
     * @throws SchemaLocationPartsNotEvenException when the schemaLocation attribute does not have even parts
     */
    public function buildSchemas(): Schemas
    {
        $schemas = new Schemas();
        $xpath = new DOMXPath($this->document);

        // get the http://www.w3.org/2001/XMLSchema-instance namespace (it could not be 'xsi')
        $xsi = $this->document->lookupPrefix('http://www.w3.org/2001/XMLSchema-instance');
        if (! $xsi) { // the namespace is not registered, no need to continue
            return $schemas;
        }

        // get all the xsi:schemaLocation attributes in the document
        /** @var DOMNodeList<DOMAttr> $schemasList */
        $schemasList = $xpath->query("//@$xsi:schemaLocation") ?: new DOMNodeList();

        // process every schemaLocation and import them into schemas
        foreach ($schemasList as $node) {
            $schemas->import($this->buildSchemasFromSchemaLocationValue($node->nodeValue));
        }

        return $schemas;
    }

    /**
     * Create a schemas collection from the content of a schema location
     *
     * @param string $content
     * @return Schemas
     * @throws SchemaLocationPartsNotEvenException when the schemaLocation attribute does not have even parts
     */
    public function buildSchemasFromSchemaLocationValue(string $content): Schemas
    {
        // get parts without inner spaces
        $parts = preg_split('/\s+/', $content) ?: [];
        $partsCount = count($parts);

        // check that the list count is an even number
        if (0 !== $partsCount % 2) {
            throw SchemaLocationPartsNotEvenException::create($parts);
        }

        // insert the uris pairs into the schemas
        $schemas = new Schemas();
        for ($k = 0; $k < $partsCount; $k = $k + 2) {
            $schemas->create($parts[$k], $parts[$k + 1]);
        }
        return $schemas;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Eclipxe\XmlSchemaValidator;
6
7		use DOMAttr;
8		use DOMDocument;
9		use DOMNodeList;
10		use DOMXPath;
11		use Eclipxe\XmlSchemaValidator\Exceptions\SchemaLocationPartsNotEvenException;
12		use Eclipxe\XmlSchemaValidator\Exceptions\ValidationFailException;
13		use Eclipxe\XmlSchemaValidator\Exceptions\XmlContentIsEmptyException;
14		use Eclipxe\XmlSchemaValidator\Exceptions\XmlContentIsInvalidException;
15		use Eclipxe\XmlSchemaValidator\Exceptions\XmlSchemaValidatorException;
16		use Eclipxe\XmlSchemaValidator\Internal\LibXmlException;
17
18		/**
19		* This class is an XML schema validator
20		* It is needed because some XML can contain more than one external schema and DOM library fails to load it.
21		*/
22		class SchemaValidator
23		{
24		/** @var DOMDocument */
25		private $document;
26
27		/** @var string */
28		private $lastError = '';
29
30		/**
31		* SchemaValidator constructor.
32		*
33		* @param DOMDocument $document
34		*/
35	13	public function __construct(DOMDocument $document)
36		{
37	13	$this->document = $document;
38	13	}
39
40		/**
41		* Create a SchemaValidator instance based on a XML string
42		*
43		* @param string $contents
44		* @return self
45		* @throws XmlContentIsEmptyException when the xml contents is an empty string
46		* @throws XmlContentIsInvalidException when the xml contents cannot be loaded
47		*/
48	14	public static function createFromString(string $contents): self
49		{
50		// do not allow empty string
51	14	if ('' === $contents) {
52	1	throw XmlContentIsEmptyException::create();
53		}
54
55		// create and load contents throwing specific exception
56		try {
57		/** @var DOMDocument $document */
58	13	$document = LibXmlException::useInternalErrors(
59		function () use ($contents): DOMDocument {
60	13	$document = new DOMDocument();
61	13	$document->loadXML($contents);
62	13	return $document;
63	13	}
64		);
65	1	} catch (LibXmlException $exception) {
66	1	throw XmlContentIsInvalidException::create($exception);
67		}
68
69	12	return new self($document);
70		}
71
72		/**
73		* Validate the content by:
74		* - Create the Schemas collection from the document
75		* - Validate using validateWithSchemas
76		* - Populate the error property
77		*
78		* @return bool
79		* @see validateWithSchemas
80		*/
81	9	public function validate(): bool
82		{
83	9	$this->lastError = '';
84		try {
85		// create the schemas collection
86	9	$schemas = $this->buildSchemas();
87		// validate the document using the schema collection
88	8	$this->validateWithSchemas($schemas);
89	4	} catch (XmlSchemaValidatorException $ex) {
90	4	$this->lastError = $ex->getMessage();
91	4	return false;
92		}
93	5	return true;
94		}
95
96		/**
97		* Retrieve the last error message captured on the last validate operation
98		*
99		* @return string
100		*/
101	5	public function getLastError(): string
102		{
103	5	return $this->lastError;
104		}
105
106		/**
107		* Validate against a list of schemas (if any)
108		*
109		* @param Schemas $schemas
110		* @return void
111		*
112		* @throws ValidationFailException when schema validation fails
113		*/
114	11	public function validateWithSchemas(Schemas $schemas): void
115		{
116		// early exit, do not validate if schemas collection is empty
117	11	if (0 === $schemas->count()) {
118	2	return;
119		}
120
121		// build the unique importing schema
122	9	$xsd = $schemas->getImporterXsd();
123
124		// validate and trap LibXmlException
125		try {
126		LibXmlException::useInternalErrors(function () use ($xsd): void {
127	9	$this->document->schemaValidateSource($xsd);
128	9	});
129	4	} catch (LibXmlException $exception) {
130	4	throw ValidationFailException::create($exception);
131		}
132	5	}
133
134		/**
135		* Retrieve a list of namespaces based on the schemaLocation attributes
136		*
137		* @return Schemas
138		* @throws SchemaLocationPartsNotEvenException when the schemaLocation attribute does not have even parts
139		*/
140	9	public function buildSchemas(): Schemas
141		{
142	9	$schemas = new Schemas();
143	9	$xpath = new DOMXPath($this->document);
144
145		// get the http://www.w3.org/2001/XMLSchema-instance namespace (it could not be 'xsi')
146	9	$xsi = $this->document->lookupPrefix('http://www.w3.org/2001/XMLSchema-instance');
147	9	if (! $xsi) { // the namespace is not registered, no need to continue
148	1	return $schemas;
149		}
150
151		// get all the xsi:schemaLocation attributes in the document
152		/** @var DOMNodeList<DOMAttr> $schemasList */
153	8	$schemasList = $xpath->query("//@$xsi:schemaLocation") ?: new DOMNodeList();
154
155		// process every schemaLocation and import them into schemas
156	8	foreach ($schemasList as $node) {
157	7	$schemas->import($this->buildSchemasFromSchemaLocationValue($node->nodeValue));
158		}
159
160	7	return $schemas;
161		}
162
163		/**
164		* Create a schemas collection from the content of a schema location
165		*
166		* @param string $content
167		* @return Schemas
168		* @throws SchemaLocationPartsNotEvenException when the schemaLocation attribute does not have even parts
169		*/
170	7	public function buildSchemasFromSchemaLocationValue(string $content): Schemas
171		{
172		// get parts without inner spaces
173	7	$parts = preg_split('/\s+/', $content) ?: [];
174	7	$partsCount = count($parts);
175
176		// check that the list count is an even number
177	7	if (0 !== $partsCount % 2) {
178	1	throw SchemaLocationPartsNotEvenException::create($parts);
179		}
180
181		// insert the uris pairs into the schemas
182	6	$schemas = new Schemas();
183	6	for ($k = 0; $k < $partsCount; $k = $k + 2) {
184	6	$schemas->create($parts[$k], $parts[$k + 1]);
185		}
186	6	return $schemas;
187		}
188		}
189

eclipxe13 / XmlSchemaValidator

Push — master ( add283...7568bf )

SchemaValidator::buildSchemas() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like