CondParse\TokenMap

Complexity

Total Complexity

11

Size/Duplication

Total Lines	147
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	registerOperand()	0	5	1
A	registerOperator()	0	5	1
A	registerToken()	0	7	1
A	getTokens()	0	4	1
A	compareOperatorPrecedence()	0	6	1
A	isOperand()	0	4	1
A	buildOperand()	0	4	1
A	verifyTokenConfig()	0	19	4

<?php


namespace CondParse;


use CondParse\Exception\TokenMapException;
use CondParse\Operand\AndOperator;
use CondParse\Operand\BooleanOperand;
use CondParse\Operand\NotOperand;
use CondParse\Operand\OrOperator;

class TokenMap
{
    const TOKEN_NOT = 'NOT';
    const TOKEN_AND = 'AND';
    const TOKEN_OR = 'OR';
    const TOKEN_BRACKET_OPEN = 'BRACKET_OPEN';
    const TOKEN_BRACKET_CLOSE = 'BRACKET_CLOSE';
    const TOKEN_TRUE = 'TRUE';
    const TOKEN_FALSE = 'FALSE';
    const TOKEN_WHITESPACE = 'WHITESPACE';

    const DEFAULT_TOKENS = [
        self::TOKEN_NOT => '\!',
        self::TOKEN_AND => '&&',
        self::TOKEN_OR => '\|\|',
        self::TOKEN_BRACKET_OPEN => '\(',
        self::TOKEN_BRACKET_CLOSE => '\)',
        self::TOKEN_TRUE => 'true',
        self::TOKEN_FALSE => 'false',
        self::TOKEN_WHITESPACE => '\s+'
    ];

    const DEFAULT_OPERAND_TOKENS = [
        self::TOKEN_TRUE, self::TOKEN_FALSE
    ];

    const DEFAULT_OPERATOR_PRECEDENCE = [
        self::TOKEN_BRACKET_OPEN => -1,
        self::TOKEN_BRACKET_CLOSE => -1,
        self::TOKEN_OR => 100,
        self::TOKEN_AND => 1000,
        self::TOKEN_NOT => 10000
    ];

    const DEFAULT_TOKEN_CLASSES = [
        self::TOKEN_AND => AndOperator::class,
        self::TOKEN_OR => OrOperator::class,
        self::TOKEN_TRUE => BooleanOperand::class,
        self::TOKEN_FALSE => BooleanOperand::class,
        self::TOKEN_NOT => NotOperand::class
    ];

    private $tokenList = self::DEFAULT_TOKENS;
    private $operandTokens = self::DEFAULT_OPERAND_TOKENS;
    private $operatorPrecedence = self::DEFAULT_OPERATOR_PRECEDENCE;
    private $tokenClasses = self::DEFAULT_TOKEN_CLASSES;

    /**
     * @param string $name
     * @param string $regex
     * @param string $class
     */
    public function registerOperand($name, $regex, $class)
    {
        $this->registerToken($name, $regex, $class);
        $this->operandTokens[] = $name;
    }

    /**
     * @param string $name
     * @param string $regex
     * @param int $precedence
     * @param string $class
     */
    public function registerOperator($name, $regex, $precedence, $class)
    {
        $this->registerToken($name, $regex, $class);
        $this->operatorPrecedence[$name] = $precedence;
    }

    /**
     * @param string $name
     * @param string $regex
     * @param string $class
     * @throws TokenMapException
     */
    protected function registerToken($name, $regex, $class)
    {
        $this->verifyTokenConfig($name, $class);

        $this->tokenList[$name] = $regex;
        $this->tokenClasses[$name] = $class;
    }

    /**
     * @return string[]
     */
    public function getTokens()
    {
        return $this->tokenList;
    }

    /**
     * @param LexerToken $leftLexerToken
     * @param LexerToken $rightLexerToken
     * @return int
     */
    public function compareOperatorPrecedence(LexerToken $leftLexerToken, LexerToken $rightLexerToken)
    {
        return
            $this->operatorPrecedence[$leftLexerToken->getToken()]
            - $this->operatorPrecedence[$rightLexerToken->getToken()];
    }

    /**
     * @param LexerToken $lexerToken
     * @return bool
     */
    public function isOperand(LexerToken $lexerToken)
    {
        return in_array($lexerToken->getToken(), $this->operandTokens);
    }

    /**
     * @param LexerToken $lexerToken
     * @return OperandInterface
     */
    public function buildOperand(LexerToken $lexerToken)
    {
        return new $this->tokenClasses[$lexerToken->getToken()]($lexerToken);
    }

    /**
     * @param string $name
     * @param string $class
     * @throws TokenMapException
     */
    protected function verifyTokenConfig($name, $class)
    {
        if (!is_string($name)) {
            throw new TokenMapException('Can\'t register token, name must be string');
        }

        if (isset($this->tokenList[$name])) {
            throw new TokenMapException(sprintf(
                'Token <%s> already defined with regex <%s>',
                $name, $this->tokenList[$name]
            ));
        }

        if (!is_subclass_of($class, OperandInterface::class)) {
            throw new TokenMapException(sprintf(
                'Token <%s> with class <%s> must implement OperandInterface', $name, $class
            ));
        }
    }
}