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

Completed
Branch — scrutinizer (79ce98)

by Thomas
created 2019-07-24 11:09 UTC
Attribute::getVal() B

↳ Parent: Attribute
Complexity

Conditions	7
Paths	1
Size

Total Lines	28
Code Lines	18
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
cc	7
eloc	18
c	1
b	1
f	0
nc	1
nop	0
dl	0
loc	28
rs	8.8333
<?php

namespace Sulao\HtmlQuery;

use DOMElement, DOMNode;

/**
 * Class Attribute
 *
 * @package Sulao\HtmlQuery
 */
abstract class Attribute extends Selection
{
    /**
     * 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 (DOMNode $node) use ($name) {
            if (!($node instanceof DOMElement)) {
                return null;
            }

            return $node->getAttribute($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 (DOMNode $node) use ($name, $value) {
            if ($node instanceof DOMElement) {
                $node->setAttribute($name, $value);
            }
        });
    }

    /**
     * Remove an attribute from every matched nodes.
     *
     * @param string $attributeName
     *
     * @return static
     */
    public function removeAttr(string $attributeName)
    {
        return $this->each(function (DOMNode $node) use ($attributeName) {
            if ($node instanceof DOMElement) {
                $node->removeAttribute($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 (DOMNode $node) use ($except) {
            $names = [];
            foreach (iterator_to_array($node->attributes) as $attribute) {
                $names[] = $attribute->name;
            }

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

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

                return $node->hasAttribute($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);
    }

    /**
     * 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 (HtmlQuery $node) use ($className) {
            if (!$node->hasAttr('class')) {
                $node->setAttr('class', $className);
                return;
            }

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

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

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

    /**
     * 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 (HtmlQuery $node) use ($className) {
                if (!$node->hasAttr('class')) {
                    return false;
                }

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

                return in_array($className, $classes);
            }
        );
    }

    /**
     * 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 (HtmlQuery $node) use ($className) {
            if (!$node->hasAttr('class')) {
                return;
            }

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

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

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

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

    /**
     * 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 (HtmlQuery $node) use ($className, $state) {
            if (!is_null($state)) {
                if ($state) {
                    $node->addClass($className);
                } else {
                    $node->removeClass($className);
                }
                return;
            }

            if (!$this->hasAttr('class')) {
                $node->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)) {
                $node->removeClass($className);
                return;
            }

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

    /**
     * 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 (HtmlQuery $node) use ($name) {
            $style = (string) $node->attr('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 for every matched node.
     *
     * @param string      $name
     * @param string|null $value
     *
     * @return static
     */
    public function setCss(string $name, ?string $value)
    {
        return $this->each(function (HtmlQuery $node) use ($name, $value) {
            if ((string) $value === '') {
                $node->removeCss($name);
                return;
            }

            $style = (string) $node->attr('style');
            if (!$style) {
                $node->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 for every matched node.
     *
     * @param string $name
     *
     * @return static
     */
    public function removeCss(string $name)
    {
        return $this->each(function (HtmlQuery $node) use ($name) {
            $style = (string) $node->attr('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);
            }
        });
    }
}

xinningsu / html-query

Branch — scrutinizer (79ce98)

Attribute::getVal() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
