DecoderWorker::decode() - Code Metrics - derafu/derafu-lib-core - Measure and Improve Code Quality continuously with Scrutinizer

DecoderWorker::decode() B
last analyzed 2025-01-31 20:08 UTC

↳ Parent: DecoderWorker
Complexity

Conditions	7
Paths	18
Size

Total Lines	47
Code Lines	19
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	22
CRAP Score	7
Importance

Changes
Metric	Value
cc	7
eloc	19
c	0
b	0
f	0
nc	18
nop	3
dl	0
loc	47
ccs	22
cts	22
cp	1
crap	7
rs	8.8333
<?php

declare(strict_types=1);

/**
 * Derafu: Biblioteca PHP (Núcleo).
 * Copyright (C) Derafu <https://www.derafu.org>
 *
 * Este programa es software libre: usted puede redistribuirlo y/o modificarlo
 * bajo los términos de la Licencia Pública General Affero de GNU publicada por
 * la Fundación para el Software Libre, ya sea la versión 3 de la Licencia, o
 * (a su elección) cualquier versión posterior de la misma.
 *
 * Este programa se distribuye con la esperanza de que sea útil, pero SIN
 * GARANTÍA ALGUNA; ni siquiera la garantía implícita MERCANTIL o de APTITUD
 * PARA UN PROPÓSITO DETERMINADO. Consulte los detalles de la Licencia Pública
 * General Affero de GNU para obtener una información más detallada.
 *
 * Debería haber recibido una copia de la Licencia Pública General Affero de GNU
 * junto a este programa.
 *
 * En caso contrario, consulte <http://www.gnu.org/licenses/agpl.html>.
 */

namespace Derafu\Lib\Core\Package\Prime\Component\Xml\Worker;

use Derafu\Lib\Core\Foundation\Abstract\AbstractWorker;
use Derafu\Lib\Core\Package\Prime\Component\Xml\Contract\DecoderWorkerInterface;
use Derafu\Lib\Core\Package\Prime\Component\Xml\Contract\XmlInterface;
use DOMElement;
use DOMNodeList;
use DOMText;

/**
 * Clase que crea un arreglo PHP a partir de un documento XML.
 */
class DecoderWorker extends AbstractWorker implements DecoderWorkerInterface
{
    /**
     * {@inheritDoc}
     */
    public function decode(
        XmlInterface|DOMElement $documentElement,
        ?array &$data = null,
        bool $twinsAsArray = false
    ): array {
        // Si no viene un tagElement se busca uno, si no se obtiene se termina
        // la generación.
        $tagElement = $documentElement instanceof DOMElement
            ? $documentElement
            : $documentElement->getDocumentElement()
        ;
        if ($tagElement === null) {
            return [];
        }

        // Índice en el arreglo que representa al tag. Además es un nombre de
        // variable más corto :)
        $key = $tagElement->tagName;

        // Si no hay un arreglo de destino para los datos se crea un arreglo
        // con el índice del nodo principal con valor vacío.
        if ($data === null) {
            //$data = [$key => self::getEmptyValue()];
            $data = [$key => null];
        }

        // Si el tagElement tiene atributos se agregan al arreglo dentro del
        // índice especial '@attributes'.
        if ($tagElement->hasAttributes()) {
            $data[$key]['@attributes'] = [];
            foreach ($tagElement->attributes as $attribute) {
                $data[$key]['@attributes'][$attribute->name] = $attribute->value;
            }
        }

        // Si el tagElement tiene nodos hijos se agregan al valor del tag.
        if ($tagElement->hasChildNodes()) {
            self::arrayAddChilds(
                  arrayAddChilds(
                $data,
                $tagElement,
                $tagElement->childNodes,
                $twinsAsArray
            );
        }

        // Entregar los datos del documento XML como un arreglo.
        return $data;
    }

    /**
     * Agrega nodos hijos de un documento XML a un arreglo PHP.
     *
     * @param array &$data Arreglo donde se agregarán los nodos hijos.
     * @param DOMElement $tagElement Nodo padre del que se extraerán los nodos
     * hijos.
     * @param DOMNodeList $childs Lista de nodos hijos del nodo padre.
     * @param bool $twinsAsArray Indica si se deben tratar los nodos gemelos
     * como un arreglo.
     * @return void
     */
    private function arrayAddChilds(
        array &$data,
        DOMElement $tagElement,
        DOMNodeList $childs,
        bool $twinsAsArray,
    ): void {
        $key = $tagElement->tagName;
        // Se recorre cada uno de los nodos hijos.
        foreach ($childs as $child) {
            if ($child instanceof DOMText) {
                $textContent = trim($child->textContent);
                if ($textContent !== '') {
                    if ($tagElement->hasAttributes()) {
                        $data[$key]['@value'] = $textContent;
                    } elseif ($childs->length === 1 && empty($data[$key])) {
                        $data[$key] = $textContent;
                    } else {
                        $array[$key]['@value'] = $textContent;
                    }
                }
            } elseif ($child instanceof DOMElement) {
                $n_twinsNodes = self::nodeCountTwins(
                $n_twinsNodes = self::nodeCountTwins(
                    $tagElement,
                    $child->tagName
                );
                if ($n_twinsNodes === 1) {
                    if ($twinsAsArray) {
                        self::decode($child, $data);
                              decode($child, $data);
                    } else {
                        self::decode($child, $data[$key]);
                    }
                } else {
                    // Se crea una lista para el nodo hijo, pues tiene varios
                    // nodos iguales el XML.
                    if (!isset($data[$key][$child->tagName])) {
                        $data[$key][$child->tagName] = [];
                    }

                    // Se revisa si el nodo hijo es escalar. Si lo es, se añade
                    // a la lista directamente.
                    $textContent = trim($child->textContent);
                    if ($textContent !== '') {
                        $data[$key][$child->tagName][] = $textContent;
                    }
                    // Si el nodo hijo es un escalar, sino que es una lista de
                    // nodos, se construye como si fuese un arreglo normal con
                    // la llamada a decode().
                    else {
                        $siguiente = count($data[$key][$child->tagName]);
                        $data[$key][$child->tagName][$siguiente] = [];
                        self::decode(
                            $child,
                            $data[$key][$child->tagName][$siguiente],
                            true
                        );
                    }
                }
            }
        }
    }

    /**
     * Cuenta los nodos con el mismo nombre hijos de un DOMElement.
     *
     * @param DOMElement $dom Elemento DOM donde se buscarán los nodos.
     * @param string $tagName Nombre del tag a contar.
     * @return int Cantidad de nodos hijos con el mismo nombre.
     */
    private function nodeCountTwins(DOMElement $dom, string $tagName): int
    {
        $twins = 0;
        foreach ($dom->childNodes as $child) {
            if ($child instanceof DOMElement && $child->tagName === $tagName) {
                $twins++;
            }
        }

        return $twins;
    }
}

derafu / derafu-lib-core

DecoderWorker::decode() B last analyzed 2025-01-31 20:08 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

DecoderWorker::decode() B
last analyzed 2025-01-31 20:08 UTC
