Kinedu\CfdiXML\Common\Node

Complexity

Total Complexity

34

Size/Duplication

Total Lines	293
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	2
C	add()	0	63	10
A	getDirectChildElementByName()	0	10	3
B	setNamespace()	0	30	6
A	setSchemaDefinition()	0	15	2
A	hasOutstandingReferences()	0	4	1
A	getAttr()	0	10	2
A	setAttr()	0	8	3
A	getElement()	0	4	1
A	getDocument()	0	4	1
A	getWrapperNodeName()	0	4	1
A	getParentNodeName()	0	4	1
A	getNodeName()	0	4	1

<?php

/*
 * This file is part of the cfdi-xml project.
 *
 * (c) Kinedu
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Kinedu\CfdiXML\Common;

use DOMElement;
use DOMDocument;
use DOMNodeList;

class Node
{
    /**
     * Node document.
     *
     * @var DOMDocument
     */
    protected $document;

    /**
     * Node element.
     *
     * @var DOMElement
     */
    protected $element;

    /**
     * Define the parent node name.
     *
     * @var string|null
     */
    protected $parentNodeName = null;

    /**
     * Define the node name.
     *
     * @var string
     */
    protected $nodeName;

    /**
     * Node attributes.
     *
     * @var array
     */
    protected $attr = [];

    protected $outstandingReferences;

    /**
     * Create a new node instance.
     *
     * @param array $attr
     */
    public function __construct(array ...$attr)
    {
        $this->attr = $attr;

        $this->document = new DOMDocument('1.0', 'UTF-8');
        $this->document->preserveWhiteSpace = false;

        if ($nodeName = $this->getNodeName()) {
            $this->element = $this->document->createElement($nodeName);
            $this->document->appendChild($this->element);
            $this->setAttr($this->element, $this->getAttr());
        }
    }

    /**
     * Add a new node.
     *
     * @param \Kinedu\CfdiXML\Common\Node $node
     *
     * @return void
     */
    public function add(Node $node)
    {
        $wrapperElement = null;

        if ($node->hasOutstandingReferences()) {
            $schemaDefinition = $node->outstandingReferences['schema_definition'];
            $namespace = $node->outstandingReferences['namespace'];

            $this->setSchemaDefinition($schemaDefinition);

It seems like $schemaDefinition defined by $node->outstandingReferences['schema_definition'] on line 88 can also be of type object<Kinedu\CfdiXML\Common\Node>; however, Kinedu\CfdiXML\Common\Node::setSchemaDefinition() does only seem to accept string, maybe add an additional type check?

            $this->setNamespace($namespace);

It seems like $namespace defined by $node->outstandingReferences['namespace'] on line 89 can also be of type string; however, Kinedu\CfdiXML\Common\Node::setNamespace() does only seem to accept object<Kinedu\CfdiXML\Common\Node>, maybe add an additional type check?

        }

        if (isset($node->schemaDefinition) && $node->globalSchemaLocation) {

The property globalSchemaLocation does not exist. Did you maybe forget to declare it?

            $this->setSchemaDefinition(
                $node->getSchemaLocation()

It seems like you code against a specific sub-type and not the parent class Kinedu\CfdiXML\Common\Node as the method getSchemaLocation() does only exist in the following sub-classes of Kinedu\CfdiXML\Common\Node: Kinedu\CfdiXML\Common\Complemento, Kinedu\CfdiXML\Common\ComplementoBase, Kinedu\CfdiXML\Common\ComplementoConcepto, Kinedu\CfdiXML\Common\Complemento\IEDU, Kinedu\CfdiXML\Common\Complemento\Pago, Kinedu\CfdiXML\Common\Complemento\TimbreFiscalDigital. Maybe you want to instanceof check for one of these explicitly?

            );

            $this->setNamespace($node);
        }

        $nodeElement = $this->document->createElement($node->getNodeName());
        $this->setAttr($nodeElement, $node->getAttr());

        foreach ($node->element->childNodes as $child) {
            $nodeElement->appendChild(
                $this->document->importNode($child, true)
            );
        }

        if ($wrapperName = $node->getWrapperNodeName()) {
            $wrapperElement = $this->getDirectChildElementByName(
                $this->element->childNodes,
                $wrapperName
            );

            if (!$wrapperElement) {
                $wrapperElement = $this->document->createElement($wrapperName);
                $this->element->appendChild($wrapperElement);
            }

            $this->setAttr($wrapperElement, $node->getAttr('wrapper'));
        }

        if ($parentName = $node->getParentNodeName()) {
            $currentElement = ($wrapperElement) ? $wrapperElement : $this->element;

            $parentNode = $this->getDirectChildElementByName(
                $currentElement->childNodes,
                $parentName
            );

            if (!$parentNode) {
                $parentElement = $this->document->createElement($parentName);
                $currentElement->appendChild($parentElement);
                $parentElement->appendChild($nodeElement);
                $this->setAttr($parentElement, $node->getAttr('parent'));
            } else {
                $parentNode->appendChild($nodeElement);
            }
        } else {
            $this->element->appendChild($nodeElement);
        }
    }

    /**
     * Search the direct child of an element.
     *
     * @param DOMNodeList $children
     * @param string $find
     *
     * @return DOMElement|null
     */
    protected function getDirectChildElementByName(DOMNodeList $children, string $find)
    {
        foreach ($children as $child) {
            if ($child->nodeName == $find) {
                return $child;
            }
        }

        return null;
    }

    /**
     * @param  \Kinedu\CfdiXML\Common\Node  $node
     * @return void
     */
    public function setNamespace(Node $node)
    {
        $element = $this->element;

        if ($element->tagName == 'cfdi:Comprobante') {
            $namespaceKey = "xmlns:{$node->namespaceKey}";

The property namespaceKey does not exist. Did you maybe forget to declare it?

            $namespaceValue = $node->getNamespace();

It seems like you code against a specific sub-type and not the parent class Kinedu\CfdiXML\Common\Node as the method getNamespace() does only exist in the following sub-classes of Kinedu\CfdiXML\Common\Node: Kinedu\CfdiXML\Common\Complemento, Kinedu\CfdiXML\Common\ComplementoBase, Kinedu\CfdiXML\Common\ComplementoConcepto, Kinedu\CfdiXML\Common\Complemento\IEDU, Kinedu\CfdiXML\Common\Complemento\Pago, Kinedu\CfdiXML\Common\Complemento\TimbreFiscalDigital. Maybe you want to instanceof check for one of these explicitly?

            $elementAttr = [];

            if ($element->hasAttributes()) {
                $lastAttrName = null;

                foreach (iterator_to_array($element->attributes) as $attr) {
                    if ((substr($lastAttrName, 0, 5) == 'xmlns') &&
                        (substr($attr->name, 0, 5) != 'xmlns')) {
                        $elementAttr[$namespaceKey] = $namespaceValue;
                    }

                    $elementAttr[$lastAttrName = $attr->name] = $attr->value;

                    $element->removeAttributeNode($attr);
                }
            }

            $this->setAttr($element, $elementAttr);
        } else {
            $this->outstandingReferences['namespace'] = $node;
        }
    }

    /**
     * @param  string  $schemaDefinition
     * @return void
     */
    public function setSchemaDefinition(string $schemaDefinition)
    {
        $attrName = 'xsi:schemaLocation';

        $node = $this->element;

        if ($node->hasAttribute($attrName)) {
            $value = $node->getAttribute($attrName);
            $value = "{$value} {$schemaDefinition}";

            $node->setAttribute($attrName, $value);
        } else {
            $this->outstandingReferences['schema_definition'] = $schemaDefinition;
        }
    }

    private function hasOutstandingReferences(): bool
    {
        return !! $this->outstandingReferences;
    }

    /**
     * Get node attributes.
     *
     * @param string $index
     *
     * @return array|null
     */
    public function getAttr(string $index = 'node')
    {
        $attrIndex = ['node', 'parent', 'wrapper'];

        $index = (in_array($index, $attrIndex))
            ? array_search($index, $attrIndex)
            : 0;

        return $this->attr[$index] ?? null;
    }

    /**
     * Adds attributes to an element.
     *
     * @param DOMElement $element
     * @param array $attr
     *
     * @return void
     */
    public function setAttr(DOMElement $element, array $attr = null)
    {
        if (!is_null($attr)) {
            foreach ($attr as $key => $value) {
                $element->setAttribute($key, $value);
            }
        }
    }

    /**
     * Get element.
     *
     * @return DOMElement
     */
    public function getElement(): DOMElement
    {
        return $this->element;
    }

    /**
     * Get document.
     *
     * @return DOMDocument
     */
    public function getDocument(): DOMDocument
    {
        return $this->document;
    }

    /**
     * Get wrapper node name.
     *
     * @return string|null
     */
    public function getWrapperNodeName()
    {
        return $this->wrapperNodeName ?? null;

The property wrapperNodeName does not seem to exist. Did you mean nodeName?

    }

    /**
     * Get parent node name.
     *
     * @return string|null
     */
    public function getParentNodeName()
    {
        return $this->parentNodeName ?? null;
    }

    /**
     * Get node name.
     *
     * @return string
     */
    public function getNodeName()
    {
        return $this->nodeName ?? null;
    }
}