Vyuldashev\XmlToArray\XmlToArray

Complexity

Total Complexity

19

Size/Duplication

Total Lines	97
Duplicated Lines	0 %

Importance

Changes	5
Bugs	2	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	convertAttributes()	0	14	3
A	convert()	0	5	1
A	toArray()	0	13	3
B	convertDomElement()	0	49	11

<?php

declare(strict_types=1);

namespace Vyuldashev\XmlToArray;

use DOMAttr;
use DOMCdataSection;
use DOMDocument;
use DOMElement;
use DOMNamedNodeMap;
use DOMText;

class XmlToArray
{
    protected $document;

    public function __construct(string $xml)
    {
        $this->document = new DOMDocument();
        $this->document->loadXML($xml);
    }

    public static function convert(string $xml): array
    {
        $converter = new static($xml);

        return $converter->toArray();
    }

    protected function convertAttributes(DOMNamedNodeMap $nodeMap): ?array
    {
        if ($nodeMap->length === 0) {
            return null;
        }

        $result = [];

        /** @var DOMAttr $item */
        foreach ($nodeMap as $item) {
            $result[$item->name] = $item->value;
        }

        return ['_attributes' => $result];
    }

    protected function convertDomElement(DOMElement $element)
    {
        $sameNames = [];
        $result = $this->convertAttributes($element->attributes);

It seems like $element->attributes can also be of type null; however, parameter $nodeMap of Vyuldashev\XmlToArray\XmlToArray::convertAttributes() does only seem to accept DOMNamedNodeMap, maybe add an additional type check?

        // Creates an index which counts each key, starting at zero, e.g. ['foo' => 2, 'bar' => 0]
        $childNodeNames = [];

The assignment to $childNodeNames is dead and can be removed.

        foreach ($element->childNodes as $key => $node) {
            if (array_key_exists($node->nodeName, $sameNames)) {
                $sameNames[$node->nodeName] += 1;
            } else {
                $sameNames[$node->nodeName] = 0;
            }
        }

        foreach ($element->childNodes as $key => $node) {
            if (is_null($result)) {
                $result = [];
            }

            if ($node instanceof DOMCdataSection) {
                $result['_cdata'] = $node->data;

                continue;
            }
            if ($node instanceof DOMText) {
                if (empty($result)) {
                    $result = $node->textContent;
                } else {
                    $result['_value'] = $node->textContent;
                }
                continue;
            }
            if ($node instanceof DOMElement) {
                if ($sameNames[$node->nodeName]) { // Truthy — When $sameNames['foo'] > 0
                    if (!array_key_exists($node->nodeName, $result)) { // Setup $result['foo']
                        $result[$node->nodeName] = [];
                    }

                    $result[$node->nodeName][$key] = $this->convertDomElement($node); // Store as $result['foo'][*]
                } else {
                    $result[$node->nodeName] = $this->convertDomElement($node); // Store as $result['foo']
                }

                continue;
            }
        }

        return $result;
    }

    public function toArray(): array
    {
        $result = [];

        if ($this->document->hasChildNodes()) {
            $children = $this->document->childNodes;

            foreach ($children as $child) {
                $result[$child->nodeName] = $this->convertDomElement($child);
            }
        }

        return $result;
    }
}