XmlDeserializationVisitor::visitArray() - Code Metrics - Inspection of "Merge pull request #645 from schmittjoh/alcalyn-fe..." - schmittjoh/serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3d958d...523004 )

by Asmir

created 2016-10-28 11:20 UTC

XmlDeserializationVisitor::visitArray() F

↳ Parent: XmlDeserializationVisitor

Complexity

Conditions	20
Paths	1440

Size

Total Lines	65
Code Lines	39

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	33
CRAP Score	26.25

Importance

Changes

Metric	Value
dl	0
loc	65
ccs	33
cts	44
cp	0.75
rs	2.8282
c	0
b	0
f	0
cc	20
eloc	39
nc	1440
nop	3
crap	26.25

How to fix Long Method Complexity

<?php

/*
 * Copyright 2016 Johannes M. Schmitt <[email protected]>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace JMS\Serializer;

use JMS\Serializer\Exception\XmlErrorException;
use JMS\Serializer\Exception\LogicException;
use JMS\Serializer\Exception\InvalidArgumentException;
use JMS\Serializer\Exception\RuntimeException;
use JMS\Serializer\Metadata\PropertyMetadata;
use JMS\Serializer\Metadata\ClassMetadata;

class XmlDeserializationVisitor extends AbstractVisitor
{
    private $objectStack;
    private $metadataStack;
    private $objectMetadataStack;
    private $currentObject;
    private $currentMetadata;
    private $result;
    private $navigator;
    private $disableExternalEntities = true;
    private $doctypeWhitelist = array();

    public function enableExternalEntities()
    {
        $this->disableExternalEntities = false;
    }

    public function setNavigator(GraphNavigator $navigator)
    {
        $this->navigator = $navigator;
        $this->objectStack = new \SplStack;
        $this->metadataStack = new \SplStack;
        $this->objectMetadataStack = new \SplStack;
        $this->result = null;
    }

    public function getNavigator()
    {
        return $this->navigator;
    }

    public function prepare($data)
    {
        $previous = libxml_use_internal_errors(true);
        $previousEntityLoaderState = libxml_disable_entity_loader($this->disableExternalEntities);

        if (false !== stripos($data, '<!doctype')) {
            $internalSubset = $this->getDomDocumentTypeEntitySubset($data);
            if (!in_array($internalSubset, $this->doctypeWhitelist, true)) {
                throw new InvalidArgumentException(sprintf(
                    'The document type "%s" is not allowed. If it is safe, you may add it to the whitelist configuration.',
                    $internalSubset
                ));
            }
        }

        $doc = simplexml_load_string($data);

        libxml_use_internal_errors($previous);
        libxml_disable_entity_loader($previousEntityLoaderState);

        if (false === $doc) {
            throw new XmlErrorException(libxml_get_last_error());
        }

        return $doc;
    }

    public function visitNull($data, array $type, Context $context)
    {
        return null;
    }

    public function visitString($data, array $type, Context $context)
    {
        $data = (string) $data;

        if (null === $this->result) {
            $this->result = $data;
        }

        return $data;
    }

    public function visitBoolean($data, array $type, Context $context)
    {
        $data = (string) $data;

        if ('true' === $data || '1' === $data) {
            $data = true;
        } elseif ('false' === $data || '0' === $data) {
            $data = false;
        } else {
            throw new RuntimeException(sprintf('Could not convert data to boolean. Expected "true", "false", "1" or "0", but got %s.', json_encode($data)));
        }

        if (null === $this->result) {
            $this->result = $data;
        }

        return $data;
    }

    public function visitInteger($data, array $type, Context $context)
    {
        $data = (integer) $data;

        if (null === $this->result) {
            $this->result = $data;
        }

        return $data;
    }

    public function visitDouble($data, array $type, Context $context)
    {
        $data = (double) $data;

        if (null === $this->result) {
            $this->result = $data;
        }

        return $data;
    }

    public function visitArray($data, array $type, Context $context)
    {
        $entryName = null !== $this->currentMetadata && $this->currentMetadata->xmlEntryName ? $this->currentMetadata->xmlEntryName : 'entry';
        $namespace = null !== $this->currentMetadata && $this->currentMetadata->xmlEntryNamespace ? $this->currentMetadata->xmlEntryNamespace : null;

        if ($namespace === null && $this->objectMetadataStack->count()) {
            $classMetadata = $this->objectMetadataStack->top();
            $namespace = isset($classMetadata->xmlNamespaces[''])?$classMetadata->xmlNamespaces['']:$namespace;
        }

        $hasNode = null !== $namespace ? isset($data->children($namespace)->$entryName) : isset($data->$entryName);
        if (false === $hasNode) {
            if (null === $this->result) {
                return $this->result = array();
            }

            return array();
        }

        switch (count($type['params'])) {
            case 0:
                throw new RuntimeException(sprintf('The array type must be specified either as "array<T>", or "array<K,V>".'));

            case 1:
                $result = array();

                if (null === $this->result) {
                    $this->result = &$result;
                }

                $nodes = $data->children($namespace)->$entryName;
                foreach ($nodes as $v) {
                    $result[] = $this->navigator->accept($v, $type['params'][0], $context);
                }

                return $result;

            case 2:
                if (null === $this->currentMetadata) {
                    throw new RuntimeException('Maps are not supported on top-level without metadata.');
                }

                list($keyType, $entryType) = $type['params'];
                $result = array();
                if (null === $this->result) {
                    $this->result = &$result;
                }

                $nodes = $data->children($namespace)->$entryName;
                foreach ($nodes as $v) {
                    $attrs = $v->attributes();
                    if ( ! isset($attrs[$this->currentMetadata->xmlKeyAttribute])) {
                        throw new RuntimeException(sprintf('The key attribute "%s" must be set for each entry of the map.', $this->currentMetadata->xmlKeyAttribute));
                    }

                    $k = $this->navigator->accept($attrs[$this->currentMetadata->xmlKeyAttribute], $keyType, $context);
                    $result[$k] = $this->navigator->accept($v, $entryType, $context);
                }

                return $result;

            default:
                throw new LogicException(sprintf('The array type does not support more than 2 parameters, but got %s.', json_encode($type['params'])));
        }
    }

    public function startVisitingObject(ClassMetadata $metadata, $object, array $type, Context $context)
    {
        $this->setCurrentObject($object);
        $this->objectMetadataStack->push($metadata);
        if (null === $this->result) {
            $this->result = $this->currentObject;
        }
    }

    public function visitProperty(PropertyMetadata $metadata, $data, Context $context)
    {
        $name = $this->namingStrategy->translateName($metadata);

        if ( ! $metadata->type) {
            throw new RuntimeException(sprintf('You must define a type for %s::$%s.', $metadata->reflection->class, $metadata->name));
        }

       if ($metadata->xmlAttribute) {

            $attributes = $data->attributes($metadata->xmlNamespace);
            if (isset($attributes[$name])) {
                $v = $this->navigator->accept($attributes[$name], $metadata->type, $context);
                $metadata->reflection->setValue($this->currentObject, $v);
            }

            return;
        }

        if ($metadata->xmlValue) {
            $v = $this->navigator->accept($data, $metadata->type, $context);
            $metadata->reflection->setValue($this->currentObject, $v);

            return;
        }

        if ($metadata->xmlCollection) {
            $enclosingElem = $data;
            if (!$metadata->xmlCollectionInline) {
                $enclosingElem = $data->children($metadata->xmlNamespace)->$name;
            }

            $this->setCurrentMetadata($metadata);
            $v = $this->navigator->accept($enclosingElem, $metadata->type, $context);
            $this->revertCurrentMetadata();
            $metadata->reflection->setValue($this->currentObject, $v);

            return;
        }

        if ($metadata->xmlNamespace) {
            $node = $data->children($metadata->xmlNamespace)->$name;
            if (!$node->count()) {
                return;
            }
        } else {

            $namespaces = $data->getDocNamespaces();

            if (isset($namespaces[''])) {
                $prefix = uniqid('ns-');
                $data->registerXPathNamespace($prefix, $namespaces['']);
                $nodes = $data->xpath('./'.$prefix. ':'.$name );
            } else {
                $nodes = $data->xpath('./'. $name );
            }
            if (empty($nodes)) {
                return;
            }
            $node = reset($nodes);
        }

        $v = $this->navigator->accept($node, $metadata->type, $context);

        $metadata->setValue($this->currentObject, $v);
    }

    public function endVisitingObject(ClassMetadata $metadata, $data, array $type, Context $context)
    {
        $rs = $this->currentObject;
        $this->objectMetadataStack->pop();
        $this->revertCurrentObject();

        return $rs;
    }

    public function setCurrentObject($object)
    {
        $this->objectStack->push($this->currentObject);
        $this->currentObject = $object;
    }

    public function getCurrentObject()
    {
        return $this->currentObject;
    }

    public function revertCurrentObject()
    {
        return $this->currentObject = $this->objectStack->pop();
    }

    public function setCurrentMetadata(PropertyMetadata $metadata)
    {
        $this->metadataStack->push($this->currentMetadata);
        $this->currentMetadata = $metadata;
    }

    public function getCurrentMetadata()
    {
        return $this->currentMetadata;
    }

    public function revertCurrentMetadata()
    {
        return $this->currentMetadata = $this->metadataStack->pop();
    }

    public function getResult()
    {
        return $this->result;
    }

    /**
     * @param array<string> $doctypeWhitelist
     */
    public function setDoctypeWhitelist(array $doctypeWhitelist)
    {
        $this->doctypeWhitelist = $doctypeWhitelist;
    }

    /**
     * @return array<string>
     */
    public function getDoctypeWhitelist()
    {
        return $this->doctypeWhitelist;
    }

    /**
     * Retrieves internalSubset even in bugfixed php versions
     *
     * @param \DOMDocumentType $child
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $data
     * @return string
     */
    private function getDomDocumentTypeEntitySubset($data)
    {
        $startPos = $endPos = stripos($data, '<!doctype');
        $braces = 0;
        do {
            $char = $data[$endPos++];
            if ($char === '<') {
                ++$braces;
            }
            if ($char === '>') {
                --$braces;
            }
        } while ($braces > 0);

        $internalSubset = substr($data, $startPos, $endPos - $startPos);
        $internalSubset = str_replace(array("\n", "\r"), '', $internalSubset);
        $internalSubset = preg_replace('/\s{2,}/', ' ', $internalSubset);
        $internalSubset = str_replace(array("[ <!", "> ]>"), array('[<!', '>]>'), $internalSubset);

        return $internalSubset;
    }
}


1		<?php
2
3		/*
4		* Copyright 2016 Johannes M. Schmitt <[email protected]>
5		*
6		* Licensed under the Apache License, Version 2.0 (the "License");
7		* you may not use this file except in compliance with the License.
8		* You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS,
14		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15		* See the License for the specific language governing permissions and
16		* limitations under the License.
17		*/
18
19		namespace JMS\Serializer;
20
21		use JMS\Serializer\Exception\XmlErrorException;
22		use JMS\Serializer\Exception\LogicException;
23		use JMS\Serializer\Exception\InvalidArgumentException;
24		use JMS\Serializer\Exception\RuntimeException;
25		use JMS\Serializer\Metadata\PropertyMetadata;
26		use JMS\Serializer\Metadata\ClassMetadata;
27
28		class XmlDeserializationVisitor extends AbstractVisitor
29		{
30		private $objectStack;
31		private $metadataStack;
32		private $objectMetadataStack;
33		private $currentObject;
34		private $currentMetadata;
35		private $result;
36		private $navigator;
37		private $disableExternalEntities = true;
38		private $doctypeWhitelist = array();
39
40		public function enableExternalEntities()
41		{
42		$this->disableExternalEntities = false;
43		}
44
45	49	public function setNavigator(GraphNavigator $navigator)
46		{
47	49	$this->navigator = $navigator;
48	49	$this->objectStack = new \SplStack;
49	49	$this->metadataStack = new \SplStack;
50	49	$this->objectMetadataStack = new \SplStack;
51	49	$this->result = null;
52	49	}
53
54	1	public function getNavigator()
55		{
56	1	return $this->navigator;
57		}
58
59	51	public function prepare($data)
60		{
61	51	$previous = libxml_use_internal_errors(true);
62	51	$previousEntityLoaderState = libxml_disable_entity_loader($this->disableExternalEntities);
63
64	51	if (false !== stripos($data, '<!doctype')) {
65	3	$internalSubset = $this->getDomDocumentTypeEntitySubset($data);
66	3	if (!in_array($internalSubset, $this->doctypeWhitelist, true)) {
67	2	throw new InvalidArgumentException(sprintf(
68	2	'The document type "%s" is not allowed. If it is safe, you may add it to the whitelist configuration.',
69		$internalSubset
70	2	));
71		}
72	1	}
73
74	49	$doc = simplexml_load_string($data);
75
76	49	libxml_use_internal_errors($previous);
77	49	libxml_disable_entity_loader($previousEntityLoaderState);
78
79	49	if (false === $doc) {
80		throw new XmlErrorException(libxml_get_last_error());
81		}
82
83	49	return $doc;
84		}
85
86	1	public function visitNull($data, array $type, Context $context)
87		{
88	1	return null;
89		}
90
91	17	public function visitString($data, array $type, Context $context)
92		{
93	17	$data = (string) $data;
94
95	17	if (null === $this->result) {
96	3	$this->result = $data;
97	3	}
98
99	17	return $data;
100		}
101
102	8	public function visitBoolean($data, array $type, Context $context)
103		{
104	8	$data = (string) $data;
105
106	8	if ('true' === $data \|\| '1' === $data) {
107	4	$data = true;
108	8	} elseif ('false' === $data \|\| '0' === $data) {
109	5	$data = false;
110	5	} else {
111		throw new RuntimeException(sprintf('Could not convert data to boolean. Expected "true", "false", "1" or "0", but got %s.', json_encode($data)));
112		}
113
114	8	if (null === $this->result) {
115	6	$this->result = $data;
116	6	}
117
118	8	return $data;
119		}
120
121	8	public function visitInteger($data, array $type, Context $context)
122		{
123	8	$data = (integer) $data;
124
125	8	if (null === $this->result) {
126	2	$this->result = $data;
127	2	}
128
129	8	return $data;
130		}
131
132	12	public function visitDouble($data, array $type, Context $context)
133		{
134	12	$data = (double) $data;
135
136	12	if (null === $this->result) {
137	6	$this->result = $data;
138	6	}
139
140	12	return $data;
141		}
142
143	12	public function visitArray($data, array $type, Context $context)
144		{
145	12	$entryName = null !== $this->currentMetadata && $this->currentMetadata->xmlEntryName ? $this->currentMetadata->xmlEntryName : 'entry';
146	12	$namespace = null !== $this->currentMetadata && $this->currentMetadata->xmlEntryNamespace ? $this->currentMetadata->xmlEntryNamespace : null;
147
148	12	if ($namespace === null && $this->objectMetadataStack->count()) {
149	7	$classMetadata = $this->objectMetadataStack->top();
150	7	$namespace = isset($classMetadata->xmlNamespaces[''])?$classMetadata->xmlNamespaces['']:$namespace;
151	7	}
152
153	12	$hasNode = null !== $namespace ? isset($data->children($namespace)->$entryName) : isset($data->$entryName);
154		if (false === $hasNode) {
155		if (null === $this->result) {
156		return $this->result = array();
157		}
158
159		return array();
160		}
161	12
162	12	switch (count($type['params'])) {
163		case 0:
164		throw new RuntimeException(sprintf('The array type must be specified either as "array<T>", or "array<K,V>".'));
165	12
166	12	case 1:
167		$result = array();
168	12
169	5	if (null === $this->result) {
170	5	$this->result = &$result;
171		}
172	12
173	12	$nodes = $data->children($namespace)->$entryName;
174	12	foreach ($nodes as $v) {
175	12	$result[] = $this->navigator->accept($v, $type['params'][0], $context);
176		}
177	12
178		return $result;
179	3
180	3	case 2:
181		if (null === $this->currentMetadata) {
182		throw new RuntimeException('Maps are not supported on top-level without metadata.');
183		}
184	3
185	3	list($keyType, $entryType) = $type['params'];
186	3	$result = array();
187		if (null === $this->result) {
188		$this->result = &$result;
189		}
190	3
191	3	$nodes = $data->children($namespace)->$entryName;
192	3	foreach ($nodes as $v) {
193	3	$attrs = $v->attributes();
194		if ( ! isset($attrs[$this->currentMetadata->xmlKeyAttribute])) {
195		throw new RuntimeException(sprintf('The key attribute "%s" must be set for each entry of the map.', $this->currentMetadata->xmlKeyAttribute));
196		}
197	3
198	3	$k = $this->navigator->accept($attrs[$this->currentMetadata->xmlKeyAttribute], $keyType, $context);
199	3	$result[$k] = $this->navigator->accept($v, $entryType, $context);
200		}
201	3
202		return $result;
203
204		default:
205		throw new LogicException(sprintf('The array type does not support more than 2 parameters, but got %s.', json_encode($type['params'])));
206		}
207		}
208	22
209		public function startVisitingObject(ClassMetadata $metadata, $object, array $type, Context $context)
210	22	{
211	22	$this->setCurrentObject($object);
212	22	$this->objectMetadataStack->push($metadata);
213	21	if (null === $this->result) {
214	21	$this->result = $this->currentObject;
215	22	}
216		}
217	21
218		public function visitProperty(PropertyMetadata $metadata, $data, Context $context)
219	21	{
220		$name = $this->namingStrategy->translateName($metadata);
221	21
222		if ( ! $metadata->type) {
223		throw new RuntimeException(sprintf('You must define a type for %s::$%s.', $metadata->reflection->class, $metadata->name));
224		}
225	21
226		if ($metadata->xmlAttribute) {
227	4
228	4	$attributes = $data->attributes($metadata->xmlNamespace);
229	4	if (isset($attributes[$name])) {
230	4	$v = $this->navigator->accept($attributes[$name], $metadata->type, $context);
231	4	$metadata->reflection->setValue($this->currentObject, $v);
232		}
233	4
234		return;
235		}
236	21
237	5	if ($metadata->xmlValue) {
238	5	$v = $this->navigator->accept($data, $metadata->type, $context);
239		$metadata->reflection->setValue($this->currentObject, $v);
240	5
241		return;
242		}
243	19
244	3	if ($metadata->xmlCollection) {
245	3	$enclosingElem = $data;
246	3	if (!$metadata->xmlCollectionInline) {
247	3	$enclosingElem = $data->children($metadata->xmlNamespace)->$name;
248		}
249	3
250	3	$this->setCurrentMetadata($metadata);
251	3	$v = $this->navigator->accept($enclosingElem, $metadata->type, $context);
252	3	$this->revertCurrentMetadata();
253		$metadata->reflection->setValue($this->currentObject, $v);
254	3
255		return;
256		}
257	19
258	3	if ($metadata->xmlNamespace) {
259	3	$node = $data->children($metadata->xmlNamespace)->$name;
260		if (!$node->count()) {
261		return;
262	3	}
263		} else {
264	17
265		$namespaces = $data->getDocNamespaces();
266	17
267	1	if (isset($namespaces[''])) {
268	1	$prefix = uniqid('ns-');
269	1	$data->registerXPathNamespace($prefix, $namespaces['']);
270	1	$nodes = $data->xpath('./'.$prefix. ':'.$name );
271	16	} else {
272		$nodes = $data->xpath('./'. $name );
273	17	}
274	1	if (empty($nodes)) {
275		return;
276	17	}
277		$node = reset($nodes);
278		}
279	19
280		$v = $this->navigator->accept($node, $metadata->type, $context);
281	19
282	19	$metadata->setValue($this->currentObject, $v);
283		}
284	22
285		public function endVisitingObject(ClassMetadata $metadata, $data, array $type, Context $context)
286	22	{
287	22	$rs = $this->currentObject;
288	22	$this->objectMetadataStack->pop();
289		$this->revertCurrentObject();
290	22
291		return $rs;
292		}
293	22
294		public function setCurrentObject($object)
295	22	{
296	22	$this->objectStack->push($this->currentObject);
297	22	$this->currentObject = $object;
298		}
299
300		public function getCurrentObject()
301		{
302		return $this->currentObject;
303		}
304	22
305		public function revertCurrentObject()
306	22	{
307		return $this->currentObject = $this->objectStack->pop();
308		}
309	3
310		public function setCurrentMetadata(PropertyMetadata $metadata)
311	3	{
312	3	$this->metadataStack->push($this->currentMetadata);
313	3	$this->currentMetadata = $metadata;
314		}
315
316		public function getCurrentMetadata()
317		{
318		return $this->currentMetadata;
319		}
320	3
321		public function revertCurrentMetadata()
322	3	{
323		return $this->currentMetadata = $this->metadataStack->pop();
324		}
325	48
326		public function getResult()
327	48	{
328		return $this->result;
329		}
330
331		/**
332		* @param array<string> $doctypeWhitelist
333	1	*/
334		public function setDoctypeWhitelist(array $doctypeWhitelist)
335	1	{
336	1	$this->doctypeWhitelist = $doctypeWhitelist;
337		}
338
339		/**
340		* @return array<string>
341		*/
342		public function getDoctypeWhitelist()
343		{
344		return $this->doctypeWhitelist;
345		}
346
347		/**
348		* Retrieves internalSubset even in bugfixed php versions
349		*
350		* @param \DOMDocumentType $child
		0 ignored issues – show Bug introduced 2016-05-06 14:50 UTC by Report Bug Copy Issue Report There is no parameter named `$child`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
351		* @param string $data
352		* @return string
353	3	*/
354		private function getDomDocumentTypeEntitySubset($data)
355	3	{
356	3	$startPos = $endPos = stripos($data, '<!doctype');
357		$braces = 0;
358	3	do {
359	3	$char = $data[$endPos++];
360	3	if ($char === '<') {
361	3	++$braces;
362	3	}
363	3	if ($char === '>') {
364	3	--$braces;
365	3	}
366		} while ($braces > 0);
367	3
368	3	$internalSubset = substr($data, $startPos, $endPos - $startPos);
369	3	$internalSubset = str_replace(array("\n", "\r"), '', $internalSubset);
370	3	$internalSubset = preg_replace('/\s{2,}/', ' ', $internalSubset);
371		$internalSubset = str_replace(array("[ <!", "> ]>"), array('[<!', '>]>'), $internalSubset);
372	3
373		return $internalSubset;
374		}
375		}
376

schmittjoh / serializer

Push — master ( 3d958d...523004 )

XmlDeserializationVisitor::visitArray() F

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like