Sulao\HtmlQuery\HtmlNode

Complexity

Total Complexity

59

Size/Duplication

Total Lines	423
Duplicated Lines	0 %

Importance

Changes	1
Bugs	1	Features	0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	before()	0	3	1
A	outerHtml()	0	3	1
A	hasAttr()	0	7	2
B	removeCss()	0	29	6
A	getText()	0	3	1
A	setText()	0	3	1
A	setAttr()	0	4	2
A	hasClass()	0	10	2
A	replaceWith()	0	4	2
A	remove()	0	4	2
A	toggleClass()	0	30	5
A	removeAttr()	0	4	2
A	setCss()	0	30	6
A	addClass()	0	18	3
A	prepend()	0	6	2
A	getCss()	0	19	4
A	removeAllAttrs()	0	10	4
A	removeClass()	0	23	4
A	getHtml()	0	8	2
A	append()	0	3	1
A	empty()	0	3	1
A	getAttr()	0	7	2
A	getDoc()	0	5	2

<?php

namespace Sulao\HtmlQuery;

use DOMDocument, DOMElement, DOMNode;

/**
 * Class HtmlNode
 *
 * @package Sulao\HtmlQuery
 */
class HtmlNode
{
    /**
     * @var DOMNode
     */
    protected $node;

    /**
     * Node constructor.
     *
     * @param DOMNode $node
     */
    public function __construct(DOMNode $node)
    {
        $this->node = $node;
    }

    /**
     * Get the outer HTML content.
     *
     * @return string|null
     */
    public function outerHtml()
    {
        return $this->getDoc()->saveHTML($this->node);
    }

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

        return $content;
    }

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

    /**
     * Set the text contents.
     *
     * @param string $text
     */
    public function setText(string $text)
    {
        $this->node->nodeValue = $text;
    }

    /**
     * Get the value of an attribute
     *
     * @param string $name
     *
     * @return string|null
     */
    public function getAttr(string $name)
    {
        if (!($this->node instanceof DOMElement)) {
            return null;
        }

        return $this->node->getAttribute($name);
    }

    /**
     * Set attribute.
     *
     * @param string $name
     * @param string $value
     */
    public function setAttr(string $name, string $value)
    {
        if ($this->node instanceof DOMElement) {
            $this->node->setAttribute($name, $value);
        }
    }

    /**
     * Remove an attribute.
     *
     * @param string $attributeName
     */
    public function removeAttr(string $attributeName)
    {
        if ($this->node instanceof DOMElement) {
            $this->node->removeAttribute($attributeName);
        }
    }

    /**
     * Remove all attributes except the specified ones.
     *
     * @param string|array $except The attribute name(s) that won't be removed
     */
    public function removeAllAttrs($except = [])
    {
        if ($this->node instanceof DOMElement) {
            $names = [];
            foreach (iterator_to_array($this->node->attributes) as $attribute) {
                $names[] = $attribute->name;
            }

            foreach (array_diff($names, (array) $except) as $name) {
                $this->node->removeAttribute($name);
            }
        }
    }

    /**
     * Determine whether the node has the given attribute.
     *
     * @param string $attributeName
     *
     * @return bool
     */
    public function hasAttr(string $attributeName)
    {
        if (!($this->node instanceof DOMElement)) {
            return false;
        }

        return $this->node->hasAttribute($attributeName);
    }

    /**
     * Remove all child nodes from the DOM.
     */
    public function empty()
    {
        $this->node->nodeValue = '';
    }

    /**
     * Remove the node from the DOM.
     */
    public function remove()
    {
        if ($this->node->parentNode) {
            $this->node->parentNode->removeChild($this->node);
        }
    }

    /**
     * Adds the specified class(es).
     *
     * @param string $className
     */
    public function addClass(string $className)
    {
        if (!$this->hasAttr('class')) {
            $this->setAttr('class', $className);
            return;
        }

        $classNames = Helper::splitClass($className);
        $class = (string) $this->getAttr('class');
        $classes = Helper::splitClass($class);

        $classArr = array_diff($classNames, $classes);
        if (empty($classArr)) {
            return;
        }

        $class .= ' ' . implode(' ', $classArr);
        $this->setAttr('class', $class);
    }

    /**
     * Determine whether the node is assigned the given class.
     *
     * @param string $className
     *
     * @return bool
     */
    public function hasClass(string $className)
    {
        if (!$this->hasAttr('class')) {
            return false;
        }

        $class = (string) $this->getAttr('class');
        $classes = Helper::splitClass($class);

        return in_array($className, $classes);
    }

    /**
     * Remove a single class, multiple classes, or all classes.
     *
     * @param string|null $className
     */
    public function removeClass(?string $className = null)
    {
        if (!$this->hasAttr('class')) {
            return;
        }

        if (is_null($className)) {
            $this->removeAttr('class');
            return;
        }

        $classNames = Helper::splitClass($className);
        $class = (string) $this->getAttr('class');
        $classes = Helper::splitClass($class);

        $classArr = array_diff($classes, $classNames);
        if (empty($classArr)) {
            $this->removeAttr('class');
            return;
        }

        $class = implode(' ', $classArr);
        $this->setAttr('class', $class);
    }

    /**
     * Add or remove class(es), depending on either the class's presence
     * or the value of the state argument.
     *
     * @param string $className
     * @param bool|null   $state
     */
    public function toggleClass(string $className, ?bool $state = null)
    {
        if (!is_null($state)) {
            if ($state) {
                $this->addClass($className);
            } else {
                $this->removeClass($className);
            }
            return;
        }

        if (!$this->hasAttr('class')) {
            $this->setAttr('class', $className);
            return;
        }

        $classNames = Helper::splitClass($className);
        $classes = Helper::splitClass((string) $this->getAttr('class'));

        $classArr = array_diff($classes, $classNames);
        $classArr = array_merge(
            $classArr,
            array_diff($classNames, $classes)
        );
        if (empty($classArr)) {
            $this->removeClass($className);
            return;
        }

        $this->setAttr('class', implode(' ', $classArr));
    }

    /**
     * Get the value of a computed style property
     *
     * @param string $name
     *
     * @return string|null
     */
    public function getCss(string $name)
    {
        $style = (string) $this->getAttr('style');
        $css = Helper::splitCss($style);
        if (!$css) {
            return null;
        }

        if (array_key_exists($name, $css)) {
            return $css[$name];
        }

        $arr = array_change_key_case($css, CASE_LOWER);
        $key = strtolower($name);
        if (array_key_exists($key, $arr)) {
            return $arr[$key];
        }

        return null;
    }

    /**
     * Set or Remove one CSS property.
     *
     * @param string      $name
     * @param string|null $value
     */
    public function setCss(string $name, ?string $value)
    {
        if ((string) $value === '') {
            $this->removeCss($name);
            return;
        }

        $style = (string) $this->getAttr('style');
        if (!$style) {
            $this->setAttr('style', $name . ': ' . $value . ';');
            return;
        }

        $css = Helper::splitCss($style);
        if (!array_key_exists($name, $css)) {
            $allKeys = array_keys($css);
            $arr = array_combine(
                $allKeys,
                array_map('strtolower', $allKeys)
            ) ?: [];

            $keys = array_keys($arr, strtolower($name));
            foreach ($keys as $key) {
                unset($css[$key]);
            }
        }

        $css[$name] = $value;
        $style = Helper::implodeCss($css);
        $this->setAttr('style', $style);
    }

    /**
     * Remove one CSS property.
     *
     * @param string $name
     */
    public function removeCss(string $name)
    {
        $style = (string) $this->getAttr('style');
        if (!$style) {
            return;
        }

        $css = Helper::splitCss($style);
        $removed = false;
        if (array_key_exists($name, $css)) {
            unset($css[$name]);
            $removed = true;
        } else {
            $allKeys = array_keys($css);
            $arr = array_combine(
                $allKeys,
                array_map('strtolower', $allKeys)
            ) ?: [];

            $keys = array_keys($arr, strtolower($name));
            foreach ($keys as $key) {
                unset($css[$key]);
                $removed = true;
            }
        }

        if ($removed) {
            $style = Helper::implodeCss($css);
            $this->setAttr('style', $style);
        }
    }

    /**
     * Insert a node before the node.
     *
     * @param DOMNode $newNode
     */
    public function before(DOMNode $newNode)
    {
        $this->node->parentNode->insertBefore($newNode, $this->node);
    }

    /**
     * Insert a node to the end of the node.
     *
     * @param DOMNode $newNode
     */
    public function append(DOMNode $newNode)
    {
        $this->node->appendChild($newNode);
    }

    /**
     * Insert content or node(s) to the beginning of each matched node.
     *
     * @param DOMNode $newNode
     */
    public function prepend(DOMNode $newNode)
    {
        if ($this->node->firstChild) {
            $this->node->insertBefore($newNode, $this->node->firstChild);
        } else {
            $this->node->appendChild($newNode);
        }
    }

    /**
     * Replace the node with the provided node
     *
     * @param DOMNode $newNode
     */
    public function replaceWith(DOMNode $newNode)
    {
        if ($this->node->parentNode) {
            $this->node->parentNode->replaceChild($newNode, $this->node);
        }
    }

    protected function getDoc()
    {
        return $this->node instanceof DOMDocument
            ? $this->node :
            $this->node->ownerDocument;
    }
}