XmlClassMetadataLoader::loadDocument() - Code Metrics - Inspection of "[Event] Fix integration + Add tests & docs" - egeloen/ivory-serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#19)

by Eric

created 2017-02-02 23:19 UTC

XmlClassMetadataLoader::loadDocument() B

↳ Parent: XmlClassMetadataLoader

Complexity

Conditions	6
Paths	6

Size

Total Lines	36
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	20
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	36
ccs	20
cts	20
cp	1
rs	8.439
c	0
b	0
f	0
cc	6
eloc	19
nc	6
nop	1
crap	6

<?php

/*
 * This file is part of the Ivory Serializer package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\Serializer\Mapping\Loader;

/**
 * @author GeLo <[email protected]>
 */
class XmlClassMetadataLoader extends AbstractFileClassMetadataLoader
{
    /**
     * {@inheritdoc}
     */
    protected function loadFile($file)
    {
        $data = [];
        $xml = simplexml_import_dom($this->loadDocument($file));

        foreach ($xml->class as $class) {
            $data[(string) $class['name']] = $this->loadClass($class);
        }

        return $data;
    }

    /**
     * @param \SimpleXMLElement $class
     *
     * @return mixed[]
     */
    private function loadClass(\SimpleXMLElement $class)
    {
        $definition = [];

        if (isset($class['exclusion-policy'])) {
            $definition['exclusion_policy'] = (string) $class['exclusion-policy'];
        }

        if (isset($class['order'])) {
            $definition['order'] = (string) $class['order'];
        }

        if (isset($class['readable'])) {
            $definition['readable'] = (string) $class['readable'] === 'true';
        }

        if (isset($class['writable'])) {
            $definition['writable'] = (string) $class['writable'] === 'true';
        }

        if (isset($class['xml-root'])) {
            $definition['xml_root'] = (string) $class['xml-root'];
        }

        $properties = [];

        foreach ($class->property as $property) {
            $properties[(string) $property['name']] = $this->loadProperty($property);
        }

        $definition['properties'] = $properties;

        return $definition;
    }

    /**
     * @param \SimpleXMLElement $element
     *
     * @return mixed[]
     */
    private function loadProperty(\SimpleXMLElement $element)
    {
        $property = [];

        if (isset($element['alias'])) {
            $property['alias'] = (string) $element['alias'];
        }

        if (isset($element['type'])) {
            $property['type'] = (string) $element['type'];
        }

        if (isset($element['exclude'])) {
            $property['exclude'] = (string) $element['exclude'] === 'true';
        }

        if (isset($element['expose'])) {
            $property['expose'] = (string) $element['expose'] === 'true';
        }

        if (isset($element['accessor'])) {
            $property['accessor'] = (string) $element['accessor'];
        }

        if (isset($element['readable'])) {
            $property['readable'] = (string) $element['readable'] === 'true';
        }

        if (isset($element['writable'])) {
            $property['writable'] = (string) $element['writable'] === 'true';
        }

        if (isset($element['mutator'])) {
            $property['mutator'] = (string) $element['mutator'];
        }

        if (isset($element['since'])) {
            $property['since'] = (string) $element['since'];
        }

        if (isset($element['until'])) {
            $property['until'] = (string) $element['until'];
        }

        if (isset($element['max-depth'])) {
            $property['max_depth'] = (int) $element['max-depth'];
        }

        foreach ($element->group as $group) {
            $property['groups'][] = (string) $group;
        }

        if (isset($element['xml-attribute'])) {
            $property['xml_attribute'] = (string) $element['xml-attribute'] === 'true';
        }

        if (isset($element['xml-value'])) {
            $property['xml_value'] = (string) $element['xml-value'] === 'true';
        }

        if (isset($element['xml-inline'])) {
            $property['xml_inline'] = (string) $element['xml-inline'] === 'true';
        }

        if (isset($element['xml-entry'])) {
            $property['xml_entry'] = (string) $element['xml-entry'];
        }

        if (isset($element['xml-entry-attribute'])) {
            $property['xml_entry_attribute'] = (string) $element['xml-entry-attribute'];
        }

        if (isset($element['xml-key-as-attribute'])) {
            $property['xml_key_as_attribute'] = (string) $element['xml-key-as-attribute'] === 'true';
        }

        if (isset($element['xml-key-as-node'])) {
            $property['xml_key_as_node'] = (string) $element['xml-key-as-node'] === 'true';
        }

        return $property;
    }

    /**
     * @param string $file
     *
     * @return \DOMDocument
     */
    private function loadDocument($file)
    {
        $data = trim(@file_get_contents($file));

        if (empty($data)) {
            throw new \InvalidArgumentException(sprintf('The XML mapping file "%s" is not valid.', $file));
        }

        $internalErrors = libxml_use_internal_errors();
        $disableEntities = libxml_disable_entity_loader();

        $this->setLibXmlState(true, true);

        $document = new \DOMDocument();
        $document->validateOnParse = true;

        if (!@$document->loadXML($data, LIBXML_NONET | LIBXML_COMPACT)) {
            throw $this->createException($file, $internalErrors, $disableEntities);
        }

        $document->normalizeDocument();

        if (!@$document->schemaValidateSource(file_get_contents(__DIR__.'/../Resource/mapping.xsd'))) {
            throw $this->createException($file, $internalErrors, $disableEntities);
        }

        foreach ($document->childNodes as $child) {
            if ($child->nodeType === XML_DOCUMENT_TYPE_NODE) {
                throw new \InvalidArgumentException('The document type is not allowed.');
            }
        }

        $this->setLibXmlState($internalErrors, $disableEntities);

        return $document;
    }

    /**
     * @param string $file
     * @param bool   $internalErrors
     * @param bool   $disableEntities
     *
     * @return \InvalidArgumentException
     */
    private function createException($file, $internalErrors, $disableEntities)
    {
        $errors = [];

        foreach (libxml_get_errors() as $error) {

            $errors[] = sprintf('[%s %s] %s (in %s - line %d, column %d)',
                $error->level === LIBXML_ERR_WARNING ? 'WARNING' : 'ERROR',
                $error->code,
                trim($error->message),
                $file,
                $error->line,
                $error->column
            );
        }

        $this->setLibXmlState($internalErrors, $disableEntities);

        return new \InvalidArgumentException(implode(PHP_EOL, $errors));
    }

    /**
     * @param bool $internalErrors
     * @param bool $disableEntities
     */
    private function setLibXmlState($internalErrors, $disableEntities)
    {
        libxml_use_internal_errors($internalErrors);
        libxml_disable_entity_loader($disableEntities);
        libxml_clear_errors();
    }
}


1			<?php
2
3			/*
4			* This file is part of the Ivory Serializer package.
5			*
6			* (c) Eric GELOEN <[email protected]>
7			*
8			* For the full copyright and license information, please read the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Ivory\Serializer\Mapping\Loader;
13
14			/**
15			* @author GeLo <[email protected]>
16			*/
17			class XmlClassMetadataLoader extends AbstractFileClassMetadataLoader
18			{
19			/**
20			* {@inheritdoc}
21			*/
22	388		protected function loadFile($file)
23			{
24	388		$data = [];
25	388		$xml = simplexml_import_dom($this->loadDocument($file));
26
27	360		foreach ($xml->class as $class) {
28	360		$data[(string) $class['name']] = $this->loadClass($class);
29	180		}
30
31	360		return $data;
32			}
33
34			/**
35			* @param \SimpleXMLElement $class
36			*
37			* @return mixed[]
38			*/
39	360		private function loadClass(\SimpleXMLElement $class)
40			{
41	360		$definition = [];
42
43	360		if (isset($class['exclusion-policy'])) {
44	248		$definition['exclusion_policy'] = (string) $class['exclusion-policy'];
45	124		}
46
47	360		if (isset($class['order'])) {
48	264		$definition['order'] = (string) $class['order'];
49	132		}
50
51	360		if (isset($class['readable'])) {
52	240		$definition['readable'] = (string) $class['readable'] === 'true';
53	120		}
54
55	360		if (isset($class['writable'])) {
56	240		$definition['writable'] = (string) $class['writable'] === 'true';
57	120		}
58
59	360		if (isset($class['xml-root'])) {
60	248		$definition['xml_root'] = (string) $class['xml-root'];
61	124		}
62
63	360		$properties = [];
64
65	360		foreach ($class->property as $property) {
66	352		$properties[(string) $property['name']] = $this->loadProperty($property);
67	180		}
68
69	360		$definition['properties'] = $properties;
70
71	360		return $definition;
72			}
73
74			/**
75			* @param \SimpleXMLElement $element
76			*
77			* @return mixed[]
78			*/
79	352		private function loadProperty(\SimpleXMLElement $element)
80			{
81	352		$property = [];
82
83	352		if (isset($element['alias'])) {
84	248		$property['alias'] = (string) $element['alias'];
85	124		}
86
87	352		if (isset($element['type'])) {
88	248		$property['type'] = (string) $element['type'];
89	124		}
90
91	352		if (isset($element['exclude'])) {
92	248		$property['exclude'] = (string) $element['exclude'] === 'true';
93	124		}
94
95	352		if (isset($element['expose'])) {
96	240		$property['expose'] = (string) $element['expose'] === 'true';
97	120		}
98
99	352		if (isset($element['accessor'])) {
100	248		$property['accessor'] = (string) $element['accessor'];
101	124		}
102
103	352		if (isset($element['readable'])) {
104	240		$property['readable'] = (string) $element['readable'] === 'true';
105	120		}
106
107	352		if (isset($element['writable'])) {
108	240		$property['writable'] = (string) $element['writable'] === 'true';
109	120		}
110
111	352		if (isset($element['mutator'])) {
112	248		$property['mutator'] = (string) $element['mutator'];
113	124		}
114
115	352		if (isset($element['since'])) {
116	248		$property['since'] = (string) $element['since'];
117	124		}
118
119	352		if (isset($element['until'])) {
120	248		$property['until'] = (string) $element['until'];
121	124		}
122
123	352		if (isset($element['max-depth'])) {
124	240		$property['max_depth'] = (int) $element['max-depth'];
125	120		}
126
127	352		foreach ($element->group as $group) {
128	248		$property['groups'][] = (string) $group;
129	176		}
130
131	352		if (isset($element['xml-attribute'])) {
132	240		$property['xml_attribute'] = (string) $element['xml-attribute'] === 'true';
133	120		}
134
135	352		if (isset($element['xml-value'])) {
136	240		$property['xml_value'] = (string) $element['xml-value'] === 'true';
137	120		}
138
139	352		if (isset($element['xml-inline'])) {
140	240		$property['xml_inline'] = (string) $element['xml-inline'] === 'true';
141	120		}
142
143	352		if (isset($element['xml-entry'])) {
144	248		$property['xml_entry'] = (string) $element['xml-entry'];
145	124		}
146
147	352		if (isset($element['xml-entry-attribute'])) {
148	248		$property['xml_entry_attribute'] = (string) $element['xml-entry-attribute'];
149	124		}
150
151	352		if (isset($element['xml-key-as-attribute'])) {
152	240		$property['xml_key_as_attribute'] = (string) $element['xml-key-as-attribute'] === 'true';
153	120		}
154
155	352		if (isset($element['xml-key-as-node'])) {
156	240		$property['xml_key_as_node'] = (string) $element['xml-key-as-node'] === 'true';
157	120		}
158
159	352		return $property;
160			}
161
162			/**
163			* @param string $file
164			*
165			* @return \DOMDocument
166			*/
167	388		private function loadDocument($file)
168			{
169	388		$data = trim(@file_get_contents($file));
170
171	388		if (empty($data)) {
172	4		throw new \InvalidArgumentException(sprintf('The XML mapping file "%s" is not valid.', $file));
173			}
174
175	384		$internalErrors = libxml_use_internal_errors();
176	384		$disableEntities = libxml_disable_entity_loader();
177
178	384		$this->setLibXmlState(true, true);
179
180	384		$document = new \DOMDocument();
181	384		$document->validateOnParse = true;
182
183	384		if (!@$document->loadXML($data, LIBXML_NONET \| LIBXML_COMPACT)) {
184	8		throw $this->createException($file, $internalErrors, $disableEntities);
185			}
186
187	376		$document->normalizeDocument();
188
189	376		if (!@$document->schemaValidateSource(file_get_contents(__DIR__.'/../Resource/mapping.xsd'))) {
190	16		throw $this->createException($file, $internalErrors, $disableEntities);
191			}
192
193	360		foreach ($document->childNodes as $child) {
194	360		if ($child->nodeType === XML_DOCUMENT_TYPE_NODE) {
195	180		throw new \InvalidArgumentException('The document type is not allowed.');
196			}
197	180		}
198
199	360		$this->setLibXmlState($internalErrors, $disableEntities);
200
201	360		return $document;
202			}
203
204			/**
205			* @param string $file
206			* @param bool $internalErrors
207			* @param bool $disableEntities
208			*
209			* @return \InvalidArgumentException
210			*/
211	24		private function createException($file, $internalErrors, $disableEntities)
212			{
213	24		$errors = [];
214
215	24	View Code Duplication	foreach (libxml_get_errors() as $error) {
			0 ignored issues – show Duplication introduced 2017-01-21 02:21 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
216	24		$errors[] = sprintf('[%s %s] %s (in %s - line %d, column %d)',
217	24		$error->level === LIBXML_ERR_WARNING ? 'WARNING' : 'ERROR',
218	24		$error->code,
219	24		trim($error->message),
220	12		$file,
221	24		$error->line,
222	24		$error->column
223	12		);
224	12		}
225
226	24		$this->setLibXmlState($internalErrors, $disableEntities);
227
228	24		return new \InvalidArgumentException(implode(PHP_EOL, $errors));
229			}
230
231			/**
232			* @param bool $internalErrors
233			* @param bool $disableEntities
234			*/
235	384		private function setLibXmlState($internalErrors, $disableEntities)
236			{
237	384		libxml_use_internal_errors($internalErrors);
238	384		libxml_disable_entity_loader($disableEntities);
239	384		libxml_clear_errors();
240	384		}
241			}
242

egeloen / ivory-serializer

Pull Request — master (#19)

XmlClassMetadataLoader::loadDocument() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like