s9e\SourceOptimizer\TokenStream

Complexity

Total Complexity

68

Size/Duplication

Total Lines	480
Duplicated Lines	10.42 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

77.78%

Importance

Changes

0

29 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	is()	0	4	1
A	isAny()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	5	1
A	current()	0	4	1
A	currentText()	0	4	2
A	isNoise()	0	4	1
A	key()	0	4	1
A	next()	0	4	3
A	remove()	0	4	1
A	replace()	0	4	1
A	rewind()	0	4	1
A	seek()	0	4	1
A	valid()	0	4	1
D	canRemoveCurrentToken()	0	36	9
A	lookahead()	13	13	3
A	lookbehind()	13	13	3
C	normalizeSingleLineComments()	0	25	7
A	parse()	0	17	3
A	previous()	0	11	3
A	reset()	0	12	3
A	serialize()	0	10	3
A	skipNoise()	0	11	3
A	skipWhitespace()	0	11	3
A	skipTo()	12	12	4
A	skipToToken()	12	12	4

<?php

/**
* @package   s9e\SourceOptimizer
* @copyright Copyright (c) 2014-2017 The s9e Authors
* @license   http://www.opensource.org/licenses/mit-license.php The MIT License
*/
namespace s9e\SourceOptimizer;

use ArrayAccess;
use Iterator;

class TokenStream implements ArrayAccess, Iterator
{
	/**
	* @var integer Number of tokens
	*/
	protected $cnt;

	/**
	* @var string[] List of exact triplet of tokens to exclude from minification
	*/
	protected $excludeExact = [
		// 1 - - 1 and 1 + + 1 should not become 1--1 or 1++1
		'- -',
		'+ +',
		// $a - --$b should not become $a---$b
		'- --',
		'+ ++'
	];

	/**
	* @var bool Whether the source code needs to be reparsed before this stream is handed off to a
	*           new pass
	*/
	public $needsReparsing;

	/**
	* @var integer Current token index
	*/
	protected $offset;

	/**
	* @var bool Whether some tokens have been removed
	*/
	protected $sparse;

	/**
	* @var array<array|string> List of tokens
	*/
	protected $tokens;

	/**
	* Constructor
	*
	* @param string $src Original source code
	*/
	public function __construct($src)
	{
		$this->parse($src);
	}

	/**
	* Test whether current token can be removed safely
	*
	* @return bool
	*/
	public function canRemoveCurrentToken()
	{
		$prevToken = $this->lookbehind();
		$nextToken = $this->lookahead();

		if ($prevToken === false || $nextToken === false)
		{
			return true;
		}

		if (is_array($prevToken))
		{
			if ($prevToken[0] === T_COMMENT && substr($prevToken[1], 0, 2) === '//')
			{
				return false;
			}

			$prevToken = $prevToken[1];
		}
		if (is_array($nextToken))
		{
			$nextToken = $nextToken[1];
		}

		$str = $prevToken . ' ' . $nextToken;
		if (in_array($str, $this->excludeExact, true))
		{
			return false;
		}

		$delimiters = "\t\n\r !\"#$%&'()*+,-./:;<=>?@[\\]^`{|}~";
		$prevChar = substr($prevToken, -1);
		$nextChar = $nextToken[0];

		return (strpos($delimiters, $prevChar) !== false || strpos($delimiters, $nextChar) !== false);
	}

	/**
	* Test whether current token is the given type of token
	*
	* @param  integer $tokenValue
	* @return bool
	*/
	public function is($tokenValue)
	{
		return ($this->tokens[$this->offset][0] === $tokenValue);
	}

	/**
	* Test whether current token is any of the given types of token
	*
	* @param  integer[] $tokenValues
	* @return bool
	*/
	public function isAny(array $tokenValues)
	{
		return in_array($this->tokens[$this->offset][0], $tokenValues, true);
	}

	/**
	* Test whether there's a token at given offset
	*
	* @param  integer $offset
	* @return bool
	*/
	public function offsetExists($offset)
	{
		return isset($this->tokens[$offset]);
	}

	/**
	* Return the token stored at given offset
	*
	* @param  integer $offset
	* @return array|string
	*/
	public function offsetGet($offset)
	{
		return $this->tokens[$offset];
	}

	/**
	* Replace the token stored at given offset
	*
	* @param  integer      $offset
	* @param  array|string $token
	* @return void
	*/
	public function offsetSet($offset, $token)
	{
		$this->tokens[$offset] = $token;
	}

	/**
	* Remove the token stored at given offset
	*
	* @return void
	*/
	public function offsetUnset($offset)
	{
		unset($this->tokens[$offset]);
		$this->sparse = true;
	}

	/**
	* Return the current token
	*
	* @return array|string
	*/
	public function current()
	{
		return $this->tokens[$this->offset];
	}

	/**
	* Get current token's text
	*
	* @return string
	*/
	public function currentText()
	{
		return (is_array($this->tokens[$this->offset])) ? $this->tokens[$this->offset][1] : $this->tokens[$this->offset];
	}

	/**
	* Test whether current token is noise (whitespace or comment)
	*
	* @return bool
	*/
	public function isNoise()
	{
		return in_array($this->tokens[$this->offset][0], [T_COMMENT, T_DOC_COMMENT, T_WHITESPACE], true);
	}

	/**
	* Return the offset of current token
	*
	* @return integer
	*/
	public function key()
	{
		return $this->offset;
	}

	/**
	* Peek at the next token
	*
	* @return array|string|false
	*/
	public function lookahead()
	{
		$i = $this->offset;
		while (++$i < $this->cnt)
		{
			if (isset($this->tokens[$i]))
			{
				return $this->tokens[$i];
			}
		}

		return false;
	}

	/**
	* Peek at the previous token
	*
	* @return array|string|false
	*/
	public function lookbehind()
	{
		$i = $this->offset;
		while (--$i >= 0)
		{
			if (isset($this->tokens[$i]))
			{
				return $this->tokens[$i];
			}
		}

		return false;
	}

	/**
	* Move to the next token in the stream
	*
	* @return void
	*/
	public function next()
	{
		while (++$this->offset < $this->cnt && !isset($this->tokens[$this->offset]));
	}

	/**
	* Normalize the whitespace at the end of single-line comments
	*
	* Will remove the newline at the end of single-line comments and put it either in the next token
	* if it's a T_WHITESPACE or it will insert a T_WHITESPACE otherwise.
	*
	* @return void
	*/
	protected function normalizeSingleLineComments()
	{
		$keys = [];
		foreach ($this->tokens as $k => $token)
		{
			// Remove the newline at the end of comments to put it in the next token
			if ($token[0] === T_COMMENT && $token[1][1] === '/')
			{
				$this->tokens[$k][1] = rtrim($token[1], "\n");
				$keys[] = $k + 1;
			}
		}

		foreach (array_reverse($keys) as $k)
		{
			if (isset($this->tokens[$k]) && $this->tokens[$k][0] === T_WHITESPACE)
			{
				$this->tokens[$k][1] = "\n" . $this->tokens[$k][1];
			}
			else
			{
				array_splice($this->tokens, $k, 0, [[T_WHITESPACE, "\n"]]);
			}
		}
	}

	/**
	* Parse/tokenize given PHP source
	*
	* @param  string $src
	* @return void
	*/
	protected function parse($src)
	{
		$this->tokens = token_get_all($src);
		foreach ($this->tokens as $k => &$token)
		{
			if (is_array($token))
			{
				unset($token[2]);
			}
		}
		$this->normalizeSingleLineComments();

		$this->cnt = count($this->tokens);
		$this->offset = 0;
		$this->needsReparsing = false;
		$this->sparse = false;
	}

	/**
	* Move to the previous token in the stream
	*
	* @return void
	*/
	public function previous()
	{
		while ($this->offset > 0)
		{
			--$this->offset;
			if (isset($this->tokens[$this->offset]))
			{
				break;
			}
		}
	}

	/**
	* Remove current token
	*
	* @return void
	*/
	public function remove()
	{
		$this->offsetUnset($this->offset);
	}

	/**
	* Replace current token
	*
	* @param  array|string $token Token replacement
	* @return void
	*/
	public function replace($token)
	{
		$this->offsetSet($this->offset, $token);
	}

	/**
	* Reset this stream
	*
	* @return void
	*/
	public function reset()
	{
		$this->offset = 0;
		if ($this->needsReparsing)
		{
			$this->parse($this->serialize());
		}
		elseif ($this->sparse)
		{
			$this->tokens = array_values($this->tokens);
		}
	}

	/**
	* Rewind/reset this stream
	*
	* @return void
	*/
	public function rewind()
	{
		$this->reset();
	}

	/**
	* Move the stream to given offset
	*
	* @param  integer $offset
	* @return void
	*/
	public function seek($offset)
	{
		$this->offset = $offset;
	}

	/**
	* Serialize these tokens back to source code
	*
	* @return string
	*/
	public function serialize()
	{
		$src = '';
		foreach ($this->tokens as $token)
		{
			$src .= (is_array($token)) ? $token[1] : $token;
		}

		return $src;
	}

	/**
	* Skip all whitespace, comments and docblocks starting at current offset
	*
	* @return void
	*/
	public function skipNoise()
	{
		while ($this->valid())
		{
			if (!$this->isNoise())
			{
				break;
			}
			$this->next();
		}
	}

	/**
	* Skip all whitespace starting at current offset
	*
	* @return void
	*/
	public function skipWhitespace()
	{
		while ($this->offset < $this->cnt)
		{
			if ($this->tokens[$this->offset][0] !== T_WHITESPACE)
			{
				break;
			}
			++$this->offset;
		}
	}

	/**
	* Iterate through tokens until the stream reaches a token of given value or the end of stream
	*
	* @param  integer $tokenValue The target value, e.g. T_ELSE
	* @return bool                Whether a matching token was found
	*/
	public function skipTo($tokenValue)
	{
		while (++$this->offset < $this->cnt)
		{
			if (isset($this->tokens[$this->offset][0]) && $this->tokens[$this->offset][0] === $tokenValue)
			{
				return true;
			}
		}

		return false;
	}

	/**
	* Iterate through tokens until the stream reaches given token or the end of stream
	*
	* @param  array|string $token The target token, either a string or a [tokenValue, string] pair
	* @return bool                Whether a matching token was found
	*/
	public function skipToToken($token)
	{
		while (++$this->offset < $this->cnt)
		{
			if (isset($this->tokens[$this->offset]) && $this->tokens[$this->offset] === $token)
			{
				return true;
			}
		}

		return false;
	}

	/**
	* Test whether the stream is at a valid offset
	*
	* @return bool
	*/
	public function valid()
	{
		return ($this->offset < $this->cnt);
	}
}