DOMWrap\Collections\NodeCollection

Complexity

Total Complexity

20

Size/Duplication

Total Lines	159
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

58.54%

Importance

Changes	1
Bugs	0	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	3
A	count()	0	3	1
A	offsetExists()	0	3	1
A	offsetGet()	0	3	2
A	offsetSet()	0	7	2
A	offsetUnset()	0	3	1
A	getRecursiveIterator()	0	3	1
A	getChildren()	0	9	2
A	hasChildren()	0	7	2
A	current()	0	3	1
A	key()	0	3	1
A	next()	0	3	1
A	rewind()	0	3	1
A	valid()	0	3	1

<?php declare(strict_types=1);

namespace DOMWrap\Collections;

/**
 * Node List
 *
 * @package DOMWrap\Collections
 * @license http://opensource.org/licenses/BSD-3-Clause BSD 3 Clause
 */
class NodeCollection implements \Countable, \ArrayAccess, \RecursiveIterator
{
    /** @var iterable */
    protected $nodes = [];

    /**
     * @param iterable $nodes
     */
    public function __construct(iterable $nodes = null) {
        if (!is_iterable($nodes)) {
            $nodes = [];
        }

        foreach ($nodes as $node) {

The expression $nodes of type object<DOMWrap\Collections\iterable>|null|array is not guaranteed to be traversable. How about adding an additional type check?

            $this->nodes[] = $node;
        }
    }

    /**
     * @see \Countable::count()
     *
     * @return int
     */
    public function count(): int {
        return count($this->nodes);
    }

    /**
     * @see \ArrayAccess::offsetExists()
     *
     * @param mixed $offset
     *
     * @return bool
     */
    public function offsetExists($offset): bool {
        return isset($this->nodes[$offset]);
    }

    /**
     * @see \ArrayAccess::offsetGet()
     *
     * @param mixed $offset
     *
     * @return mixed
     */
    public function offsetGet($offset) {
        return isset($this->nodes[$offset]) ? $this->nodes[$offset] : null;
    }

    /**
     * @see \ArrayAccess::offsetSet()
     *
     * @param mixed $offset
     * @param mixed $value
     */
    public function offsetSet($offset, $value): void {
        if (is_null($offset)) {
            $this->nodes[] = $value;
        } else {
            $this->nodes[$offset] = $value;
        }
    }

    /**
     * @see \ArrayAccess::offsetUnset()
     *
     * @param mixed $offset
     */
    public function offsetUnset($offset): void {
        unset($this->nodes[$offset]);
    }

    /**
     * @see \RecursiveIterator::RecursiveIteratorIterator()
     *
     * @return \RecursiveIteratorIterator
     */
    public function getRecursiveIterator(): \RecursiveIteratorIterator {
        return new \RecursiveIteratorIterator($this, \RecursiveIteratorIterator::SELF_FIRST);
    }

    /**
     * @see \RecursiveIterator::getChildren()
     *
     * @return \RecursiveIterator
     */
    public function getChildren(): \RecursiveIterator {
        $nodes = [];

        if ($this->valid()) {
            $nodes = $this->current()->childNodes;
        }

        return new static($nodes);
    }

    /**
     * @see \RecursiveIterator::hasChildren()
     *
     * @return bool
     */
    public function hasChildren(): bool {
        if ($this->valid()) {
            return $this->current()->hasChildNodes();
        }

        return false;
    }

    /**
     * @see \RecursiveIterator::current()
     * @see \Iterator::current()
     *
     * @return mixed
     */
    public function current() {
        return current($this->nodes);
    }

    /**
     * @see \RecursiveIterator::key()
     * @see \Iterator::key()
     *
     * @return mixed
     */
    public function key() {
        return key($this->nodes);
    }

    /**
     * @see \RecursiveIterator::next()
     * @see \Iterator::next()
     *
     * @return mixed
     */
    public function next() {
        return next($this->nodes);
    }

    /**
     * @see \RecursiveIterator::rewind()
     * @see \Iterator::rewind()
     *
     * @return mixed
     */
    public function rewind() {
        return reset($this->nodes);
    }

    /**
     * @see \RecursiveIterator::valid()
     * @see \Iterator::valid()
     *
     * @return bool
     */
    public function valid(): bool {
        return key($this->nodes) !== null;
    }
}