Transphporm\Property\Content

Complexity

Total Complexity

34

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	10
Bugs	4	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	attr()	0	3	1
A	header()	0	3	1
A	before()	0	6	2
A	after()	0	5	2
A	removeAdded()	0	7	4
A	replaceContent()	0	8	2
A	appendContent()	0	5	2
A	removeAllChildren()	0	3	2
A	processPseudo()	0	10	3
A	getNode()	0	16	4
B	run()	0	13	5
A	isIncludedTemplate()	0	7	3
A	getContentMode()	0	3	2

<?php
/* @description     Transformation Style Sheets - Revolutionising PHP templating    *
 * @author          Tom Butler tom@r.je                                             *
 * @copyright       2015 Tom Butler <tom@r.je> | https://r.je/                      *
 * @license         http://www.opensource.org/licenses/bsd-license.php  BSD License *
 * @version         1.0                                                             */
namespace Transphporm\Property;
class Content implements \Transphporm\Property {
	private $data;
	private $headers;
	private $formatter;


	public function __construct($data, &$headers, \Transphporm\Hook\Formatter $formatter) {
		$this->data = $data;
		$this->headers = &$headers;
		$this->formatter = $formatter;
	}

	public function run($value, \DomElement $element, array $rules, \Transphporm\Hook\PseudoMatcher $pseudoMatcher, array $properties = []) {
		if ($this->isIncludedTemplate($element)) return false;
		if ($element->getAttribute('transphporm') === 'remove') return false;
	
		$value = $this->formatter->format($value, $rules);
		if (!$this->processPseudo($value, $element, $pseudoMatcher)) {
			//Remove the current contents
			$this->removeAllChildren($element);
			//Now make a text node
			if ($this->getContentMode($rules) === 'replace') $this->replaceContent($element, $value);
			else $this->appendContent($element, $value);
		}
	}

	private function isIncludedTemplate($element) {
		do {
			if ($element->getAttribute('transphporm') == 'includedtemplate') return true;
		}
		while (($element = $element->parentNode) instanceof \DomElement);
		return false;
	}

	private function getContentMode($rules) {
		return (isset($rules['content-mode'])) ? $rules['content-mode'] : 'append';
	}

	private function processPseudo($value, $element, $pseudoMatcher) {
		$pseudoContent = ['attr', 'header', 'before', 'after'];
		foreach ($pseudoContent as $pseudo) {
			if ($pseudoMatcher->hasFunction($pseudo)) {
				$this->$pseudo($value, $pseudoMatcher->getFuncArgs($pseudo), $element);
				return true;
			}
		}
		return false;
	}
	
	private function getNode($node, $document) {
		foreach ($node as $n) {
			if ($n instanceof \DomElement) {
				$new = $document->importNode($n, true);
				//Removing this might cause problems with caching... 
				//$new->setAttribute('transphporm', 'added');

80% of this comment could be valid code. Did you maybe forget this after debugging?

			}
			else {
				if ($n instanceof \DomText) $n = $n->nodeValue;
				$new = $document->createElement('text');
				$new->appendChild($document->createTextNode($n));
				$new->setAttribute('transphporm', 'text');
			}
			yield $new;
		}
	}

	/** Functions for writing to pseudo elements, attr, before, after, header */
	private function attr($value, $pseudoArgs, $element) {
		$element->setAttribute($pseudoArgs, implode('', $value));
	}

	private function header($value, $pseudoArgs, $element) {

The parameter $element is not used and could be removed.

		$this->headers[] = [$pseudoArgs, implode('', $value)];
	}

	private function before($value, $pseudoArgs, $element) {

The parameter $pseudoArgs is not used and could be removed.

		foreach ($this->getNode($value, $element->ownerDocument) as $node) {
			$element->insertBefore($node, $element->firstChild);	
		}
		return true;
	}

	private function after($value, $pseudoArgs, $element) {

The parameter $pseudoArgs is not used and could be removed.

		 foreach ($this->getNode($value, $element->ownerDocument) as $node) {
		 		$element->appendChild($node);
		}			 
	}

	private function removeAdded($e) {
		$remove = [];
		while ($e = $e->previousSibling && !in_array($e->getAttribute('transphporm'), [null, 'remove'])) {

Consider adding parentheses for clarity. Current Interpretation: $e = ($e->previousSibling && !in_array($e->getAttribute('transphporm'), array(null, 'remove'))), Probably Intended Meaning: ($e = $e->previousSibling) && !in_array($e->getAttribute('transphporm'), array(null, 'remove'))

			$remove[] = $e;
		}
		foreach ($remove as $r) $r->parentNode->removeChild($r);
	}

	private function replaceContent($element, $content) {
		//If this rule was cached, the elements that were added last time need to be removed prior to running the rule again.
		$this->removeAdded($element);
		foreach ($this->getNode($content, $element->ownerDocument) as $node) {
			$element->parentNode->insertBefore($node, $element);
		}		
		$element->setAttribute('transphporm', 'remove');
	}

	private function appendContent($element, $content) {
		foreach ($this->getNode($content, $element->ownerDocument) as $node) {
			$element->appendChild($node);
		}
	}
	
	private function removeAllChildren($element) {
		while ($element->hasChildNodes()) $element->removeChild($element->firstChild);
	}
}