HtmlQuery::removeCss() - Code Metrics - Inspection of "fix scrutinizer issue" - xinningsu/html-query - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Branch — scrutinizer (dd8772)

by Thomas
created 2019-07-30 07:51 UTC
HtmlQuery::removeCss() A

↳ Parent: HtmlQuery
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	2
nc	1
nop	1
dl	0
loc	4
rs	10
c	1
b	0
f	0
<?php

namespace Sulao\HtmlQuery;

use DOMDocument, DOMElement, DOMNode, DOMNodeList;
use Traversable;

/**
 * Class HtmlQuery
 *
 * @package Sulao\HtmlQuery
 */
class HtmlQuery extends Selection
{
    const VERSION = '1.0.0';

    /**
     * @var DOMDocument
     */
    protected $doc;

    /**
     * @var DOMNode[]
     */
    protected $nodes;

    /**
     * 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 (HtmlNode $node) {
            return $node->outerHtml();
        });
    }

    /**
     * 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 (HtmlNode $node) {
            return $node->getHtml();
        });
    }

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

        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 (HtmlNode $node) {
            return $node->getText();
        });
    }

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

    /**
     * Get the value of an attribute for the first matched node
     * or set one or more attributes for every matched node.
     *
     * @param string|array $name
     * @param string|null  $value
     *
     * @return static|mixed|null
     */
    public function attr($name, $value = null)
    {
        if (is_array($name)) {
            foreach ($name as $key => $val) {
                $this->setAttr($key, $val);
            }

            return $this;
        }

        if (!is_null($value)) {
            return $this->setAttr($name, $value);
        }

        return $this->getAttr($name);
    }

    /**
     * Get the value of an attribute for the first matched node
     *
     * @param string $name
     *
     * @return string|null
     */
    public function getAttr(string $name)
    {
        return $this->mapFirst(function (HtmlNode $node) use ($name) {
            return $node->getAttr($name);
        });
    }

    /**
     * Set one or more attributes for every matched node.
     *
     * @param string $name
     * @param string $value
     *
     * @return static
     */
    public function setAttr(string $name, string $value)
    {
        return $this->each(function (HtmlNode $node) use ($name, $value) {
            $node->setAttr($name, $value);
        });
    }

    /**
     * Remove an attribute from every matched nodes.
     *
     * @param string $attributeName
     *
     * @return static
     */
    public function removeAttr(string $attributeName)
    {
        return $this->each(function (HtmlNode $node) use ($attributeName) {
            $node->removeAttr($attributeName);
        });
    }

    /**
     * Remove all attributes from every matched nodes except the specified ones.
     *
     * @param string|array $except The attribute name(s) that won't be removed
     *
     * @return static
     */
    public function removeAllAttrs($except = [])
    {
        return $this->each(function (HtmlNode $node) use ($except) {
            $node->removeAllAttrs($except);
        });
    }

    /**
     * Determine whether any of the nodes have the given attribute.
     *
     * @param string $attributeName
     *
     * @return bool
     */
    public function hasAttr(string $attributeName)
    {
        return $this->mapAnyTrue(
            function (HtmlNode $node) use ($attributeName) {
                return $node->hasAttr($attributeName);
            }
        );
    }

    /**
     * Alias of attr
     *
     * @param string|array $name
     * @param string|null  $value
     *
     * @return static|mixed|null
     */
    public function prop($name, $value = null)
    {
        return $this->attr($name, $value);
    }

    /**
     * Alias of removeAttr
     *
     * @param string $attributeName
     *
     * @return static
     */
    public function removeProp(string $attributeName)
    {
        return $this->removeAttr($attributeName);
    }

    /**
     * Get the value of an attribute with prefix data- for the first matched
     * node, if the value is valid json string, returns the value encoded in
     * json in appropriate PHP type
     *
     * or set one or more attributes with prefix data- for every matched node.
     *
     * @param string|array $name
     * @param string|null  $value
     *
     * @return static|mixed|null
     */
    public function data($name, $value = null)
    {
        if (is_array($name)) {
            $keys = array_keys($name);
            $keys = array_map(function ($value) {
                return 'data-' . $value;
            }, $keys);

            $name = array_combine($keys, $name);
        } else {
            $name = 'data-' . $name;
        }

        if (!is_null($value) && !is_string($value)) {

            $value = (string) json_encode($value);
        }

        $result = $this->attr($name, $value);
        $result = $this->attr(/** @scrutinizer ignore-type */ $name, $value);

        if (is_string($result)) {
            $json = json_decode($result);
            if (json_last_error() === JSON_ERROR_NONE) {
                return $json;
            }
        }

        return $result;
    }

    /**
     * Determine whether any of the nodes have the given attribute
     * prefix with data-.
     *
     * @param string $name
     *
     * @return bool
     */
    public function hasData(string $name)
    {
        return $this->hasAttr('data-' . $name);
    }

    /**
     * Remove an attribute prefix with data- from every matched nodes.
     *
     * @param string $name
     *
     * @return static
     */
    public function removeData(string $name)
    {
        return $this->removeAttr('data-' . $name);
    }

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

    /**
     * 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 (HtmlNode $node) {
                $node->remove();
            });
        }

        return $this;
    }

    /**
     * Get the current value of the first matched node
     * or set the value of every matched node.
     *
     * @param string|null $value
     *
     * @return string|null|static
     */
    public function val(?string $value = null)
    {
        if (is_null($value)) {
            return $this->getVal();
        }

        return $this->setVal($value);
    }

    /**
     * Get the current value of the first matched node
     *
     * @return string|null
     */
    public function getVal()
    {
        return $this->mapFirst(function (DOMNode $node) {
            if (!($node instanceof DOMElement)) {
                return null;
            }

            switch ($node->tagName) {
                case 'input':
                    return $node->getAttribute('value');
                case 'textarea':
                    return $node->nodeValue;
                case 'select':
                    $ht = $this->resolve($node);

                    $selected = $ht->children('option:selected');
                    if ($selected->count()) {
                        return $selected->getAttr('value');
                    }

                    $fistChild = $ht->xpathFind('child::*[1]');
                    if ($fistChild->count()) {
                        return $fistChild->getAttr('value');
                    }
                    break;
            }

            return null;
        });
    }

    /**
     * Set the value of every matched node.
     *
     * @param string $value
     *
     * @return static
     */
    public function setVal(string $value)
    {
        return $this->each(function (DOMNode $node) use ($value) {
            if (!($node instanceof DOMElement)) {
                return;
            }

            switch ($node->tagName) {
                case 'input':
                    $node->setAttribute('value', $value);
                    break;
                case 'textarea':
                    $node->nodeValue = $value;
                    break;
                case 'select':
                    $ht = $this->resolve($node);

                    $selected = $ht->children('option:selected');
                    if ($selected->count()) {
                        $selected->removeAttr('selected');
                    }

                    $options = $ht->children("option[value='{$value}']");
                    if ($options->count()) {
                        $options->first()->setAttr('selected', 'selected');
                    }
                    break;
            }
        });
    }

    /**
     * Adds the specified class(es) to each node in the matched nodes.
     *
     * @param string $className
     *
     * @return static
     */
    public function addClass(string $className)
    {
        return $this->each(function (HtmlNode $node) use ($className) {
            $node->addClass($className);
        });
    }

    /**
     * Determine whether any of the matched nodes are assigned the given class.
     *
     * @param string $className
     *
     * @return bool
     */
    public function hasClass(string $className)
    {
        return $this->mapAnyTrue(
            function (HtmlNode $node) use ($className) {
                return $node->hasClass($className);
            }
        );
    }

    /**
     * Remove a single class, multiple classes, or all classes
     * from each matched node.
     *
     * @param string|null $className
     *
     * @return static
     */
    public function removeClass(?string $className = null)
    {
        return $this->each(function (HtmlNode $node) use ($className) {
            $node->removeClass($className);
        });
    }

    /**
     * Add or remove class(es) from each matched node, depending on
     * either the class's presence or the value of the state argument.
     *
     * @param string $className
     * @param bool|null   $state
     *
     * @return static
     */
    public function toggleClass(string $className, ?bool $state = null)
    {
        return $this->each(function (HtmlNode $node) use ($className, $state) {
            $node->toggleClass($className, $state);
        });
    }

    /**
     * Get the value of a computed style property for the first matched node
     * or set one or more CSS properties for every matched node.
     *
     * @param string|array $name
     * @param string|null  $value
     *
     * @return static|string|null
     */
    public function css($name, $value = null)
    {
        if (is_null($value) && !is_array($name)) {
            return $this->getCss($name);
        }

        if (is_array($name)) {
            foreach ($name as $key => $val) {
                $this->setCss($key, $val);
            }
        } else {
            $this->setCss($name, $value);
        }

        return $this;
    }


    /**
     * Get the value of a computed style property for the first matched node
     *
     * @param string $name
     *
     * @return string|null
     */
    public function getCss(string $name)
    {
        return $this->mapFirst(function (HtmlNode $node) use ($name) {
            return $node->getCss($name);
        });
    }

    /**
     * Set or Remove one CSS property for every matched node.
     *
     * @param string      $name
     * @param string|null $value
     *
     * @return static
     */
    public function setCss(string $name, ?string $value)
    {
        return $this->each(function (HtmlNode $node) use ($name, $value) {
            $node->setCss($name, $value);
        });
    }

    /**
     * Remove one CSS property for every matched node.
     *
     * @param string $name
     *
     * @return static
     */
    public function removeCss(string $name)
    {
        return $this->each(function (HtmlNode $node) use ($name) {
            return $node->removeCss($name);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        });
    }

    /**
     * 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 (HtmlNode $node, $index) use ($content) {
            $content->each(function (DOMNode $newNode) use ($node, $index) {
                $newNode = $index !== $this->count() - 1
                    ? $newNode->cloneNode(true)
                    : $newNode;

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

    /**
     * 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 (HtmlNode $node, $index) use ($content) {
            $content->each(function (DOMNode $newNode) use ($node, $index) {
                $newNode = $index !== $this->count() - 1
                    ? $newNode->cloneNode(true)
                    : $newNode;

                $node->append($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 (HtmlNode $node, $index) use ($content) {
            $content->each(function (DOMNode $newNode) use ($node, $index) {
                $newNode = $index !== $this->count() - 1
                    ? $newNode->cloneNode(true)
                    : $newNode;

                $node->prepend($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)
                ? $newNode->/** @scrutinizer ignore-call */ cloneNode(true)
                : $newNode;

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

            $deepestNode = end($nodes);
            $node->parentNode->replaceChild($newNode, $node);
            $node->parentNode->replaceChild(/** @scrutinizer ignore-type */ $newNode, $node);
            $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);
        });
    }

    /**
     * Validate the nodes
     *
     * @param DOMNode|DOMNode[]|DOMNodeList|static $nodes
     *
     * @return DOMNode[]
     * @throws Exception
     */
    protected function validateNodes($nodes)
    {
        if (empty($nodes)) {
            $nodes = [];
        } elseif ($nodes instanceof Traversable) {
            $nodes = iterator_to_array($nodes);
        } elseif ($nodes instanceof DOMNode || !is_array($nodes)) {
            $nodes = [$nodes];
        }

        $nodes = Helper::strictArrayUnique($nodes);
        foreach ($nodes as $node) {
            if (!($node instanceof DOMNode)) {
                throw new Exception(
                    'Expect an instance of DOMNode, '
                        . gettype($node) . ' given.'
                );
            }

            if ((!$node->ownerDocument && $node !== $this->doc)
                || ($node->ownerDocument && $node->ownerDocument !== $this->doc)
            ) {
                throw new Exception(
                    'The DOMNode does not belong to the DOMDocument.'
                );
            }
        }

        return $nodes;
    }
}

xinningsu / html-query

Branch — scrutinizer (dd8772)

HtmlQuery::removeCss() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
