nicoSWD\Rule\Parser\Parser

Complexity

Total Complexity

18

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
D	parse()	0	33	9
A	assignOperator()	0	10	3
B	evaluateExpression()	0	24	5

<?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\Rule\Parser;

use nicoSWD\Rule\Compiler\CompilerInterface;
use nicoSWD\Rule\Compiler\CompilerFactoryInterface;
use nicoSWD\Rule\Compiler\Exception\MissingOperatorException;
use nicoSWD\Rule\Expression\ExpressionFactoryInterface;
use nicoSWD\Rule\TokenStream\AST;
use nicoSWD\Rule\TokenStream\Token\BaseToken;
use nicoSWD\Rule\TokenStream\Token\TokenType;
use SplStack;

class Parser
{
    /** @var AST */
    private $ast;
    /** @var ExpressionFactoryInterface */
    private $expressionFactory;
    /** @var CompilerFactoryInterface */
    private $compilerFactory;
    /** @var null|BaseToken */
    private $operator = null;

    public function __construct(
        AST $ast,
        ExpressionFactoryInterface $expressionFactory,
        CompilerFactoryInterface $compilerFactory
    ) {
        $this->ast = $ast;
        $this->expressionFactory = $expressionFactory;
        $this->compilerFactory = $compilerFactory;
    }

    public function parse(string $rule): string
    {
        $compiler = $this->compilerFactory->create();
        $this->operator = null;
        $values = new SplStack();

        foreach ($this->ast->getStream($rule) as $token) {
            switch ($token->getType()) {
                case TokenType::VALUE:
                case TokenType::INT_VALUE:
                    $values->push($token->getValue());
                    break;
                case TokenType::LOGICAL:
                    $compiler->addLogical($token);
                    continue 2;
                case TokenType::PARENTHESIS:
                    $compiler->addParentheses($token);
                    continue 2;
                case TokenType::OPERATOR:
                    $this->assignOperator($token, $values);
                    continue 2;
                case TokenType::COMMENT:
                case TokenType::SPACE:
                    continue 2;
                default:
                    throw Exception\ParserException::unknownToken($token);
            }

            $this->evaluateExpression($values, $compiler);
        }

        return $compiler->getCompiledRule();
    }

    private function assignOperator(BaseToken $token, SplStack $values)
    {
        if (isset($this->operator)) {
            throw Exception\ParserException::unexpectedToken($token);
        } elseif ($values->isEmpty()) {
            throw Exception\ParserException::incompleteExpression($token);
        }

        $this->operator = $token;
    }

    private function evaluateExpression(SplStack $values, CompilerInterface $compiler)
    {
        if (!isset($this->operator) || $values->count() !== 2) {
            return;
        }

        list($rightValue, $leftValue) = $values;

        try {
            $expression = $this->expressionFactory->createFromOperator($this->operator);

            $compiler->addBoolean(
                $expression->evaluate($leftValue, $rightValue)
            );
        } catch (MissingOperatorException $e) {
            throw new Exception\ParserException('Missing operator');
        }

        do {
            $values->pop();
        } while (!$values->isEmpty());

        unset($this->operator);
    }
}