FromArrayBuilder::addDataItem() - Code Metrics - Inspection of "add FromArray to XML" - bytic/utility - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cb02e9...c4035d )

by Gabriel

created 2020-10-05 13:08 UTC

FromArrayBuilder::addDataItem() C

↳ Parent: FromArrayBuilder

Complexity

Conditions	15
Paths	38

Size

Total Lines	51
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
eloc	34
c	1
b	0
f	1
dl	0
loc	51
rs	5.9166
cc	15
nc	38
nop	5

How to fix Long Method Complexity

<?php
/** @noinspection PhpComposerExtensionStubsInspection */

namespace Nip\Utility\Xml;

use DOMDocument;
use DOMText;
use SebastianBergmann\CodeCoverage\XmlException;
filter:
    dependency_paths: ["lib/*"]
use SimpleXMLElement;

/**
 * Class FromArrayBuilder
 * @package Nip\Utility\Xml
 */
class FromArrayBuilder
{

    protected $input;

    /**
     * @var DOMDocument
     */
    protected $dom;
    protected $options = [];


    /**
     * @param          $input
     * @param   array  $options
     *
     * @return DOMDocument|SimpleXMLElement
     */
    public static function build($input, array $options = [])
    {
        if (is_object($input) && method_exists($input, 'toArray') && is_callable([$input, 'toArray'])) {
            $input = $input->toArray();
        }
        if (!is_array($input) || count($input) !== 1) {
            throw new XmlException('Invalid input.');
        }
        $key = key($input);
        if (is_int($key)) {
            throw new XmlException('The key of input must be alphanumeric');
        }

        return (new static($input, $options))->buildXml();
    }

    /**
     * FromArrayBuilder constructor.
     *
     * @param          $input
     * @param   array  $options
     */
    protected function __construct($input, array $options = [])
    {
        $this->input = $input;

        $defaults = [
            'format'   => 'tags',
            'version'  => '1.0',
            'encoding' => mb_internal_encoding(),
            'return'   => 'simplexml',
            'pretty'   => false,
        ];
        $options  += $defaults;

        $this->options = $options;

        $this->dom = new DOMDocument($options['version'], $options['encoding']);
        if ($options['pretty']) {
            $this->dom->formatOutput = true;
        }
    }

    /**
     * @return SimpleXMLElement|DOMDocument
     */
    protected function buildXml()
    {
        $this->addData($this->dom, $this->dom, $this->input, $this->options['format']);

        $return = strtolower($this->options['return']);
        if ($return === 'simplexml' || $return === 'simplexmlelement') {
            return new SimpleXMLElement($this->dom->saveXML());
        }

        return $this->dom;
    }

    /**
     * Recursive method to create childs from array
     *
     * @param   \DOMDocument              $dom     Handler to DOMDocument
     * @param   \DOMDocument|\DOMElement  $node    Handler to DOMElement (child)
     * @param   array                     $data    Array of data to append to the $node.
     * @param   string                    $format  Either 'attributes' or 'tags'. This determines where nested keys go.
     *
     * @return void
     * @throws XmlException
     */
    protected function addData(DOMDocument $dom, $node, &$data, $format): void
    {
        if (empty($data) || !is_array($data)) {
            return;
        }
        foreach ($data as $key => $value) {
            if (!is_string($key)) {
                throw new XmlException('Invalid array');
            }
            $this->addDataItem($dom, $node, $key, $value, $format);
        }
    }

    /**
     * @param   DOMDocument  $dom
     * @param                $node
     * @param                $key
     * @param                $value
     * @param                $format
     */
    protected function addDataItem(DOMDocument $dom, $node, $key, $value, $format): void
    {
        if (is_object($value) && method_exists($value, 'toArray') && is_callable([$value, 'toArray'])) {
            $value = $value->toArray();
        }

        if (!is_array($value)) {
            if (is_bool($value)) {
                $value = (int)$value;
            } elseif ($value === null) {
                $value = '';
            }
            $isNamespace = strpos($key, 'xmlns:');
            if ($isNamespace !== false) {
                /** @psalm-suppress PossiblyUndefinedMethod */
                $node->setAttributeNS('http://www.w3.org/2000/xmlns/', $key, (string)$value);
                return;
            }
            if ($key[0] !== '@' && $format === 'tags') {
                if (!is_numeric($value)) {
                    // Escape special characters
                    // https://www.w3.org/TR/REC-xml/#syntax
                    // https://bugs.php.net/bug.php?id=36795
                    $child = $dom->createElement($key, '');
                    $child->appendChild(new DOMText((string)$value));
                } else {
                    $child = $dom->createElement($key, (string)$value);
                }
                $node->appendChild($child);
            } else {
                if ($key[0] === '@') {
                    $key = substr($key, 1);
                }
                $attribute = $dom->createAttribute($key);
                $attribute->appendChild($dom->createTextNode((string)$value));
                $node->appendChild($attribute);
            }
        } else {
            if ($key[0] === '@') {
                throw new XmlException('Invalid array');
            }
            if (is_numeric(implode('', array_keys($value)))) {
                // List
                foreach ($value as $item) {
                    $itemData          = compact('dom', 'node', 'key', 'format');
                    $itemData['value'] = $item;
                    $this->createChild($itemData);
                }
            } else {
                // Struct
                $this->createChild(compact('dom', 'node', 'key', 'value', 'format'));
            }
        }
    }

    /**
     * Helper to _fromArray(). It will create childs of arrays
     *
     * @param   array  $data  Array with information to create childs
     *
     * @return void
     */
    protected function createChild(array $data): void
    {
        $data += [
            'dom'    => null,
            'node'   => null,
            'key'    => null,
            'value'  => null,
            'format' => null,
        ];

        $value  = $data['value'];
        $dom    = $data['dom'];
        $key    = $data['key'];
        $format = $data['format'];
        $node   = $data['node'];

        $childNS = $childValue = null;
        if (is_object($value) && method_exists($value, 'toArray') && is_callable([$value, 'toArray'])) {
            $value = $value->toArray();
        }
        if (is_array($value)) {
            if (isset($value['@'])) {
                $childValue = (string)$value['@'];
                unset($value['@']);
            }
            if (isset($value['xmlns:'])) {
                $childNS = $value['xmlns:'];
                unset($value['xmlns:']);
            }
        } elseif (!empty($value) || $value === 0 || $value === '0') {
            $childValue = (string)$value;
        }

        $child = $dom->createElement($key);
        if ($childValue !== null) {
            $child->appendChild($dom->createTextNode($childValue));
        }
        if ($childNS) {
            $child->setAttribute('xmlns', $childNS);
        }

        $this->addData($dom, $child, $value, $format);
        $node->appendChild($child);
    }
}

1			<?php
2			/** @noinspection PhpComposerExtensionStubsInspection */
3
4			namespace Nip\Utility\Xml;
5
6			use DOMDocument;
7			use DOMText;
8			use SebastianBergmann\CodeCoverage\XmlException;
			0 ignored issues – show Bug introduced 2020-10-05 13:09 UTC by Report Bug Copy Issue Report The type `SebastianBergmann\CodeCoverage\XmlException` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
9			use SimpleXMLElement;
10
11			/**
12			* Class FromArrayBuilder
13			* @package Nip\Utility\Xml
14			*/
15			class FromArrayBuilder
16			{
17
18			protected $input;
19
20			/**
21			* @var DOMDocument
22			*/
23			protected $dom;
24			protected $options = [];
25
26
27			/**
28			* @param $input
29			* @param array $options
30			*
31			* @return DOMDocument\|SimpleXMLElement
32			*/
33			public static function build($input, array $options = [])
34			{
35			if (is_object($input) && method_exists($input, 'toArray') && is_callable([$input, 'toArray'])) {
36			$input = $input->toArray();
37			}
38			if (!is_array($input) \|\| count($input) !== 1) {
39			throw new XmlException('Invalid input.');
40			}
41			$key = key($input);
42			if (is_int($key)) {
43			throw new XmlException('The key of input must be alphanumeric');
44			}
45
46			return (new static($input, $options))->buildXml();
47			}
48
49			/**
50			* FromArrayBuilder constructor.
51			*
52			* @param $input
53			* @param array $options
54			*/
55			protected function __construct($input, array $options = [])
56			{
57			$this->input = $input;
58
59			$defaults = [
60			'format' => 'tags',
61			'version' => '1.0',
62			'encoding' => mb_internal_encoding(),
63			'return' => 'simplexml',
64			'pretty' => false,
65			];
66			$options += $defaults;
67
68			$this->options = $options;
69
70			$this->dom = new DOMDocument($options['version'], $options['encoding']);
71			if ($options['pretty']) {
72			$this->dom->formatOutput = true;
73			}
74			}
75
76			/**
77			* @return SimpleXMLElement\|DOMDocument
78			*/
79			protected function buildXml()
80			{
81			$this->addData($this->dom, $this->dom, $this->input, $this->options['format']);
82
83			$return = strtolower($this->options['return']);
84			if ($return === 'simplexml' \|\| $return === 'simplexmlelement') {
85			return new SimpleXMLElement($this->dom->saveXML());
86			}
87
88			return $this->dom;
89			}
90
91			/**
92			* Recursive method to create childs from array
93			*
94			* @param \DOMDocument $dom Handler to DOMDocument
95			* @param \DOMDocument\|\DOMElement $node Handler to DOMElement (child)
96			* @param array $data Array of data to append to the $node.
97			* @param string $format Either 'attributes' or 'tags'. This determines where nested keys go.
98			*
99			* @return void
100			* @throws XmlException
101			*/
102			protected function addData(DOMDocument $dom, $node, &$data, $format): void
103			{
104			if (empty($data) \|\| !is_array($data)) {
105			return;
106			}
107			foreach ($data as $key => $value) {
108			if (!is_string($key)) {
109			throw new XmlException('Invalid array');
110			}
111			$this->addDataItem($dom, $node, $key, $value, $format);
112			}
113			}
114
115			/**
116			* @param DOMDocument $dom
117			* @param $node
118			* @param $key
119			* @param $value
120			* @param $format
121			*/
122			protected function addDataItem(DOMDocument $dom, $node, $key, $value, $format): void
123			{
124			if (is_object($value) && method_exists($value, 'toArray') && is_callable([$value, 'toArray'])) {
125			$value = $value->toArray();
126			}
127
128			if (!is_array($value)) {
129			if (is_bool($value)) {
130			$value = (int)$value;
131			} elseif ($value === null) {
132			$value = '';
133			}
134			$isNamespace = strpos($key, 'xmlns:');
135			if ($isNamespace !== false) {
136			/** @psalm-suppress PossiblyUndefinedMethod */
137			$node->setAttributeNS('http://www.w3.org/2000/xmlns/', $key, (string)$value);
138			return;
139			}
140			if ($key[0] !== '@' && $format === 'tags') {
141			if (!is_numeric($value)) {
142			// Escape special characters
143			// https://www.w3.org/TR/REC-xml/#syntax
144			// https://bugs.php.net/bug.php?id=36795
145			$child = $dom->createElement($key, '');
146			$child->appendChild(new DOMText((string)$value));
147			} else {
148			$child = $dom->createElement($key, (string)$value);
149			}
150			$node->appendChild($child);
151			} else {
152			if ($key[0] === '@') {
153			$key = substr($key, 1);
154			}
155			$attribute = $dom->createAttribute($key);
156			$attribute->appendChild($dom->createTextNode((string)$value));
157			$node->appendChild($attribute);
158			}
159			} else {
160			if ($key[0] === '@') {
161			throw new XmlException('Invalid array');
162			}
163			if (is_numeric(implode('', array_keys($value)))) {
164			// List
165			foreach ($value as $item) {
166			$itemData = compact('dom', 'node', 'key', 'format');
167			$itemData['value'] = $item;
168			$this->createChild($itemData);
169			}
170			} else {
171			// Struct
172			$this->createChild(compact('dom', 'node', 'key', 'value', 'format'));
173			}
174			}
175			}
176
177			/**
178			* Helper to _fromArray(). It will create childs of arrays
179			*
180			* @param array $data Array with information to create childs
181			*
182			* @return void
183			*/
184			protected function createChild(array $data): void
185			{
186			$data += [
187			'dom' => null,
188			'node' => null,
189			'key' => null,
190			'value' => null,
191			'format' => null,
192			];
193
194			$value = $data['value'];
195			$dom = $data['dom'];
196			$key = $data['key'];
197			$format = $data['format'];
198			$node = $data['node'];
199
200			$childNS = $childValue = null;
201			if (is_object($value) && method_exists($value, 'toArray') && is_callable([$value, 'toArray'])) {
202			$value = $value->toArray();
203			}
204			if (is_array($value)) {
205			if (isset($value['@'])) {
206			$childValue = (string)$value['@'];
207			unset($value['@']);
208			}
209			if (isset($value['xmlns:'])) {
210			$childNS = $value['xmlns:'];
211			unset($value['xmlns:']);
212			}
213			} elseif (!empty($value) \|\| $value === 0 \|\| $value === '0') {
214			$childValue = (string)$value;
215			}
216
217			$child = $dom->createElement($key);
218			if ($childValue !== null) {
219			$child->appendChild($dom->createTextNode($childValue));
220			}
221			if ($childNS) {
222			$child->setAttribute('xmlns', $childNS);
223			}
224
225			$this->addData($dom, $child, $value, $format);
226			$node->appendChild($child);
227			}
228			}

bytic / utility

Push — master ( cb02e9...c4035d )

FromArrayBuilder::addDataItem() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like