Extract PECL code from Aspect to PeclAspect

.github/workflows/continuous-integration-pecl.yml

@@ -70,6 +70,11 @@ jobs:
         run: |
           php -dextension=./ext-rayaop/modules/rayaop.so vendor/bin/phpunit --coverage-clover=coverage.xml
 
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+
       - name: Run Valgrind memory check
         if: steps.build_extension.outcome == 'failure' || steps.run_pecl_demo.outcome == 'failure'
         run: |
@@ -115,3 +120,6 @@ jobs:
             echo "Build extension and run failed. Please check the logs for more information."
             exit 1
           fi
+
+      - name: Run additional script
+        run: php 'demo/05-pecl.php'

demo/run.php

@@ -5,3 +5,4 @@
 passthru('php ' . __DIR__ . '/02-matcher-bind.php');
 passthru('php ' . __DIR__ . '/03-annotation-bind.php');
 passthru('php ' . __DIR__ . '/04-my-matcher.php');
+//passthru('php ' . __DIR__ . '/05-pecl.php');

src/Aspect.php

@@ -4,24 +4,13 @@
 
 namespace Ray\Aop;
 
-use RecursiveDirectoryIterator;
-use RecursiveIteratorIterator;
+use Ray\Aop\Exception\NotWritableException;
 use ReflectionClass;
 use ReflectionMethod;
 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
-use function strcasecmp;
+use function file_exists;
+use function is_writable;
 use function sys_get_temp_dir;
 
 /**
@@ -35,6 +24,7 @@
  *   methodMatcher: AbstractMatcher,
  *   interceptors: MethodInterceptors
  * }
+ * @psalm-type MatcherConfigList = array<array-key, MatcherConfig>
  * @psalm-type Arguments = array<array-key, mixed>
  */
 final class Aspect
@@ -50,25 +40,20 @@ final class Aspect
     /**
      * Collection of matcher configurations
      *
-     * @var array<array-key, MatcherConfig>
+     * @var MatcherConfigList
      */
     private $matchers = [];
 
-    /**
-     * Bound interceptors map
-     *
-     * @var ClassBindings
-     */
-    private $bound = [];
-
     /** @param non-empty-string|null $tmpDir Directory for generated proxy classes */
     public function __construct(?string $tmpDir = null)
     {
         if ($tmpDir === null) {
             $tmp = sys_get_temp_dir();
-            $this->tmpDir = $tmp !== '' ? $tmp : '/tmp';
+            $tmpDir = $tmp !== '' ? $tmp : '/tmp';
+        }
 
-            return;
+        if (! file_exists($tmpDir) || ! is_writable($tmpDir)) {
+            throw new NotWritableException("{$tmpDir} is not writable.");
         }
 
         $this->tmpDir = $tmpDir;
@@ -95,124 +80,13 @@ public function bind(AbstractMatcher $classMatcher, AbstractMatcher $methodMatch
     /**
      * Weave aspects into classes in the specified directory
      *
-     * @param string $classDir Target class directory
+     * @param non-empty-string $classDir Target class directory
      *
      * @throws RuntimeException When Ray.Aop extension is not loaded.
-     *
-     * @codeCoverageIgnore
      */
     public function weave(string $classDir): void
     {
-        if (! extension_loaded('rayaop')) {
-            throw new RuntimeException('Ray.Aop extension is not loaded. Cannot use weave() method.');
-        }
-
-        $this->scanDirectory($classDir);
-        $this->applyInterceptors();
-    }
-
-    /**
-     * Scan directory and compile classes
-     *
-     * @codeCoverageIgnore
-     */
-    private function scanDirectory(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);
-        }
-    }
-
-    /**
-     * Get class name from file
-     *
-     * @return class-string|null
-     *
-     * @codeCoverageIgnore
-     */
-    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;
-    }
-
-    /**
-     * Process class for interception
-     *
-     * @param class-string $className
-     *
-     * @codeCoverageIgnore
-     */
-    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;
-            }
-
-            /** @var ReflectionMethod[] $methods */
-            $methods = $reflection->getMethods(ReflectionMethod::IS_PUBLIC);
-            foreach ($methods as $method) {
-                if (! $matcher['methodMatcher']->matchesMethod($method, $matcher['methodMatcher']->getArguments())) {
-                    continue;
-                }
-
-                $this->bound[$className][$method->getName()] = $matcher['interceptors'];
-            }
-        }
-    }
-
-    /**
-     * Apply interceptors to bound methods
-     *
-     * @codeCoverageIgnore
-     */
-    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 */
-                method_intercept($className, $methodName, $dispatcher);  // @phpstan-ignore-line
-            }
-        }
+        (new AspectPecl())->weave($classDir, $this->matchers);
     }
 
     /**
@@ -228,51 +102,6 @@ private function applyInterceptors(): void
      * @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); // @codeCoverageIgnore
-        }
-
-        return $this->newInstanceWithPhp($className, $args);
-    }
-
-    /**
-     * Create instance using PECL extension
-     *
-     * @param class-string<T> $className
-     * @param Arguments       $args
-     *
-     * @return T
-     *
-     * @template T of object
-     * @codeCoverageIgnore
-     */
-    private function newInstanceWithPecl(string $className, array $args): object
-    {
-        /** @psalm-suppress MixedMethodCall */
-        $instance = new $className(...$args);
-        $this->processClass($className);
-        $this->applyInterceptors();
-
-        /** @var T $instance */
-        return $instance;
-    }
-
-    /**
-     * Create instance using PHP-based implementation
-     *
-     * @param class-string<T> $className
-     * @param list<mixed>     $args
-     *
-     * @return T
-     *
-     * @throws RuntimeException When temporary directory is not set.
-     *
-     * @template T of object
-     */
-    private function newInstanceWithPhp(string $className, array $args): object
     {
         $bind = $this->createBind($className);
         $weaver = new Weaver($bind, $this->tmpDir);

src/AspectPecl.php

@@ -0,0 +1,124 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ray\Aop;
+
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use ReflectionClass;
+use ReflectionMethod;
+use RuntimeException;
+use SplFileInfo;
+
+use function array_keys;
+use function assert;
+use function class_exists;
+use function extension_loaded;
+use function function_exists;
+use function method_intercept;
+
+/**
+ * @psalm-type MethodBoundInterceptors = array<non-empty-string, MethodInterceptors>
+ * @psalm-type ClassBoundInterceptors = array<class-string, MethodBoundInterceptors>
+ * @psalm-import-type MatcherConfigList from Aspect
+ * @psalm-import-type MethodInterceptors from Aspect
+ */
+final class AspectPecl
+{
+    public function __construct()
+    {
+        if (! extension_loaded('rayaop')) {
+            throw new RuntimeException('Ray.Aop extension is not loaded. Cannot use weave() method.'); // @codeCoverageIgnore
+        }
+    }
+
+    /**
+     * Weave aspects into classes in the specified directory
+     *
+     * @param non-empty-string  $classDir Target class directory
+     * @param MatcherConfigList $mathcers List of matchers and interceptors
+     *
+     * @throws RuntimeException When Ray.Aop extension is not loaded.
+     */
+    public function weave(string $classDir, array $mathcers): void
+    {
+        if (! extension_loaded('rayaop')) {
+            throw new RuntimeException('Ray.Aop extension is not loaded. Cannot use weave() method.'); // @codeCoverageIgnore
+        }
+
+        $files = new RecursiveIteratorIterator(
+            new RecursiveDirectoryIterator($classDir)
+        );
+
+        /** @var SplFileInfo[] $files */
+        foreach ($files as $file) {
+            if ($file->isDir() || $file->getExtension() !== 'php') {
+                continue;
+            }
+
+            $className = ClassName::from($file->getPathname());
+
+            if ($className === null) {
+                continue;
+            }
+
+            assert(class_exists($className), $className);
+
+            $boundInterceptors = $this->getBoundInterceptors($className, $mathcers);
+            $this->applyInterceptors($boundInterceptors);
+        }
+    }
+
+    /**
+     * Process class for interception
+     *
+     * @param class-string      $className
+     * @param MatcherConfigList $matchers
+     *
+     * @return ClassBoundInterceptors
+     */
+    private function getBoundInterceptors(string $className, array $matchers): array
+    {
+        assert(class_exists($className), $className);
+        $reflection = new ReflectionClass($className);
+
+        $bound = [];
+        foreach ($matchers as $matcher) {
+            if (! $matcher['classMatcher']->matchesClass($reflection, $matcher['classMatcher']->getArguments())) {
+                continue;
+            }
+
+            /** @var ReflectionMethod[] $methods */
+            $methods = $reflection->getMethods(ReflectionMethod::IS_PUBLIC);
+            foreach ($methods as $method) {
+                if (! $matcher['methodMatcher']->matchesMethod($method, $matcher['methodMatcher']->getArguments())) {
+                    continue;
+                }
+
+                $bound[$className][$method->getName()] = $matcher['interceptors'];
+            }
+        }
+
+        return $bound;
+    }
+
+    /**
+     * Apply interceptors to bound methods
+     *
+     * @param ClassBoundInterceptors $boundInterceptors
+     */
+    private function applyInterceptors(array $boundInterceptors): void
+    {
+        $dispatcher = new PeclDispatcher($boundInterceptors);
+        assert(function_exists('method_intercept')); // PECL Ray.Aop extension
+
+        foreach ($boundInterceptors as $className => $methods) {
+            $methodNames = array_keys($methods);
+            foreach ($methodNames as $methodName) {
+                assert($dispatcher instanceof MethodInterceptorInterface);
+                method_intercept($className, $methodName, $dispatcher);
+            }
+        }
+    }
+}