Remorhaz\UniLex\Lexer\TokenMatcherTemplate::createContext()

Size

Total Lines	135
Code Lines	54

Duplication

Lines	0
Ratio	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	TokenMatcherTemplate.php$0 ➔ getBuffer()	0	3	1
A	TokenMatcherTemplate.php$0 ➔ getRegExp()	0	7	2
A	TokenMatcherTemplate.php$0 ➔ getSymbolString()	0	7	2
A	TokenMatcherTemplate.php$0 ➔ setNewToken()	0	5	1
A	TokenMatcherTemplate.php$0 ➔ setRegExps()	0	3	1
A	TokenMatcherTemplate.php$0 ➔ getSymbolList()	0	7	2
A	TokenMatcherTemplate.php$0 ➔ setMode()	0	5	1
A	TokenMatcherTemplate.php$0 ➔ setTokenAttribute()	0	7	1
A	TokenMatcherTemplate.php$0 ➔ getMode()	0	3	1
A	TokenMatcherTemplate.php$0 ➔ getToken()	0	3	1
A	TokenMatcherTemplate.php$0 ➔ __construct()	0	14	1
A	TokenMatcherTemplate.php$0 ➔ allowRegExps()	0	3	1

<?php

namespace Remorhaz\UniLex\Lexer;

use Remorhaz\UniLex\Exception;
use Remorhaz\UniLex\IO\CharBufferInterface;
use Remorhaz\UniLex\IO\TokenExtractInterface;

use function array_diff;
use function array_intersect;
use function array_key_first;
use function array_keys;
use function count;

abstract class TokenMatcherTemplate implements TokenMatcherInterface
{

    private $token;

    private $mode = self::DEFAULT_MODE;

    /**
     * @return Token
     * @throws Exception
     */
    public function getToken(): Token
    {
        if (!isset($this->token)) {
            throw new Exception("Token is not defined");
        }

        return $this->token;
    }

    protected function createContext(
        CharBufferInterface $buffer,
        TokenFactoryInterface $tokenFactory
    ): TokenMatcherContextInterface {
        $onConstruct = function (): void {
            unset($this->token);
        };
        $onSetNewToken = function (int $tokenType) use ($tokenFactory): void {
            $this->token = $tokenFactory->createToken($tokenType);
        };
        $onGetToken = function (): Token {
            return $this->getToken();
        };
        $onSetMode = function (string $mode): void {
            $this->mode = $mode;
        };
        $onGetMode = function (): string {
            return $this->mode;
        };

        return new class (
            $buffer,
            $onConstruct,
            $onSetNewToken,
            $onGetToken,
            $onSetMode,
            $onGetMode
        ) implements TokenMatcherContextInterface {

            private $buffer;

            private $onSetNewToken;

            private $onGetToken;

            private $onSetMode;

            private $onGetMode;

            private $regExps = [];

            public function __construct(
                CharBufferInterface $buffer,
                callable $onConstruct,
                callable $onSetNewToken,
                callable $onGetToken,
                callable $onSetMode,
                callable $onGetMode
            ) {
                $this->buffer = $buffer;
                $this->onSetNewToken = $onSetNewToken;
                $this->onGetToken = $onGetToken;
                $this->onSetMode = $onSetMode;
                $this->onGetMode = $onGetMode;
                call_user_func($onConstruct);
            }

            public function setNewToken(int $tokenType): TokenMatcherContextInterface
            {
                call_user_func($this->onSetNewToken, $tokenType);

                return $this;
            }

            /**
             * @param string $name
             * @param        $value
             * @return TokenMatcherContextInterface
             */
            public function setTokenAttribute(string $name, $value): TokenMatcherContextInterface
            {
                $this
                    ->getToken()
                    ->setAttribute($name, $value);

                return $this;
            }

            public function getToken(): Token
            {
                return call_user_func($this->onGetToken);
            }

            public function getBuffer(): CharBufferInterface
            {
                return $this->buffer;
            }

            public function getSymbolString(): string
            {
                $buffer = $this->getBuffer();
                if ($buffer instanceof TokenExtractInterface) {
                    return $buffer->getTokenAsString();
                }
                throw new Exception("Extracting strings is not supported by buffer");
            }

            public function getSymbolList(): array
            {
                $buffer = $this->getBuffer();
                if ($buffer instanceof TokenExtractInterface) {
                    return $buffer->getTokenAsArray();
                }
                throw new Exception("Extracting arrays is not supported by buffer");
            }

            public function getMode(): string
            {
                return call_user_func($this->onGetMode);
            }

            public function setMode(string $mode): TokenMatcherContextInterface
            {
                call_user_func($this->onSetMode, $mode);

                return $this;
            }

            public function setRegExps(string ...$regExps): void
            {
                $this->regExps = $regExps;
            }

            public function allowRegExps(string ...$regExps): void
            {
                $this->regExps = array_intersect($this->regExps, $regExps);
            }

            public function getRegExp(): string
            {
                if (count($this->regExps) == 1) {
                    return $this->regExps[array_key_first($this->regExps)];
                }

                throw new Exception("Target regular expression is undefined");
            }
        };
    }
}