nicoSWD\Rule\TokenStream\CallableUserMethod

Complexity

Total Complexity

11

Size/Duplication

Total Lines	82
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

<?php declare(strict_types=1);
final class CallableUserMethod implements CallableUserFunctionInterface
{
    private const MAGIC_METHOD_PREFIX = '__';

    private readonly TokenFactory $tokenFactory;

A parse error occurred: Syntax error, unexpected T_STRING, expecting T_VARIABLE on line 19 at column 21

    private readonly Closure $callable;

    private array $methodPrefixes = ['', 'get', 'is', 'get_', 'is_'];

    /**
     * @throws Exception\UndefinedMethodException
     * @throws Exception\ForbiddenMethodException
     */
    public function __construct(BaseToken $token, TokenFactory $tokenFactory, string $methodName)
    {
        $this->tokenFactory = $tokenFactory;
        $this->callable = $this->getCallable($token, $methodName);
    }

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

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

    /**
     * @throws Exception\UndefinedMethodException
     * @throws Exception\ForbiddenMethodException
     */
    private function getCallable(BaseToken $token, string $methodName): Closure
    {
        $object = $token->getValue();

        if (property_exists($object, $methodName)) {
            return static fn (): mixed => $object->{$methodName};
        }

        $method = $this->findCallableMethod($object, $methodName);

        return fn (?BaseToken ...$params): mixed => $method(
            ...$this->getTokenValues($params)
        );
    }

    /**
     * @throws Exception\UndefinedMethodException
     * @throws Exception\ForbiddenMethodException
     */
    private function findCallableMethod(object $object, string $methodName): callable
    {
        $this->assertNonMagicMethod($methodName);
        $index = 0;

        do {
            if (!isset($this->methodPrefixes[$index])) {
                throw new Exception\UndefinedMethodException();
            }

            $callableMethod = $this->methodPrefixes[$index++] . $methodName;
        } while (!is_callable([$object, $callableMethod]));

        return [$object, $callableMethod];
    }

    private function getTokenValues(array $params): array
    {
        return array_map(static fn (BaseToken $token): mixed => $token->getValue(), $params);
    }

    /** @throws Exception\ForbiddenMethodException */
    private function assertNonMagicMethod(string $methodName): void
    {
        if (str_starts_with($methodName, self::MAGIC_METHOD_PREFIX)) {
            throw new Exception\ForbiddenMethodException();
        }
    }
}