nicoSWD\Rules\TokenStream

Complexity

Total Complexity

18

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

95.65%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	8	1
A	next()	0	4	1
A	valid()	0	4	1
C	current()	0	25	7
A	key()	0	4	1
A	rewind()	0	4	1
A	getVariable()	0	8	2
A	getFunction()	0	4	1
A	getMethod()	0	8	2
A	getStack()	0	4	1

<?php

declare(strict_types=1);

/**
 * @license     http://opensource.org/licenses/mit-license.php MIT
 * @link        https://github.com/nicoSWD
 * @author      Nicolas Oelgart <nico@oelgart.com>
 */
namespace nicoSWD\Rules;

use Closure;
use Iterator;
use nicoSWD\Rules\Core\CallableUserFunction;
use nicoSWD\Rules\Tokens;
use nicoSWD\Rules\AST\Nodes;

class TokenStream implements Iterator
{
    /** @var Stack */
    protected $stack;

    /** @var AST */
    private $ast;

    public function create(Stack $stack, AST $ast)
    {
        $stream = new self();
        $stream->stack = $stack;
        $stream->ast = $ast;

        return $stream;
    }

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

    public function valid(): bool
    {
        return $this->stack->valid();
    }

    public function current()
    {
        $current = $this->stack->current();

        switch (get_class($current)) {
            default:
                return $current;
            case Tokens\TokenString::class:
            case Tokens\TokenEncapsedString::class:
            case Tokens\TokenRegex::class:
                $current = new Nodes\NodeString($this);
                break;
            case Tokens\TokenOpeningArray::class:
                $current = new Nodes\NodeArray($this);
                break;
            case Tokens\TokenVariable::class:
                $current = new Nodes\NodeVariable($this);
                break;
            case Tokens\TokenFunction::class:
                $current = new Nodes\NodeFunction($this);
                break;
        }

        return $current->getNode();
    }

    public function key(): int
    {
       return $this->stack->key();
    }

    public function rewind()
    {
        $this->stack->rewind();
    }

    public function getVariable(string $name): Tokens\BaseToken
    {
        try {
            return $this->ast->getVariable($name);
        } catch (Exceptions\UndefinedVariableException $e) {
            throw Exceptions\ParserException::undefinedVariable($name, $this->stack->current());
        }
    }

    public function getFunction(string $functionName): Closure
    {
        return $this->ast->getFunction($functionName);
    }

    public function getMethod(string $methodName, Tokens\BaseToken $token): CallableUserFunction
    {
        try {
            return $this->ast->getMethod($methodName, $token);
        } catch (Exceptions\UndefinedMethodException $e) {
            throw Exceptions\ParserException::undefinedMethod($methodName, $this->stack->current());
        }
    }

    public function getStack(): Stack
    {
        return $this->stack;
    }
}