Transphporm\Parser\Tokens

Complexity

Total Complexity

32

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	count()	0	3	1
A	current()	0	3	1
A	key()	0	3	1
A	next()	0	3	1
A	valid()	0	3	1
A	rewind()	0	3	1
A	getKeysOfTokenType()	0	3	1
A	getKeyToSlice()	0	7	4
A	from()	0	3	1
A	to()	0	3	1
A	sliceTokens()	0	7	4
A	skip()	0	3	1
A	splitOnToken()	0	12	3
A	trim()	0	12	4
A	removeLine()	0	5	2
A	read()	0	3	2
A	type()	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\Parser;
class Tokens implements \Iterator, \Countable {
    private $tokens;
    private $iterator = 0;

    public function __construct(array $tokens) {
        $this->tokens = $tokens;
    }

    public function count() {
        return count($this->tokens);
    }

    // Iterator Functions
    public function current() {
        return $this->tokens[$this->iterator];
    }

    public function key() {
        return $this->iterator;
    }

    public function next() {
        ++$this->iterator;
	}

	public function valid() {
		return isset($this->tokens[$this->iterator]);
	}

	public function rewind() {
		$this->iterator = 0;
	}

    private function getKeysOfTokenType($tokenType) {
        return array_keys(array_column($this->tokens, 'type'), $tokenType);
    }

    private function getKeyToSlice($tokenType) {
        $keys = $this->getKeysOfTokenType($tokenType);
        if (empty($keys)) return false;
        $key = $keys[0];
        for ($i = 0; $key < $this->iterator && isset($keys[$i]); $i++) $key = $keys[$i];
        return $key;
    }

    public function from($tokenType, $inclusive = false) {
        return $this->sliceTokens($tokenType, "from", !$inclusive);
    }

    public function to($tokenType, $inclusive = false) {
        return $this->sliceTokens($tokenType, "to", $inclusive);
    }

    private function sliceTokens($tokenType, $type, $increment = false) {
        $key = $this->getKeyToSlice($tokenType);
        if ($key === false) return new Tokens([]);
        if ($increment) $key++;
        if ($type === "from") return new Tokens(array_slice($this->tokens, $key));
        else return new Tokens(array_slice($this->tokens, $this->iterator, $key));
    }

    public function skip($count) {
        $this->iterator += $count;
    }

    public function splitOnToken($tokenType) {
        $splitTokens = [];
		$i = 0;
		foreach ($this->tokens as $token) {
			if ($token['type'] === $tokenType) $i++;
			else $splitTokens[$i][] = $token;
		}
        return array_map(function ($tokens) {
            return new Tokens($tokens);
        }, $splitTokens);
		//return $splitTokens;
    }

    public function trim() {
        $tokens = $this->tokens;
        // Remove end whitespace
        while (end($tokens)['type'] === Tokenizer::WHITESPACE) {
            array_pop($tokens);
        }
        // Remove begining whitespace
        while (isset($tokens[0]) && $tokens[0]['type'] === Tokenizer::WHITESPACE) {
            array_shift($tokens);
        }
        return new Tokens($tokens);
    }

    public function removeLine() {
        $tokens = $this->tokens;
        foreach ($tokens as &$token) unset($token['line']);
        return new Tokens($tokens);
    }

    public function read($offset = 0) {
        return isset($this->tokens[$offset]) ? $this->tokens[$offset]['value'] : false;
    }

    public function type($offset = 0) {
        return isset($this->tokens[$offset]) ? $this->tokens[$offset]['type'] : false;
    }
}