Transphporm\Hook\PseudoMatcher

Complexity

Total Complexity

33

Size/Duplication

Total Lines	116
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes	8
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	matches()	0	8	4
A	betweenBrackets()	0	9	3
B	attribute()	0	24	5
A	parseValue()	0	5	3
A	getOperator()	0	6	2
A	nth()	0	11	3
A	attr()	0	10	3
A	header()	0	7	4
A	odd()	0	3	1
A	even()	0	3	1
A	getBetween()	0	6	2
A	getPseudo()	0	3	1

<?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\Hook;
/** Determines whether $element matches the pseudo rule such as nth-child() or [attribute="value"] */
class PseudoMatcher {
	private $pseudo;
	private $dataFunction;

	public function __construct($pseudo, DataFunction $dataFunction) {
		$this->pseudo = $pseudo;
		$this->dataFunction = $dataFunction;
	}

	public function matches($element) {
		$matches = true;

		foreach ($this->pseudo as $pseudo) {			
			$matches = $matches && $this->attribute($pseudo, $element) && $this->nth($pseudo, $element);			
		}		
		return $matches;
	}

	private function betweenBrackets($string, $openChr, $closingChr, $start = 0) {
		$open = strpos($string, $openChr, $start);
		$close = strpos($string, $closingChr, $open);

		$cPos = $open+1;
		while (($cPos = strpos($string, $openChr, $cPos+1)) !== false && $cPos < $close) $close = strpos($string, $closingChr, $close+1);

		return substr($string, $open+1, $close-$open-1);
	}
	
	private function attribute($pseudo, $element) {
		$pos = strpos($pseudo, '[');
		if ($pos === false) return true;
		
		$name = substr($pseudo, 0, $pos);
		if (!is_callable([$this->dataFunction, $name])) return true;

		$criteria = $this->betweenBrackets($pseudo, '[', ']');

		if (strpos($pseudo, '=') === false) {
			$lookupValue = $this->dataFunction->$name([$criteria], $element);
			return $lookupValue !== null;
		}
		list ($field, $value) = explode('=', $criteria);

		$operator = $this->getOperator($field);

		$field = trim($field, $operator);		
		$value = $this->parseValue(trim($value, '"'));

		$lookupValue = $this->dataFunction->$name([$field], $element);
		$matched = $lookupValue == $value;
		return $operator === '!' ? !$matched : $matched;		
	}

	private function parseValue($value) {
		if ($value == 'true') return true;
		else if ($value == 'false') return false;
		else return $value;
	}

	private function getOperator($field) {
		if ($field[strlen($field)-1] == '!') {
			return '!';
		}
		else return '';
	}

	private function nth($pseudo, $element) {
		if (strpos($pseudo, 'nth-child') === 0) {	
			$criteria = $this->getBetween($pseudo, '(', ')');
			$num = $this->getBetween($element->getNodePath(), '[', ']');
			
			if (is_callable([$this, $criteria])) return $this->$criteria($num);
			else return $num == $criteria;
			
		}
		return true;
	}

	public function attr() {
		foreach ($this->pseudo as $pseudo) {
			if (strpos($pseudo, 'attr') === 0) {
				$criteria = trim($this->getBetween($pseudo, '(', ')'));
				return $criteria;
			}
		}

		return false;
	}

	public function header($element)  {
		if ($this->matches($element)) {
			foreach ($this->pseudo as $pseudo) {
				if (strpos($pseudo, 'header') === 0) return $this->getBetween($pseudo, '[', ']');
			}
		}
	}

	private function odd($num) {
		return $num % 2 === 1;
	}

	private function even($num) {
		return $num % 2 === 0;
	}

	private function getBetween($string, $start, $end) {
		$open = strpos($string, $start);
		if ($open === false) return false;
		$close = strpos($string, $end, $open);
		return substr($string, $open+1, $close-$open-1);
	}

	public function getPseudo() {
		return $this->pseudo;
	}
}