chillerlan\PrototypeDOM\TraversalTrait

Complexity

Total Complexity

24

Size/Duplication

Total Lines	193
Duplicated Lines	0 %

Coupling/Cohesion

Components	4
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	recursivelyCollect()	0	4	1
A	_recursivelyFind()	0	10	2
A	inspect()	0	3	1
A	select()	0	3	1
A	match()	0	4	1
A	down()	0	13	4
A	up()	0	3	1
A	previous()	0	3	1
A	next()	0	3	1
A	childElements()	0	17	4
A	descendantOf()	0	3	1
A	ancestors()	0	3	1
A	siblings()	0	3	1
A	descendants()	0	3	1
A	firstDescendant()	0	3	1
A	previousSiblings()	0	3	1
A	nextSiblings()	0	3	1

<?php
/**
 * Trait TraversalTrait
 *
 * @filesource   TraversalTrait.php
 * @created      06.05.2017
 * @package      chillerlan\PrototypeDOM
 * @author       Smiley <smiley@chillerlan.net>
 * @copyright    2017 Smiley
 * @license      MIT
 */

namespace chillerlan\PrototypeDOM;

use DOMNode;

/**
 * @extends \DOMNode
 */
trait TraversalTrait{

	/**
	 * @link http://php.net/manual/class.domnode.php#domnode.props.ownerdocument
	 *
	 * @var \chillerlan\PrototypeDOM\Document
	 */
	public $ownerDocument;

	/**
	 * @param string $property
	 * @param int    $maxLength
	 * @param int    $nodeType
	 *
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function recursivelyCollect(string $property, int $maxLength = -1, int $nodeType = XML_ELEMENT_NODE):NodeList{
		/** @var \DOMNode $this */
		return $this->ownerDocument->recursivelyCollect($this, $property, $maxLength, $nodeType);

It seems like you code against a specific sub-type and not the parent class DOMDocument as the method recursivelyCollect() does only exist in the following sub-classes of DOMDocument: chillerlan\PrototypeDOM\Document. Maybe you want to instanceof check for one of these explicitly?

	}

	/**
	 * @param        $selector
	 * @param        $index
	 * @param string $property
	 * @param int    $nodeType
	 *
	 * @return \DOMNode|null
	 */
	public function _recursivelyFind($selector, $index, string $property, int $nodeType = XML_ELEMENT_NODE){

		if(is_numeric($selector)){
			$index    = $selector;
			$selector = null;
		}

		/** @var \chillerlan\PrototypeDOM\Element $this */
		return $this->ownerDocument->_recursivelyFind($this, $property, $selector, $index ?? 0, $nodeType);

It seems like you code against a specific sub-type and not the parent class DOMDocument as the method _recursivelyFind() does only exist in the following sub-classes of DOMDocument: chillerlan\PrototypeDOM\Document. Maybe you want to instanceof check for one of these explicitly?

	}

	/**
	 * @param bool $xml
	 *
	 * @return string
	 */
	public function inspect($xml = false):string{
		return $this->ownerDocument->inspect($this, $xml);
	}

	/**
	 * @param string|array $selectors
	 *
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function select($selectors = null):NodeList{
		return $this->ownerDocument->select($selectors, $this, 'descendant::');
	}

	/**
	 * @param string $selector
	 *
	 * @return bool
	 */
	public function match(string $selector):bool{
		/** @var \chillerlan\PrototypeDOM\Element $this */
		return $this->ownerDocument->match($this, $selector);

It seems like you code against a specific sub-type and not the parent class DOMDocument as the method match() does only exist in the following sub-classes of DOMDocument: chillerlan\PrototypeDOM\Document. Maybe you want to instanceof check for one of these explicitly?

	}

	/**
	 * @param null $expression
	 * @param int  $index
	 *
	 * @return \DOMNode|null
	 */
	public function down($expression = null, int $index = 0){

		if(count(func_get_args()) === 0){
			return $this->firstDescendant();
		}

		if(is_numeric($expression)){
			$index      = $expression;
			$expression = '*';
		}

		return $this->select(is_string($expression) ? $expression : null)[$index] ?? null;
	}

	/**
	 * @param string|null $expression
	 * @param int|null    $index
	 *
	 * @return \DOMNode|null
	 */
	public function up($expression = null, int $index = null){
		return $this->_recursivelyFind($expression, $index, 'parentNode');
	}

	/**
	 * @param string|null $expression
	 * @param int|null    $index
	 *
	 * @return \DOMNode|null
	 */
	public function previous($expression = null, int $index = null){
		return $this->_recursivelyFind($expression, $index, 'previousSibling');
	}

	/**
	 * @param string|null $expression
	 * @param int|null    $index
	 *
	 * @return \DOMNode|null
	 */
	public function next($expression = null, int $index = null){
		return $this->_recursivelyFind($expression, $index, 'nextSibling');
	}

	/**
	 * @param int $nodeType
	 *
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function childElements(int $nodeType = XML_ELEMENT_NODE):NodeList{
		$children = new NodeList;

		if($this->hasChildNodes()){

It seems like hasChildNodes() must be provided by classes using this trait. How about adding it as abstract method to this trait?

			foreach($this->childNodes as $child){

The property childNodes does not exist. Did you maybe forget to declare it?

				if($child->nodeType === $nodeType){
					$children[] = $child;
				}

			}

		}

		return $children;
	}

	/**
	 * @param \DOMNode $ancestor
	 *
	 * @return bool
	 */
	public function descendantOf(DOMNode $ancestor):bool{
		return $this->ancestors()->match($ancestor);
	}

	/**
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function ancestors():NodeList{
		return $this->recursivelyCollect('parentNode');
	}

	/**
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function siblings():NodeList{
		return $this->previousSiblings()->reverse()->merge($this->nextSiblings());
	}

	/**
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function descendants():NodeList{
		return $this->select();
	}

	/**
	 * @return \DOMNode|null
	 */
	public function firstDescendant(){
		return $this->descendants()[0] ?? null;
	}

	/**
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function previousSiblings():NodeList{
		return $this->recursivelyCollect('previousSibling');
	}

	/**
	 * @return \chillerlan\PrototypeDOM\NodeList
	 */
	public function nextSiblings():NodeList{
		return $this->recursivelyCollect('nextSibling');
	}

}