nicoSWD\Rules\AST

Complexity

Total Complexity

14

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	valid()	0	4	1
A	getVariable()	0	15	2
A	__construct()	0	6	1
A	next()	0	4	1
A	key()	0	4	1
A	rewind()	0	4	1
A	getStack()	0	4	1
B	current()	0	24	6

<?php

/**
 * @license     http://opensource.org/licenses/mit-license.php MIT
 * @link        https://github.com/nicoSWD
 * @author      Nicolas Oelgart <nico@oelgart.com>
 */
declare(strict_types=1);

namespace nicoSWD\Rules;

use Iterator;
use nicoSWD\Rules\Tokens\{
    BaseToken,
    TokenFactory,
    TokenFunction,
    TokenOpeningArray,
    TokenRegex,
    TokenString,
    TokenVariable
};
use nicoSWD\Rules\AST\Nodes\{
    NodeArray,
    NodeFunction,
    NodeString,
    NodeVariable
};

final class AST implements Iterator
{
    /**
     * @var Parser
     */
    public $parser;

    /**
     * @var Stack
     */
    protected $stack;

    /**
     * @var mixed[]
     */
    protected $variables = [];

    /**
     * @param Stack  $stack
     * @param Parser $parser
     */
    public function __construct(Stack $stack, Parser $parser)
    {
        $this->stack = $stack;
        $this->variables = $parser->variables;
        $this->parser = $parser;
    }

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

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

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

        switch (true) {
            default:
                return $current;
            case $current instanceof TokenString:
            case $current instanceof TokenRegex:
                $current = new NodeString($this);
                break;
            case $current instanceof TokenOpeningArray:
                $current = new NodeArray($this);
                break;
            case $current instanceof TokenVariable:
                $current = new NodeVariable($this);
                break;
            case $current instanceof TokenFunction:
                $current = new NodeFunction($this);
                break;
        }

        return $current->getNode();
    }

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

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

    /**
     * @throws Exceptions\ParserException
     */
    public function getVariable(string $name) : BaseToken
    {
        if (!array_key_exists($name, $this->variables)) {
            $token = $this->stack->current();

            throw new Exceptions\ParserException(sprintf(
                'Undefined variable "%s" at position %d on line %d',
                $name,
                $token->getPosition(),
                $token->getLine()
            ));
        }

        return TokenFactory::createFromPHPType($this->variables[$name]);
    }

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