nicoSWD\Rule\Compiler\StandardCompiler

Complexity

Total Complexity

25

Size/Duplication

Total Lines	113
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

<?php declare(strict_types=1);
use nicoSWD\Rule\TokenStream\Token\TokenOpeningParenthesis;
use nicoSWD\Rule\TokenStream\Token\Type\Logical;
use nicoSWD\Rule\TokenStream\Token\Type\Parenthesis;

final class StandardCompiler implements CompilerInterface
{
    private const OPENING_PARENTHESIS = '(';
    private const CLOSING_PARENTHESIS = ')';

    private string $output = '';
    private int $openParenthesis = 0;
    private int $closedParenthesis = 0;

    /** @throws ParserException */
    public function getCompiledRule(): string
    {
        if ($this->isIncompleteCondition()) {
            throw new ParserException('Incomplete condition');
        } elseif (!$this->numParenthesesMatch()) {
            throw new ParserException('Missing closing parenthesis');
        }

        return $this->output;
    }

    private function openParenthesis(): void
    {
        $this->openParenthesis++;
        $this->output .= self::OPENING_PARENTHESIS;
    }

    /** @throws ParserException */
    private function closeParenthesis(): void
    {
        if ($this->openParenthesis < 1) {
            throw new ParserException('Missing opening parenthesis');
        }

        $this->closedParenthesis++;
        $this->output .= self::CLOSING_PARENTHESIS;
    }

    /** @throws ParserException */
    public function addParentheses(BaseToken & Parenthesis $token): void

A parse error occurred: Syntax error, unexpected T_STRING, expecting T_VARIABLE on line 59 at column 47

    {
        if ($token instanceof TokenOpeningParenthesis) {
            if (!$this->expectOpeningParenthesis()) {
                throw ParserException::unexpectedToken($token);
            }
            $this->openParenthesis();
        } else {
            $this->closeParenthesis();
        }
    }

    /** @throws ParserException */
    public function addLogical(BaseToken & Logical $token): void
    {
        if (Operator::tryFrom($this->getLastChar()) !== null) {
            throw ParserException::unexpectedToken($token);
        }

        if ($token instanceof TokenAnd) {
            $this->output .= Operator::LOGICAL_AND->value;
        } else {
            $this->output .= Operator::LOGICAL_OR->value;
        }
    }

    /** @throws MissingOperatorException */
    public function addBoolean(bool $bool): void
    {
        if (Boolean::tryFrom($this->getLastChar()) !== null) {
            throw new MissingOperatorException();
        }

        $this->output .= Boolean::fromBool($bool)->value;
    }

    private function numParenthesesMatch(): bool
    {
        return $this->openParenthesis === $this->closedParenthesis;
    }

    private function isIncompleteCondition(): bool
    {
        return Operator::tryFrom($this->getLastChar()) !== null;
    }

    private function expectOpeningParenthesis(): bool
    {
        $lastChar = $this->getLastChar();

        return
            $lastChar === '' ||
            $lastChar === self::OPENING_PARENTHESIS ||
            Operator::tryFrom($lastChar) !== null;
    }

    private function getLastChar(): string
    {
        return substr($this->output, offset: -1);
    }
}