nicoSWD\Rule\TokenStream\AST::getCallableUserObject()

Complexity

Conditions	1
Paths	1

Size

Total Lines

52

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	23
CRAP Score	1

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	AST.php$0 ➔ __construct()	0	5	1
B	AST.php$0 ➔ getCallable()	0	25	6
A	AST.php$0 ➔ call()	0	8	1

<?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\TokenStream;

use Closure;
use InvalidArgumentException;
use nicoSWD\Rule\Grammar\CallableUserFunctionInterface;
use nicoSWD\Rule\Parser\Exception\ParserException;
use nicoSWD\Rule\TokenStream\Exception\UndefinedVariableException;
use nicoSWD\Rule\TokenStream\Token\BaseToken;
use nicoSWD\Rule\TokenStream\Token\TokenFactory;
use nicoSWD\Rule\Tokenizer\TokenizerInterface;
use nicoSWD\Rule\TokenStream\Token\TokenObject;

class AST
{
    /** @var TokenizerInterface */
    private $tokenizer;
    /** @var TokenFactory */
    private $tokenFactory;
    /** @var TokenStreamFactory */
    private $tokenStreamFactory;
    /** @var Closure[] */
    private $functions = [];
    /** @var string[] */
    private $methods = [];
    /** @var mixed[] */
    private $variables = [];

    public function __construct(
        TokenizerInterface $tokenizer,
        TokenFactory $tokenFactory,
        TokenStreamFactory $tokenStreamFactory
    ) {
        $this->tokenizer = $tokenizer;
        $this->tokenFactory = $tokenFactory;
        $this->tokenStreamFactory = $tokenStreamFactory;
    }

    public function getStream(string $rule): TokenStream
    {
        return $this->tokenStreamFactory->create($this->tokenizer->tokenize($rule), $this);
    }

    public function getMethod(string $methodName, BaseToken $token): CallableUserFunctionInterface
    {
        if ($token instanceof TokenObject) {
            return $this->getCallableUserObject($token, $methodName);
        }

        if (empty($this->methods)) {
            $this->registerMethods();
        }

        if (!isset($this->methods[$methodName])) {
            throw new Exception\UndefinedMethodException($methodName);
        }

        return new $this->methods[$methodName]($token);
    }

    private function registerMethods()
    {
        $this->methods = $this->tokenizer->getGrammar()->getInternalMethods();
    }

    public function setVariables(array $variables)
    {
        $this->variables = $variables;
    }

    public function getVariable(string $variableName): BaseToken
    {
        if (!$this->variableExists($variableName)) {
            throw new UndefinedVariableException($variableName);
        }

        return $this->tokenFactory->createFromPHPType($this->variables[$variableName]);
    }

    public function variableExists(string $variableName): bool
    {
        return array_key_exists($variableName, $this->variables);
    }

    public function getFunction(string $functionName): Closure
    {
        if (empty($this->functions)) {
            $this->registerFunctions();
        }

        if (!isset($this->functions[$functionName])) {
            throw new Exception\UndefinedFunctionException($functionName);
        }

        return $this->functions[$functionName];
    }

    private function registerFunctionClass(string $functionName, string $className)
    {
        $this->functions[$functionName] = function (BaseToken ...$args) use ($className): BaseToken {
            $function = new $className();

            if (!$function instanceof CallableUserFunctionInterface) {
                throw new InvalidArgumentException(
                    sprintf(
                        "%s must be an instance of %s",
                        $className,
                        CallableUserFunctionInterface::class
                    )
                );
            }

            return $function->call(...$args);

$args is of type array<integer,object<nicoSWD\Rule\TokenStream\Token\BaseToken>>, but the function expects a null|object<nicoSWD\Rule\TokenStream\Token\BaseToken>.

        };
    }

    private function registerFunctions()
    {
        foreach ($this->tokenizer->getGrammar()->getInternalFunctions() as $functionName => $className) {
            $this->registerFunctionClass($functionName, $className);
        }
    }

    private function getCallableUserObject(BaseToken $token, string $methodName): CallableUserFunctionInterface
    {
        return new class ($token, $this->tokenFactory, $methodName) implements CallableUserFunctionInterface {
            /** @var TokenFactory */
            private $tokenFactory;
            /** @var Closure */
            private $callable;
            /** @var array */
            private $variations = ['get', 'is', ''];

            public function __construct(BaseToken $token, TokenFactory $tokenFactory, string $methodName)
            {
                $this->tokenFactory = $tokenFactory;
                $this->callable = $this->getCallable($token, $methodName);
            }

            private function getCallable(BaseToken $token, string $methodName): Closure
            {
                $object = $token->getValue();

                if (property_exists($object, $methodName)) {
                    return function () use ($object, $methodName) {
                        return $object->{$methodName};
                    };
                }

                $method[0] = $object;

$method was never initialized. Although not strictly required by PHP, it is generally a good practice to add $method = array(); before regardless.

                $index = 0;

                do {
                    if (!isset($this->variations[$index])) {
                        throw ParserException::undefinedMethod($methodName, $token);
                    }

                    $method[1] = $this->variations[$index] . $methodName;
                } while (!is_callable($method) && isset($this->variations[$index++]));

                return function (BaseToken $param = null) use ($method) {
                    return $method($param ? $param->getValue() : null);
                };
            }

            public function call(BaseToken $param = null): BaseToken
            {
                $callable = $this->callable;

                return $this->tokenFactory->createFromPHPType(
                    $callable($param)
                );
            }
        };
    }
}