Ray\Aop\Aspect

Complexity

Total Complexity

33

Size/Duplication

Total Lines	191
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	bind()	0	6	1
A	weave()	0	8	2
A	newInstanceWithPecl()	0	8	1
A	newInstance()	0	9	3
A	createBind()	0	20	5
A	applyInterceptors()	0	13	4
A	processClass()	0	16	5
A	newInstanceWithPhp()	0	10	2
A	scanAndCompile()	0	18	5
A	__construct()	0	3	1
A	getClassNameFromFile()	0	17	4

<?php

declare(strict_types=1);

namespace Ray\Aop;

use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use ReflectionClass;

This use statement conflicts with another class in this namespace, Ray\Aop\ReflectionClass. Consider defining an alias.

use ReflectionMethod;

This use statement conflicts with another class in this namespace, Ray\Aop\ReflectionMethod. Consider defining an alias.

use RuntimeException;
use SplFileInfo;

use function array_keys;
use function array_slice;
use function assert;
use function basename;
use function class_exists;
use function count;
use function end;
use function extension_loaded;
use function get_declared_classes;
use function method_intercept; // @phpstan-ignore-line

The function method_intercept was not found. Maybe you did not declare it correctly or list all dependencies?

use function strcasecmp;
use function sys_get_temp_dir;

final class Aspect
{
    /** @var string|null */
    private $tmpDir;

    /** @var array<array{classMatcher: AbstractMatcher, methodMatcher: AbstractMatcher, interceptors: array<MethodInterceptor>}> */
    private $matchers = [];

    /** @var array<string, array<string, array<array-key, MethodInterceptor>>> */

The doc comment array<string, array<string, array<array-key, MethodInterceptor>>> at position 10 could not be parsed: Unknown type name 'array-key' at position 10 in array<string, array<string, array<array-key, MethodInterceptor>>>.

    private $bound = [];

    public function __construct(?string $tmpDir = null)
    {
        $this->tmpDir = $tmpDir ?? sys_get_temp_dir();
    }

    /** @param array<MethodInterceptor> $interceptors */
    public function bind(AbstractMatcher $classMatcher, AbstractMatcher $methodMatcher, array $interceptors): void
    {
        $this->matchers[] = [
            'classMatcher' => $classMatcher,
            'methodMatcher' => $methodMatcher,
            'interceptors' => $interceptors,
        ];
    }

    public function weave(string $classDir): void
    {
        if (! extension_loaded('rayaop')) {
            throw new RuntimeException('Ray.Aop extension is not loaded. Cannot use weave() method.');
        }

        $this->scanAndCompile($classDir);
        $this->applyInterceptors();
    }

    private function scanAndCompile(string $classDir): void
    {
        $files = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($classDir)
        );

        /** @var SplFileInfo[] $files */
        foreach ($files as $file) {
            if ($file->isDir() || $file->getExtension() !== 'php') {
                continue;
            }

            $className = $this->getClassNameFromFile($file->getPathname());
            if ($className === null) {
                continue;
            }

            $this->processClass($className);
        }
    }

    private function getClassNameFromFile(string $file): ?string
    {
        $declaredClasses = get_declared_classes();
        $previousCount = count($declaredClasses);

        /** @psalm-suppress UnresolvableInclude */
        require_once $file;

        $newClasses = array_slice(get_declared_classes(), $previousCount);

        foreach ($newClasses as $class) {
            if (strcasecmp(basename($file, '.php'), $class) === 0) {
                return $class;
            }
        }

        return $newClasses ? end($newClasses) : null;
    }

    private function processClass(string $className): void
    {
        assert(class_exists($className));
        $reflection = new ReflectionClass($className);

        foreach ($this->matchers as $matcher) {
            if (! $matcher['classMatcher']->matchesClass($reflection, $matcher['classMatcher']->getArguments())) {
                continue;
            }

            foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
                if (! $matcher['methodMatcher']->matchesMethod($method, $matcher['methodMatcher']->getArguments())) {
                    continue;
                }

                $this->bound[$className][$method->getName()] = $matcher['interceptors'];
            }
        }
    }

    private function applyInterceptors(): void
    {
        if (! extension_loaded('rayaop')) {
            throw new RuntimeException('Ray.Aop extension is not loaded');
        }

        $dispatcher = new PeclDispatcher($this->bound);
        foreach ($this->bound as $className => $methods) {
            $methodNames = array_keys($methods);
            foreach ($methodNames as $methodName) {
                assert($dispatcher instanceof MethodInterceptorInterface);
                /** @psalm-suppress UndefinedFunction PECL-created function */
                method_intercept($className, $methodName, $dispatcher); // @phpstan-ignore-line

The function method_intercept was not found. Maybe you did not declare it correctly or list all dependencies?

            }
        }
    }

    /**
     * @param class-string<T> $className

The doc comment class-string<T> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>.

     * @param list<mixed>     $args
     *
     * @return T
     *
     * @template T of object
     */
    public function newInstance(string $className, array $args = []): object
    {
        $reflection = new ReflectionClass($className);

        if ($reflection->isFinal() && extension_loaded('rayaop')) {
            return $this->newInstanceWithPecl($className, $args);
        }

        return $this->newInstanceWithPhp($className, $args);
    }

    /**
     * @param class-string<T> $className

The doc comment class-string<T> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>.

     * @param array<mixed>    $args
     *
     * @return T
     *
     * @template T of object
     */
    private function newInstanceWithPecl(string $className, array $args): object
    {
        /** @psalm-suppress MixedMethodCall */
        $instance = new $className(...$args);
        $this->processClass($className);
        $this->applyInterceptors();

        return $instance;
    }

    /**
     * @param class-string<T> $className

The doc comment class-string<T> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<T>.

     * @param list<mixed>     $args
     *
     * @return T
     *
     * @template T of object
     */
    private function newInstanceWithPhp(string $className, array $args): object
    {
        if ($this->tmpDir === null) {
            throw new RuntimeException('Temporary directory is not set. It is required for PHP-based AOP.');
        }

        $bind = $this->createBind($className);
        $weaver = new Weaver($bind, $this->tmpDir);

        return $weaver->newInstance($className, $args);
    }

    /** @param class-string $className */

The doc comment class-string at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string.

    private function createBind(string $className): Bind
    {
        $bind = new Bind();
        $reflection = new \Ray\Aop\ReflectionClass($className);

        foreach ($this->matchers as $matcher) {
            if (! $matcher['classMatcher']->matchesClass($reflection, $matcher['classMatcher']->getArguments())) {
                continue;
            }

            foreach ($reflection->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
                if (! $matcher['methodMatcher']->matchesMethod($method, $matcher['methodMatcher']->getArguments())) {
                    continue;
                }

                $bind->bindInterceptors($method->getName(), $matcher['interceptors']);
            }
        }

        return $bind;
    }
}