Go\Aop\Framework\StaticClosureMethodInvocation

Complexity

Total Complexity

8

Size/Duplication

Total Lines	86
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes

0

<?php
 */
final class StaticClosureMethodInvocation extends AbstractMethodInvocation
{
    /**
     * Closure to use
     */
    protected ?Closure $closureToCall = null;

This code did not parse for me. Apparently, there is an error somewhere around this line:

Syntax error, unexpected '?', expecting T_FUNCTION or T_CONST

    /**
     * Previous scope of invocation
     */
    protected ?string $previousScope = null;

    /**
     * For static calls we store given argument as 'scope' property
     */
    protected static string $propertyName = 'scope';

    /**
     * Proceeds all registered advices for the static method and returns an invocation result
     */
    public function proceed()
    {
        if (isset($this->advices[$this->current])) {
            $currentInterceptor = $this->advices[$this->current++];

            return $currentInterceptor->invoke($this);
        }

        // Rebind the closure if scope (class name) was changed since last time
        if ($this->previousScope !== $this->scope) {
            if ($this->closureToCall === null) {
                $this->closureToCall = self::getStaticInvoker(
                    $this->reflectionMethod->class,
                    $this->reflectionMethod->name
                );
            }
            $this->closureToCall = $this->closureToCall->bindTo(null, $this->scope);
            $this->previousScope = $this->scope;
        }

        return ($this->closureToCall)($this->arguments);
    }

    /**
     * Returns static method invoker for the concrete method in the class
     */
    protected static function getStaticInvoker(string $className, string $methodName): Closure
    {
        return fn(array $args) => forward_static_call_array([$className, $methodName], $args);
    }

    /**
     * Checks if the current joinpoint is dynamic or static
     *
     * Dynamic joinpoint contains a reference to an object that can be received via getThis() method call
     *
     * @see ClassJoinpoint::getThis()
     */
    final public function isDynamic(): bool
    {
        return false;
    }

    /**
     * Returns the object for which current joinpoint is invoked
     *
     * @return object Instance of object or null for static call/unavailable context
     */
    final public function getThis(): ?object
    {
        return null;
    }

    /**
     * Returns the static scope name (class name) of this joinpoint.
     */
    final public function getScope(): string
    {
        // $this->scope contains the current class scope that was received via static::class
        return $this->scope;
    }
}