chillerlan / php-prototype-dom

src/Node/PrototypeTraversalTrait.php

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

namespace chillerlan\PrototypeDOM\Node;

use chillerlan\PrototypeDOM\NodeList;
use DOMNode;

use function is_array, is_int, is_numeric;

use const XML_ELEMENT_NODE;

/**
 * @implements \chillerlan\PrototypeDOM\Node\PrototypeTraversal
 *
 * @property \chillerlan\PrototypeDOM\Document $ownerDocument
 */
trait PrototypeTraversalTrait{
	use PrototypeNodeTrait;

	/**
	 * @inheritDoc
	 */
	public function recursivelyFind(
		string $selector = null,
		int $index = null,
		string $property = null,
		int $nodeType = XML_ELEMENT_NODE
	):?PrototypeTraversal{

		if(is_numeric($selector)){
			return $this->ownerDocument->recursivelyFind($this, $property, null, $selector, $nodeType);

$selector of type string is incompatible with the type integer|null expected by parameter $index of chillerlan\PrototypeDOM\Document::recursivelyFind().

$this of type chillerlan\PrototypeDOM\Node\PrototypeTraversalTrait is incompatible with the type chillerlan\PrototypeDOM\Node\PrototypeNode expected by parameter $element of chillerlan\PrototypeDOM\Document::recursivelyFind().

The expression return $this->ownerDocument->recursivelyFind($this, $property, null, $selector, $nodeType) could return the type DOMNode which is incompatible with the type-hinted return chillerlan\PrototypeDOM\Node\PrototypeTraversal|null. Consider adding an additional type-check to rule them out.

		}

		return $this->ownerDocument->recursivelyFind($this, $property, $selector, $index ?? 0, $nodeType);

The expression return $this->ownerDocument->recursivelyFind($this, $property, $selector, $index ?? 0, $nodeType) could return the type DOMNode which is incompatible with the type-hinted return chillerlan\PrototypeDOM\Node\PrototypeTraversal|null. Consider adding an additional type-check to rule them out.

	}

	/**
	 * @inheritDoc
	 */
	public function select(array $selectors = null):NodeList{
		return $this->ownerDocument->select($selectors, $this, 'descendant::');

$this of type chillerlan\PrototypeDOM\Node\PrototypeTraversalTrait is incompatible with the type DOMNode|null expected by parameter $contextNode of chillerlan\PrototypeDOM\Document::select().

	}

	/**
	 * @inheritDoc
	 */
	public function down($expression = null, int $index = null):?PrototypeTraversal{

		if($expression === null && $index === null){
			return $this->firstDescendant();
		}

		$index = $index ?? 0;

		if(is_int($expression)){
			return $this->select(['*'])->item($expression);

The expression return $this->select(array('*'))->item($expression) could return the type DOMNode which is incompatible with the type-hinted return chillerlan\PrototypeDOM\Node\PrototypeTraversal|null. Consider adding an additional type-check to rule them out.

		}

		if(is_array($expression)){
			return $this->select($expression)->item($index);

The expression return $this->select($expression)->item($index) could return the type DOMNode which is incompatible with the type-hinted return chillerlan\PrototypeDOM\Node\PrototypeTraversal|null. Consider adding an additional type-check to rule them out.

		}

		return $this->select([$expression])->item($index);

The expression return $this->select(array($expression))->item($index) could return the type DOMNode which is incompatible with the type-hinted return chillerlan\PrototypeDOM\Node\PrototypeTraversal|null. Consider adding an additional type-check to rule them out.

	}

	/**
	 * @inheritDoc
	 */
	public function up($expression = null, int $index = null):?PrototypeTraversal{
		return $this->recursivelyFind($expression, $index, 'parentNode');
	}

	/**
	 * @inheritDoc
	 */
	public function previous($expression = null, int $index = null):?PrototypeTraversal{
		return $this->recursivelyFind($expression, $index, 'previousSibling');
	}

	/**
	 * @inheritDoc
	 */
	public function next($expression = null, int $index = null):?PrototypeTraversal{
		return $this->recursivelyFind($expression, $index, 'nextSibling');
	}

	/**
	 * @inheritDoc
	 */
	public function childElements(int $nodeType = null):NodeList{
		$nodeType = $nodeType ?? XML_ELEMENT_NODE;
		$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?

			return $children;
		}

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

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

		}

		return $children;
	}

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

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

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

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

	/**
	 * @inheritDoc
	 */
	public function firstDescendant():?PrototypeTraversal{
		return $this->descendants()->first();

The expression return $this->descendants()->first() could return the type DOMNode which is incompatible with the type-hinted return chillerlan\PrototypeDOM\Node\PrototypeTraversal|null. Consider adding an additional type-check to rule them out.

	}

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

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

}