Introduce caching in multiple steps (Fix #6) (#10)

* Cache class map
* Cache filtered files
* Cache class attributes

Author: olvlvl

.gitignore

@@ -1,3 +1,4 @@
+.composer-attribute-collector
 .phpunit.result.cache
 vendor
 composer.lock

MIGRATION.md

@@ -11,6 +11,7 @@ None
 - [#11](https://github.com/olvlvl/composer-attribute-collector/pull/11) Attribute instantiation errors are decorated to help find origin (@withinboredom @olvlvl)
 - [#12](https://github.com/olvlvl/composer-attribute-collector/pull/12) `Attributes::filterTargetClasses()` can filter target classes using a predicate (@olvlvl)
 - [#12](https://github.com/olvlvl/composer-attribute-collector/pull/12) `Attributes::filterTargetMethods()` can filter target methods using a predicate (@olvlvl)
+- [#10](https://github.com/olvlvl/composer-attribute-collector/pull/10) 3 types of cache speed up generation by limiting updates to changed files (@xepozz @olvlvl)
 
 ### Backward Incompatible Changes
 

Makefile

@@ -29,6 +29,7 @@ test-coveralls: test-dependencies
 
 .PHONY: test-cleanup
 test-cleanup:
+	@rm -rf .composer-attribute-collector/*
 	@rm -rf tests/sandbox/*
 
 .PHONY: test-container

README.md

@@ -18,6 +18,7 @@ Later, these targets can be retrieved through a convenient interface.
 - No dependency (except Composer of course).
 - A single interface to get attribute targets.
 - A single interface to get class attributes.
+- 3 types of cache speed up generation by limiting updates to changed files.
 
 
 
@@ -73,21 +74,23 @@ The plugin is currently experimental and its interface subject to change. Also,
 class and method targets. Please [contribute](CONTRIBUTING.md) if you're interested in shaping its
 future.
 
+**Note:** The plugin creates a `.composer-attribute-collector` directory to store caches, you might
+want to add it to your `.gitignore` file.
+
 
 
 ## Frequently Asked Questions
 
 **Do I need to generate an optimized autoloader?**
 
-You don't need to generate an optimized autoloader for this to work. The
-plugin uses code similar to Composer to find classes. Anything that works with Composer should work
-with the plugin.
+You don't need to generate an optimized autoloader for this to work. The plugin uses code similar
+to Composer to find classes. Anything that works with Composer should work with the plugin.
 
 **Can I use the plugin during development?**
 
 Yes, you can use the plugin during development, but keep in mind the attributes file is only
-generated after the autoloader is dumped. If you modify attributes you'll have to
-run `composer dump` to refresh the attributes file.
+generated after the autoloader is dumped. If you modify attributes you'll have to run
+`composer dump` to refresh the attributes file.
 
 As a workaround you could have watchers on the directories that contain classes with attributes to
 run `XDEBUG_MODE=off composer dump` when you make changes. [PhpStorm offers file watchers][phpstorm-watchers]. You could also use [spatie/file-system-watcher][], it only requires PHP.
@@ -296,6 +299,8 @@ final class IsAdmin implements Voter
 }
 ```
 
+
+
 ## Using Attributes
 
 ### Filtering target methods

phpcs.xml

@@ -4,6 +4,7 @@
     <file>src</file>
     <file>tests</file>
     <exclude-pattern>tests/sandbox/*</exclude-pattern>
+    <exclude-pattern>tests/sandbox-memoize-classmap/*</exclude-pattern>
 
 	<arg name="colors"/>
 

phpstan.neon

@@ -1,4 +1,6 @@
 parameters:
+  bootstrapFiles:
+  - tests/bootstrap.php
   level: max
   paths:
     - src

phpunit.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0"?>
 <phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 		 xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/9.5/phpunit.xsd" colors="true"
-		 bootstrap="./vendor/autoload.php">
+		 bootstrap="./tests/bootstrap.php">
 	<coverage>
 		<include>
 			<directory suffix=".php">./src</directory>

src/ClassAttributeCollector.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace olvlvl\ComposerAttributeCollector;
+
+use Attribute;
+use Composer\IO\IOInterface;
+use ReflectionAttribute;
+use ReflectionClass;
+use ReflectionException;
+
+/**
+ * @internal
+ */
+class ClassAttributeCollector
+{
+    public function __construct(
+        private IOInterface $io,
+    ) {
+    }
+
+    /**
+     * @param class-string $class
+     *
+     * @return array{
+     *     array<array{ class-string, array<int|string, mixed> }>,
+     *     array<array{ class-string, array<int|string, mixed>, non-empty-string }>
+     * }
+     *     Where `0` is an array of class attributes, and `1` is an array of method attributes.
+     * @throws ReflectionException
+     */
+    public function collectAttributes(string $class): array
+    {
+        $classReflection = new ReflectionClass($class);
+
+        if (self::isAttribute($classReflection)) {
+            return [ [], [] ];
+        }
+
+        $classAttributes = [];
+        $attributes = $classReflection->getAttributes();
+
+        foreach ($attributes as $attribute) {
+            if (self::isAttributeIgnored($attribute)) {
+                continue;
+            }
+
+            $this->io->debug("Found attribute {$attribute->getName()} on $class");
+
+            $classAttributes[] = [ $attribute->getName(), $attribute->getArguments() ];
+        }
+
+        $methodAttributes = [];
+
+        foreach ($classReflection->getMethods() as $methodReflection) {
+            foreach ($methodReflection->getAttributes() as $attribute) {
+                if (self::isAttributeIgnored($attribute)) {
+                    continue;
+                }
+
+                $method = $methodReflection->name;
+                assert($method !== '');
+
+                $this->io->debug("Found attribute {$attribute->getName()} on $class::$method");
+
+                $methodAttributes[] = [ $attribute->getName(), $attribute->getArguments(), $method ];
+            }
+        }
+
+        return [ $classAttributes, $methodAttributes ];
+    }
+
+    /**
+     * Determines if a class is an attribute.
+     *
+     * @param ReflectionClass<object> $classReflection
+     */
+    private static function isAttribute(ReflectionClass $classReflection): bool
+    {
+        foreach ($classReflection->getAttributes() as $attribute) {
+            if ($attribute->getName() === Attribute::class) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param ReflectionAttribute<object> $attribute
+     */
+    private static function isAttributeIgnored(ReflectionAttribute $attribute): bool
+    {
+        static $ignored = [
+            \ReturnTypeWillChange::class => true,
+        ];
+
+        return isset($ignored[$attribute->getName()]);
+    }
+}

src/ClassMapBuilder.php

@@ -9,7 +9,6 @@
 
 namespace olvlvl\ComposerAttributeCollector;
 
-use Composer\ClassMapGenerator\ClassMapGenerator;
 use Composer\Pcre\Preg;
 use Composer\Util\Filesystem;
 use Composer\Util\Platform;
@@ -27,6 +26,11 @@
  */
 class ClassMapBuilder
 {
+    public function __construct(
+        private MemoizeClassMapGenerator $classMapGenerator
+    ) {
+    }
+
     /**
      * @param array{
      *     'psr-0': array<string, array<string>>,
@@ -40,9 +44,9 @@ class ClassMapBuilder
      */
     public function buildClassMap(array $autoloads): array
     {
+        $classMapGenerator = $this->classMapGenerator;
+
         $excluded = $autoloads['exclude-from-classmap'];
-        $classMapGenerator = new ClassMapGenerator();
-        $classMapGenerator->avoidDuplicateScans();
 
         foreach ($autoloads['classmap'] as $dir) {
             // @phpstan-ignore-next-line
@@ -70,7 +74,7 @@ public function buildClassMap(array $autoloads): array
                     $dir = $filesystem->normalizePath(
                         $filesystem->isAbsolutePath($dir) ? $dir : $basePath . '/' . $dir
                     );
-                    if (!is_dir($dir)) {
+                    if ($dir === '' || !is_dir($dir)) {
                         continue; // @codeCoverageIgnore
                     }
 
@@ -85,7 +89,7 @@ public function buildClassMap(array $autoloads): array
             }
         }
 
-        return $classMapGenerator->getClassMap()->getMap();
+        return $classMapGenerator->getMap();
     }
 
     /**

src/Collector.php

@@ -9,10 +9,6 @@
 
 namespace olvlvl\ComposerAttributeCollector;
 
-use ReflectionAttribute;
-use ReflectionClass;
-use ReflectionMethod;
-
 /**
  * Collects classes and methods with attributes.
  *
@@ -31,21 +27,29 @@ final class Collector
     public array $methods = [];
 
     /**
-     * @param ReflectionAttribute<object> $attribute
-     * @param ReflectionClass<object> $class
+     * @param array<array{ class-string, array<int|string, mixed> }> $attributes
+     *     An array of method attributes, where `0` is an attribute class, `1` the attributes arguments.
+     * @param class-string $class
+     *     The target class.
      */
-    public function addTargetClass(ReflectionAttribute $attribute, ReflectionClass $class): void
+    public function addClassAttributes(array $attributes, string $class): void
     {
-        $this->classes[$attribute->getName()][]
-            = new TargetClassRaw($attribute->getArguments(), $class->name);
+        foreach ($attributes as [ $attribute, $arguments ]) {
+            $this->classes[$attribute][] = new TargetClassRaw($arguments, $class);
+        }
     }
 
     /**
-     * @param ReflectionAttribute<object> $attribute
+     * @param array<array{ class-string, array<int|string, mixed>, string }> $attributes
+     *     An array of method attributes, where `0` is an attribute class, `1` the attributes arguments,
+     *     and `2` the method.
+     * @param class-string $class
+     *     The target class.
      */
-    public function addTargetMethod(ReflectionAttribute $attribute, ReflectionMethod $method): void
+    public function addMethodAttributes(array $attributes, string $class): void
     {
-        $this->methods[$attribute->getName()][]
-            = new TargetMethodRaw($attribute->getArguments(), $method->class, $method->name);
+        foreach ($attributes as [ $attribute, $arguments, $method ]) {
+            $this->methods[$attribute][] = new TargetMethodRaw($arguments, $class, $method);
+        }
     }
 }