Derafu\Lib\Core\Package\Prime\Component\Xml\Worker\EncoderWorker::encode()

Complexity

Conditions	12
Paths	40

Size

Total Lines	80
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	31
CRAP Score	12

Importance

Changes

0

<?php
    public function encode(
        array $data,
        ?array $namespace = null,
        ?DOMElement $parent = null,
        ?Xml $doc = null
    ): Xml {
        // Si no hay un documento XML completo (desde raíz, no vale un nodo),
        // entonces se crea, pues se necesitará para crear los futuros nodos.
        if ($doc === null) {
            $doc = new Xml();
        }

        // Si no hay un elemento padre, entonces se está pidiendo crear el
        // documento XML desde 0 (desde el nodo raíz).
        if ($parent === null) {
            $parent = $doc;
        }

        // Iterar el primer nivel del arreglo para encontrar los tags que se
        // deben agregar al documento XML.
        foreach ($data as $key => $value) {

            // Si el índice es '@attributes' entonces el valor de este índice
            // es un arreglo donde la llave es el nombre del atributo del tag
            // de $parent y el valor es el valor del atributo.
            if ($key === '@attributes') {
                // Solo se agregan atributos si el valor es un arreglo.
                if (is_array($value)) {
                    // En la primera iteración de recursividad se debe revisar
                    // que $parent sea DOMElement. Y solo en ese caso seguir.
                    if ($parent instanceof DOMElement) {
                        $this->nodeAddAttributes($parent, $value);
                    }
                }
            }

            // Si el índice es '@value' entonces se debe asignar directamente
            // el valor al nodo, pues es un escalar (no un arreglo con nodos
            // hijos). Este caso normalmente se usa cuando se crea un nodo que
            // debe tener valor y atributos.
            elseif ($key === '@value') {
                if (!$this->skipValue($value)) {
                    $parent->nodeValue = XmlUtil::sanitize($value);
                }
            }

            // Acá el índice es el nombre de un nodo. En este caso, el nodo es
            // un arreglo. Por lo que se procesará recursivamente para agregar
            // a este nodo los nodos hijos que están en el arreglo.
            elseif (is_array($value)) {
                // Solo se crea el nodo si tiene nodos hijos. El nodo no será
                // creado si se pasa un arreglo vacio (sin hijos).
                if (!empty($value)) {
                    $this->nodeAddChilds(
                        $doc,
                        $parent,
                        $key,
                        $value,
                        $namespace
                    );
                }
            }

            // El nodo es un escalar (no es un arreglo, no son nodos hijos).
            // Por lo que se crea el nodo y asigna el valor directamente.
            else {
                if (!$this->skipValue($value)) {
                    $this->nodeAddValue(
                        $doc,
                        $parent,
                        $key,
                        (string) $value,
                        $namespace
                    );
                }
            }
        }

        // Entregar el documento XML generado.
        return $doc;
    }