Sulao\HtmlQuery\HtmlQuery

Complexity

Total Complexity

53

Size/Duplication

Total Lines	498
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	appendTo()	0	5	1
A	html()	0	7	2
A	insertBefore()	0	5	1
A	after()	0	16	3
A	text()	0	7	2
A	wrapAll()	0	17	3
A	setHtml()	0	13	2
A	__construct()	0	4	1
A	unwrapSelf()	0	12	3
A	before()	0	12	3
A	unwrap()	0	3	1
A	replaceAll()	0	5	1
A	setText()	0	4	1
A	outerHtml()	0	4	1
A	append()	0	11	2
A	getText()	0	4	1
A	remove()	0	13	3
A	replaceWith()	0	26	5
A	prependTo()	0	5	1
A	empty()	0	4	1
A	wrap()	0	24	4
A	insertAfter()	0	5	1
A	wrapInner()	0	28	5
A	getHtml()	0	9	2
A	prepend()	0	16	3

<?php

namespace Sulao\HtmlQuery;

use DOMDocument;
use DOMNode, DOMNodeList;

/**
 * Class HtmlQuery
 *
 * @package Sulao\HtmlQuery
 */
class HtmlQuery extends Attribute
{
    const VERSION = '1.0.0';
    /**
     * HtmlQuery constructor.
     *
     * @param DOMDocument                   $doc
     * @param DOMNode|DOMNode[]|DOMNodeList $nodes
     *
     * @throws Exception
     */
    public function __construct(DOMDocument $doc, $nodes)
    {
        $this->doc = $doc;
        $this->nodes = $this->validateNodes($nodes);
    }

    /**
     * Get the outer HTML contents of the first matched node.
     *
     * @return string|null
     */
    public function outerHtml()
    {
        return $this->mapFirst(function (DOMNode $node) {
            return $this->doc->saveHTML($node);
        });
    }

    /**
     * Get the inner HTML contents of the first matched node or
     * set the inner HTML contents of every matched node.
     *
     * @param string|null $html
     *
     * @return string|null|static
     */
    public function html(?string $html = null)
    {
        if (!is_null($html)) {
            return $this->setHtml($html);
        }

        return $this->getHtml();
    }

    /**
     * Get the inner HTML contents of the first matched node.
     *
     * @return string|null
     */
    public function getHtml()
    {
        return $this->mapFirst(function (DOMNode $node) {
            $content = '';
            foreach (iterator_to_array($node->childNodes) as $childNode) {
                $content .= $this->doc->saveHTML($childNode);
            }

            return $content;
        });
    }

    /**
     * Set the inner HTML contents of every matched node.
     *
     * @param string $html
     *
     * @return static
     */
    public function setHtml(string $html)
    {
        $this->empty();

        $this->each(function (DOMNode $node) {
            $node->nodeValue = '';
        });

        if ($html !== '') {
            $this->append($html);
        }

        return $this;
    }

    /**
     * Get the combined text contents of the first matched node, including
     * it's descendants, or set the text contents of every matched node.
     *
     * @param string|null $text
     *
     * @return string|null|static
     */
    public function text(?string $text = null)
    {
        if (!is_null($text)) {
            return $this->setText($text);
        }

        return $this->getText();
    }

    /**
     * Get the combined text contents of the first matched node,
     * including it's descendants.
     *
     * @return string|null
     */
    public function getText()
    {
        return $this->mapFirst(function (DOMNode $node) {
            return $node->textContent;
        });
    }

    /**
     * set the text contents of every matched node.
     *
     * @param string $text
     *
     * @return static
     */
    public function setText(string $text)
    {
        return $this->each(function (DOMNode $node) use ($text) {
            return $node->nodeValue = $text;
        });
    }

    /**
     * Remove all child nodes of all matched nodes from the DOM.
     *
     * @return static
     */
    public function empty()
    {
        return $this->each(function (DOMNode $node) {
            $node->nodeValue = '';
        });
    }

    /**
     * Remove the matched nodes from the DOM.
     * optionally filtered by a selector.
     *
     * @param string|null $selector
     *
     * @return static
     */
    public function remove(?string $selector = null)
    {
        if (!is_null($selector)) {
            $this->filter($selector)->remove();
        } else {
            $this->each(function (DOMNode $node) {
                if ($node->parentNode) {
                    $node->parentNode->removeChild($node);
                }
            });
        }

        return $this;
    }

    /**
     * Insert content or node(s) before each matched node.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function before($content)
    {
        $content = $this->contentResolve($content);

        return $this->each(function (DOMNode $node, $index) use ($content) {
            $content->each(function (DOMNode $newNode) use ($node, $index) {
                if ($node->parentNode) {
                    $newNode = $index !== $this->count() - 1
                        ? $newNode->cloneNode(true)
                        : $newNode;

                    $node->parentNode->insertBefore($newNode, $node);
                }
            });
        });
    }

    /**
     * Insert every matched node before the target.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $selector
     *
     * @return static
     */
    public function insertBefore($selector)
    {
        $target = $this->targetResolve($selector);

        return $target->before($this);
    }

    /**
     * Insert content or node(s) after each matched node.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function after($content)
    {
        $content = $this->contentResolve($content);

        return $this->each(function (HtmlQuery $node, $index) use ($content) {
            $content->each(function (DOMNode $newNode) use ($node, $index) {
                $newNode = $index !== $this->count() - 1
                    ? $newNode->cloneNode(true)
                    : $newNode;

                if ($node->next()->count()) {
                    $node->next()->before($newNode);
                } else {
                    $node->parent()->append($newNode);
                }
            }, true);
        });
    }

    /**
     * Insert every matched node after the target.
     *
     * @param string|DOMNode|DOMNode[]DOMNodeList|static $selector
     *
     * @return static
     */
    public function insertAfter($selector)
    {
        $target = $this->targetResolve($selector);

        return $target->after($this);
    }

    /**
     * Insert content or node(s) to the end of every matched node.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function append($content)
    {
        $content = $this->contentResolve($content);

        return $this->each(function (DOMNode $node, $index) use ($content) {
            $content->each(function (DOMNode $newNode) use ($node, $index) {
                $newNode = $index !== $this->count() - 1
                    ? $newNode->cloneNode(true)
                    : $newNode;

                $node->appendChild($newNode);
            });
        });
    }

    /**
     * Insert every matched node to the end of the target.
     *
     * @param string|DOMNode|DOMNode[]DOMNodeList|static $selector
     *
     * @return static
     */
    public function appendTo($selector)
    {
        $target = $this->targetResolve($selector);

        return $target->append($this);
    }

    /**
     * Insert content or node(s) to the beginning of each matched node.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function prepend($content)
    {
        $content = $this->contentResolve($content);

        return $this->each(function (DOMNode $node, $index) use ($content) {
            $content->each(function (DOMNode $newNode) use ($node, $index) {
                $newNode = $index !== $this->count() - 1
                    ? $newNode->cloneNode(true)
                    : $newNode;

                if ($node->firstChild) {
                    $node->insertBefore($newNode, $node->firstChild);
                } else {
                    $node->appendChild($newNode);
                }
            }, true);
        });
    }

    /**
     * Insert every matched node to the beginning of the target.
     *
     * @param string|DOMNode|DOMNode[]DOMNodeList|static $selector
     *
     * @return static
     */
    public function prependTo($selector)
    {
        $target = $this->targetResolve($selector);

        return $target->prepend($this);
    }

    /**
     * Replace each matched node with the provided new content or node(s)
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function replaceWith($content)
    {
        $content = $this->contentResolve($content);
        return $this->each(function (DOMNode $node, $index) use ($content) {
            if (!$node->parentNode) {
                return;
            }

            $len = $content->count();
            $content->each(
                function (DOMNode $newNode) use ($node, $index, $len) {
                    $newNode = $index !== $this->count() - 1
                        ? $newNode->cloneNode(true)
                        : $newNode;

                    if ($len === 1) {
                        $node->parentNode->replaceChild($newNode, $node);
                    } else {
                        $this->resolve($newNode)->insertAfter($node);
                    }
                },
                true
            );

            if ($len !== 1) {
                $node->parentNode->removeChild($node);
            }
        });
    }

    /**
     * Replace each target node with the matched node(s)
     *
     * @param string|DOMNode|DOMNode[]DOMNodeList|static $selector
     *
     * @return static
     */
    public function replaceAll($selector)
    {
        $target = $this->targetResolve($selector);

        return $target->replaceWith($this);
    }

    /**
     * Wrap an HTML structure around each matched node.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function wrap($content)
    {
        $content = $this->contentResolve($content);
        $newNode = $content[0];

        if (empty($newNode)) {
            return $this;
        }

        $newNode = $content[0];

        return $this->each(function (DOMNode $node, $index) use ($newNode) {
            $newNode = $index !== $this->count() - 1
                ? $newNode->cloneNode(true)

The method cloneNode() does not exist on null.

                : $newNode;

            $nodes = $this->xpathQuery('descendant::*[last()]', $newNode);
            if (!$nodes) {
                throw new Exception('Invalid wrap html format.');
            }

            $deepestNode = end($nodes);
            $node->parentNode->replaceChild($newNode, $node);

It seems like $newNode can also be of type null; however, parameter $newnode of DOMNode::replaceChild() does only seem to accept DOMNode, maybe add an additional type check?

            $deepestNode->appendChild($node);
        });
    }

    /**
     * Wrap an HTML structure around the content of each matched node.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function wrapInner($content)
    {
        $content = $this->contentResolve($content);
        $newNode = $content[0];

        if (empty($newNode)) {
            return $this;
        }

        return $this->each(function (DOMNode $node, $index) use ($newNode) {
            $newNode = $index !== $this->count() - 1
                ? $newNode->cloneNode(true)
                : $newNode;

            $nodes = $this->xpathQuery('descendant::*[last()]', $newNode);
            if (!$nodes) {
                throw new Exception('Invalid wrap html format.');
            }

            $deepestNode = end($nodes);

            // Can't loop $this->node->childNodes directly to append child,
            // Because childNodes will change once appending child.
            foreach (iterator_to_array($node->childNodes) as $childNode) {
                $deepestNode->appendChild($childNode);
            }

            $node->appendChild($newNode);
        });
    }

    /**
     * Wrap an HTML structure around all matched nodes.
     *
     * @param string|DOMNode|DOMNode[]|DOMNodeList|static $content
     *
     * @return static
     */
    public function wrapAll($content)
    {
        $content = $this->contentResolve($content);
        if (!$content->count()) {
            return $this;
        }

        $newNode = $content[0];
        $this->each(function (DOMNode $node, $index) use ($newNode) {
            if ($index === 0) {
                $this->resolve($node)->wrap($newNode);
            } else {
                $this->nodes[0]->parentNode->appendChild($node);
            }
        });

        return $this;
    }

    /**
     * Remove the parents of the matched nodes from the DOM.
     * A optional selector to check the parent node against.
     *
     * @param string|null $selector
     *
     * @return static
     */
    public function unwrap(?string $selector = null)
    {
        return $this->parent($selector)->unwrapSelf();
    }

    /**
     * Remove the HTML tag of the matched nodes from the DOM.
     * Leaving the child nodes in their place.
     *
     * @return static
     */
    public function unwrapSelf()
    {
        return $this->each(function (DOMNode $node) {
            if (!$node->parentNode) {
                return;
            }

            foreach (iterator_to_array($node->childNodes) as $childNode) {
                $node->parentNode->insertBefore($childNode, $node);
            }

            $node->parentNode->removeChild($node);
        });
    }
}