NodeList::exists() - Code Metrics - scotteh/php-dom-wrapper - Measure and Improve Code Quality continuously with Scrutinizer

NodeList::exists() A
last analyzed 2023-09-05 13:23 UTC

↳ Parent: NodeList
Complexity

Conditions	1
Paths	1
Size

Total Lines	2
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	2
Importance

Changes
Metric	Value
dl	0
loc	2
ccs	0
cts	0
cp	0
rs	10
c	0
b	0
f	0
cc	1
eloc	1
nc	1
nop	1
crap	2
<?php declare(strict_types=1);

namespace DOMWrap;

use DOMWrap\Traits\{
    CommonTrait,
    TraversalTrait,
    ManipulationTrait
};
use DOMWrap\Collections\NodeCollection;

/**
 * Node List
 *
 * @package DOMWrap
 * @license http://opensource.org/licenses/BSD-3-Clause BSD 3 Clause
 */
class NodeList extends NodeCollection
{
    use CommonTrait;

    use TraversalTrait;

    use ManipulationTrait {

        ManipulationTrait::__call as __manipulationCall;
    }

    /** @var Document */
    protected $document;

    /**
     * @param Document $document
     * @param iterable $nodes
     */
    public function __construct(Document $document = null, iterable $nodes = null) {
        parent::__construct($nodes);

        $this->document = $document;
    }

    /**
     * @param string $name
     * @param array $arguments
     *
     * @return mixed
     */
    public function __call(string $name, array $arguments) {
        try {
            $result = $this->__manipulationCall($name, $arguments);
            $result = $this->__manipulationCall($name, $arguments);
        } catch (\BadMethodCallException $e) {
            if (!$this->first() || !method_exists($this->first(), $name)) {
                throw new \BadMethodCallException("Call to undefined method " . get_class($this) . '::' . $name . "()");
            }

            $result = call_user_func_array([$this->first(), $name], $arguments);
        }

        return $result;
    }

    /**
     * {@inheritdoc}
     */
    public function collection(): NodeList {
        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function document(): ?\DOMDocument {
        return $this->document;
    }

    /**
     * {@inheritdoc}
     */
    public function result(NodeList $nodeList) {
        return $nodeList;
    }

    /**
     * @return NodeList
     */
    public function reverse(): NodeList {
        array_reverse($this->nodes);

        return $this;
    }

    /**
     * @return mixed
     */
    public function first() {
        return !empty($this->nodes) ? $this->rewind() : null;
    }

    /**
     * @return mixed
     */
    public function last() {
        return $this->end();
    }

    /**
     * @return mixed
     */
    public function end() {
        return !empty($this->nodes) ? end($this->nodes) : null;
    }

    /**
     * @param int $key
     *
     * @return mixed
     */
    public function get(int $key) {
        if (isset($this->nodes[$key])) {
            return $this->nodes[$key];
        }

        return null;
    }

    /**
     * @param int $key
     * @param mixed $value
     *
     * @return self
     */
    public function set(int $key, $value): self {
        $this->nodes[$key] = $value;

        return $this;
    }

    /**
     * @param callable $function
     *
     * @return self
     */
    public function each(callable $function): self {
        foreach ($this->nodes as $index => $node) {
            $result = $function($node, $index);

            if ($result === false) {
                break;
            }
        }

        return $this;
    }

    /**
     * @param callable $function
     *
     * @return NodeList
     */
    public function map(callable $function): NodeList {
        $nodes = $this->newNodeList();

        foreach ($this->nodes as $node) {
            $result = $function($node);

            if (!is_null($result) && $result !== false) {
                $nodes[] = $result;
            }
        }

        return $nodes;
    }

    /**
     * @param callable $function
     * @param mixed|null $initial
     *
     * @return iterable
     */
    public function reduce(callable $function, $initial = null) {
        return array_reduce($this->nodes, $function, $initial);
    }

    /**
     * @return array
     */
    public function toArray() {
        return $this->nodes;
    }

    /**
     * @param iterable $nodes
     */
    public function fromArray(iterable $nodes = null) {
        $this->nodes = [];

        if (is_iterable($nodes)) {
            foreach ($nodes as $node) {
                $this->nodes[] = $node;
            }
        }
    }

    /**
     * @param NodeList|array $elements
     *
     * @return NodeList
     */
    public function merge($elements = []): NodeList {
        if (!is_array($elements)) {
            $elements = $elements->toArray();
        }

        return $this->newNodeList(array_merge($this->toArray(), $elements));
    }

    /**
     * @param int $start
     * @param int $end
     *
     * @return NodeList
     */
    public function slice(int $start, int $end = null): NodeList {
        $nodeList = array_slice($this->toArray(), $start, $end);

        return $this->newNodeList($nodeList);
    }

    /**
     * @param \DOMNode $node
     *
     * @return self
     */
    public function push(\DOMNode $node): self {
        $this->nodes[] = $node;

        return $this;
    }

    /**
     * @return \DOMNode
     */
    public function pop(): \DOMNode {
        return array_pop($this->nodes);
    }

    /**
     * @param \DOMNode $node
     *
     * @return self
     */
    public function unshift(\DOMNode $node): self {
        array_unshift($this->nodes, $node);

        return $this;
    }

    /**
     * @return \DOMNode
     */
    public function shift(): \DOMNode {
        return array_shift($this->nodes);
    }

    /**
     * @param \DOMNode $node
     *
     * @return bool
     */
    public function exists(\DOMNode $node): bool {
        return in_array($node, $this->nodes, true);
    }

    /**
     * @param \DOMNode $node
     *
     * @return self
     */
    public function delete(\DOMNode $node): self {
        $index = array_search($node, $this->nodes, true);

        if ($index !== false) {
            unset($this->nodes[$index]);
        }

        return $this;
    }

    /**
     * @return bool
     */
    public function isRemoved(): bool {
        return false;
    }
}
scotteh / php-dom-wrapper

NodeList::exists() A last analyzed 2023-09-05 13:23 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

NodeList::exists() A
last analyzed 2023-09-05 13:23 UTC
