chillerlan\PrototypeDOM\ManipulationTrait

Complexity

Total Complexity

31

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	remove()	0	10	2
A	replace()	0	10	2
A	wrap()	0	4	1
A	empty()	0	9	2
A	update()	0	7	1
A	cleanWhitespace()	0	16	4
A	_importNode()	0	3	1
A	insert_before()	0	9	2
D	insert()	0	31	10
A	insert_after()	0	5	3
A	insert_top()	0	5	2
A	insert_bottom()	0	6	1

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

namespace chillerlan\PrototypeDOM;

use DOMNode;

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

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

	/**
	 * @var \chillerlan\PrototypeDOM\Element
	 */
	public $parentNode;

	/**
	 * @var \chillerlan\PrototypeDOM\Element
	 */
	public $firstChild;

	/**
	 * @var \chillerlan\PrototypeDOM\Element
	 */
	public $nextSibling;

	/**
	 * @return \DOMNode
	 */
	public function remove():DOMNode{

		if(!$this->parentNode){
			/** @var \DOMNode $this */
			return $this;
		}

		/** @var \DOMNode $this */
		return $this->parentNode->removeChild($this);
	}

	/**
	 * @param \DOMNode $newnode
	 *
	 * @return \DOMNode
	 */
	public function replace(DOMNode $newnode):DOMNode{

		if(!$this->parentNode){
			/** @var \DOMNode $this */
			return $this;
		}

		/** @var \DOMNode $this */
		return $this->parentNode->replaceChild($this->_importNode($newnode), $this);
	}

	/**
	 * @param \DOMNode $wrapper
	 *
	 * @return \chillerlan\PrototypeDOM\Element
	 */
	public function wrap(DOMNode $wrapper):Element{
		/** @var \chillerlan\PrototypeDOM\Element $wrapper */
		return $wrapper->insert($this->replace($wrapper));
	}

	/**
	 * @return \DOMNode
	 */
	public function empty():DOMNode{

		while($this->hasChildNodes()){

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

			$this->firstChild->remove();
		}

		/** @var \DOMNode $this */
		return $this;
	}

	/**
	 * @param string|\DOMNode|\DOMNodeList $content
	 *
	 * @return \DOMNode
	 */
	public function update($content):DOMNode{
		$this->empty();
		$this->insert($content);

		/** @var \DOMNode $this */
		return $this;
	}

	/**
	 * @return \DOMNode
	 */
	public function cleanWhitespace():DOMNode{
		$node = $this->firstChild;

		while($node){
			$nextNode = $node->nextSibling;

			if($node->nodeType === XML_TEXT_NODE && empty(trim($node->nodeValue))){
				$node->remove();
			}

			$node = $nextNode;
		}

		/** @var \DOMNode $this */
		return $this;
	}

	/**
	 * @param \DOMNode $newNode
	 *
	 * @return \DOMNode
	 */
	public function _importNode(DOMNode $newNode):DOMNode{
		return $this->ownerDocument->importNode($newNode, true);
	}

	/**
	 * Accepted insertion points are:
	 * - before (as element's previous sibling)
	 * - after (as element's next sibling)
	 * - top (as element's first child)
	 * - bottom (as element's last child)
	 *
	 * @param string|array|\DOMNode|\DOMNodeList $content
	 *
	 * @return \DOMNode
	 */
	public function insert($content):DOMNode{

		if(is_array($content)){

			foreach(['before', 'after', 'top', 'bottom'] as $pos){

				if(array_key_exists($pos, $content)){
					$nodes = $this->ownerDocument->_toNodeList($content[$pos]);

					if($pos === 'top' && $this->hasChildNodes() || $pos === 'after' && $this->nextSibling){

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

						$nodes->reverse();
					}

					foreach($nodes as $node){
						call_user_func_array([$this, 'insert_'.$pos], [$node]);
					}

				}

			}

		}
		else{
			foreach($this->ownerDocument->_toNodeList($content) as $node){
				$this->insert_bottom($node);
			}
		}

		/** @var \DOMNode $this */
		return $this;
	}

	/**
	 * @param \DOMNode      $node
	 * @param \DOMNode|null $refNode
	 *
	 * @return \DOMNode
	 */
	public function insert_before(DOMNode $node, DOMNode $refNode = null):DOMNode{

		if($this->parentNode){
			$this->parentNode->insertBefore($this->_importNode($node), $refNode ?? $this);
		}

		/** @var \DOMNode $this */
		return $this;
	}

	/**
	 * @param \DOMNode $node
	 *
	 * @return \DOMNode
	 */
	public function insert_after(DOMNode $node):DOMNode{
		return !$this->nextSibling && $this->parentNode
			? $this->parentNode->insert_bottom($node)
			: $this->nextSibling->insert_before($node);
	}

	/**
	 * @param \DOMNode $node
	 *
	 * @return \DOMNode
	 */
	public function insert_top(DOMNode $node):DOMNode{
		return $this->hasChildNodes()

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

			? $this->firstChild->insert_before($node, $this->firstChild)
			: $this->insert_bottom($node);
	}

	/**
	 * @param \DOMNode $node
	 *
	 * @return \DOMNode
	 */
	public function insert_bottom(DOMNode $node):DOMNode{
		$this->appendChild($this->_importNode($node));

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

		/** @var \DOMNode $this */
		return $this;
	}

}