QPXML::createElement() - Code Metrics - arthurkushman/querypath - Measure and Improve Code Quality continuously with Scrutinizer

QPXML::createElement() B
last analyzed 2022-03-28 08:12 UTC

↳ Parent: QPXML
Complexity

Conditions	7
Paths	7
Size

Total Lines	28
Code Lines	16
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	7
eloc	16
nc	7
nop	2
dl	0
loc	28
rs	8.8333
c	0
b	0
f	0
<?php
/** @file
 * XML extensions. See QPXML.
 */

namespace QueryPath\Extension;

use QueryPath\DOMQuery;
use QueryPath\QueryPath;
use QueryPath\Extension;

/**
 * Provide QueryPath with additional XML tools.
 *
 * @author  M Butcher <[email protected]>
 * @author  Xander Guzman <[email protected]>
 * @license MIT
 * @see     QueryPath::Extension
 * @see     QueryPath::ExtensionRegistry::extend()
 * @see     QPXML
 * @ingroup querypath_extensions
 */
class QPXML implements Extension
{

    protected $qp;

    public function __construct(\QueryPath\Query $qp)
    {
        $this->qp = $qp;
    }

    public function schema($file)
    {
        $doc = $this->qp->branch()->top()->get(0)->ownerDocument;
        $doc = $this->qp->/** @scrutinizer ignore-call */ branch()->top()->get(0)->ownerDocument;

        if (!$doc->schemaValidate($file)) {
            throw new \QueryPath\Exception('Document did not validate against the schema.');
        }
    }

    /**
     * Get or set a CDATA section.
     *
     * If this is given text, it will create a CDATA section in each matched element,
     * setting that item's value to $text.
     *
     * If no parameter is passed in, this will return the first CDATA section that it
     * finds in the matched elements.
     *
     * @param string $text
     *  The text data to insert into the current matches. If this is NULL, then the first
     *  CDATA will be returned.
     *
     * @return mixed
     *  If $text is not NULL, this will return a {@link QueryPath}. Otherwise, it will
     *  return a string. If no CDATA is found, this will return NULL.
     * @see comment()
     * @see QueryPath::text()
     * @see QueryPath::html()
     */
    public function cdata($text = NULL)
    {
        if (isset($text)) {
            // Add this text as CDATA in the current elements.
            foreach ($this->qp->get() as $element) {
            foreach ($this->qp->/** @scrutinizer ignore-call */ get() as $element) {
                $cdata = $element->ownerDocument->createCDATASection($text);
                $element->appendChild($cdata);
            }

            return $this->qp;;
        }

        // Look for CDATA sections.
        foreach ($this->qp->get() as $ele) {
            foreach ($ele->childNodes as $node) {
                if ($node->nodeType === XML_CDATA_SECTION_NODE) {
                    // Return first match.
                    return $node->textContent;
                }
            }
        }

        return NULL;
        // Nothing found
    }

    /**
     * Get or set a comment.
     *
     * This function is used to get or set comments in an XML or HTML document.
     * If a $text value is passed in (and is not NULL), then this will add a comment
     * (with the value $text) to every match in the set.
     *
     * If no text is passed in, this will return the first comment in the set of matches.
     * If no comments are found, NULL will be returned.
     *
     * @param string $text
     *  The text of the comment. If set, a new comment will be created in every item
     *  wrapped by the current {@link QueryPath}.
     * @return mixed
     *  If $text is set, this will return a {@link QueryPath}. If no text is set, this
     *  will search for a comment and attempt to return the string value of the first
     *  comment it finds. If no comment is found, NULL will be returned.
     * @see cdata()
     */
    public function comment($text = NULL)
    {
        if (isset($text)) {
            foreach ($this->qp->get() as $element) {
                $comment = $element->ownerDocument->createComment($text);
                $element->appendChild($comment);
            }

            return $this->qp;
        }
        foreach ($this->qp->get() as $ele) {
            foreach ($ele->childNodes as $node) {
                if ($node->nodeType == XML_COMMENT_NODE) {
                    // Return first match.
                    return $node->textContent;
                }
            }
        }
    }

    /**
     * Get or set a processor instruction.
     */
    public function pi($prefix = NULL, $text = NULL)
    {
        if (isset($text)) {
            foreach ($this->qp->get() as $element) {
                $comment = $element->ownerDocument->createProcessingInstruction($prefix, $text);
                $element->appendChild($comment);
            }

            return $this->qp;
        }
        foreach ($this->qp->get() as $ele) {
            foreach ($ele->childNodes as $node) {
                if ($node->nodeType == XML_PI_NODE) {

                    if (isset($prefix)) {
                        if ($node->tagName == $prefix) {
                            return $node->textContent;
                        }
                    } else {
                        // Return first match.
                        return $node->textContent;
                    }
                }
            } // foreach
        } // foreach
    }

    public function toXml()
    {
        return $this->qp->document()->saveXml();
        return $this->qp->/** @scrutinizer ignore-call */ document()->saveXml();
    }

    /**
     * Create a NIL element.
     *
     * @param string $text
     * @param string $value
     * @reval object $element
     */
    public function createNilElement($text, $value)
    {
        $value = ($value) ? 'true' : 'false';
        $element = $this->qp->createElement($text);
        $element = $this->qp->createElement($text);
        $element->attr('xsi:nil', $value);

        return $element;
    }

    /**
     * Create an element with the given namespace.
     *
     * @param string $text
     * @param string $nsUri
     *   The namespace URI for the given element.
     * @return \QueryPath\DOMQuery
     */
    public function createElement($text, $nsUri = NULL)
    {
        if (isset ($text)) {
            foreach ($this->qp->get() as $element) {
                if ($nsUri === NULL && strpos($text, ':') !== false) {
                    $ns = array_shift(explode(':', $text));
                    $ns = array_shift(/** @scrutinizer ignore-type */ explode(':', $text));
                    $nsUri = $element->ownerDocument->lookupNamespaceURI($ns);

                    if ($nsUri === NULL) {
                        throw new \QueryPath\Exception("Undefined namespace for: " . $text);
                    }
                }

                $node = NULL;
                if ($nsUri !== NULL) {
                    $node = $element->ownerDocument->createElementNS(
                        $nsUri,
                        $text
                    );
                } else {
                    $node = $element->ownerDocument->createElement($text);
                }

                return QueryPath::with($node);
            }
        }

        return new DOMQuery();
    }

    /**
     * Append an element.
     *
     * @param string $text
     * @return \QueryPath\DOMQuery
     */
    public function appendElement($text)
    {
        if (isset ($text)) {
            foreach ($this->qp->get() as $element) {
                $node = $this->qp->createElement($text);
                QueryPath::with($element)->append($node);
            }
        }

        return $this->qp;
    }
}

arthurkushman / querypath

QPXML::createElement() B last analyzed 2022-03-28 08:12 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

QPXML::createElement() B
last analyzed 2022-03-28 08:12 UTC
