Merge pull request #3 from biurad/performance

Performance Update

Author: divineniiquaye

.gitignore

@@ -1,7 +1,7 @@
 /.idea/
 /.vscode/
 /.phpcs-cache
-/.php_cs.dist
+/.php_cs.dist.php
 /.phpunit.result.cache
 /build/
 composer.phar

README.md

@@ -51,6 +51,8 @@ foreach ($$listeners as $collector) {
 }
 ```
 
+> **NB:** If you are on PHP 8 and wishes to use attributes only, please avoid using `spiral/attributes` package for best performance. Contributing why this library is not shipped with `spiral/attributes` package.
+
 ## 📓 Documentation
 
 For in-depth documentation before using this library. Full documentation on advanced usage, configuration, and customization can be found at [docs.biurad.com][docs].

composer.json

@@ -23,7 +23,7 @@
     },
     "require": {
         "php": "^7.2 || ^8.0",
-        "spiral/attributes": "dev-master"
+        "symfony/polyfill-php80": "^1.22"
     },
     "extra": {
         "branch-alias": {
@@ -36,7 +36,8 @@
         "phpstan/phpstan": "^0.12",
         "phpstan/phpstan-strict-rules": "^0.12",
         "phpunit/phpunit": "^8.5 || ^9.5",
-        "squizlabs/php_codesniffer": "^3.5",
+        "spiral/attributes": "dev-master",
+        "squizlabs/php_codesniffer": "^3.6",
         "vimeo/psalm": "^4.7"
     },
     "autoload": {
@@ -62,7 +63,8 @@
         ]
     },
     "suggest": {
-        "doctrine/annotations": "^1.8 for Doctrine metadata driver support"
+        "doctrine/annotations": "^1.8 for Doctrine metadata driver support",
+        "spiral/attributes": "For loading doctrine and/or PHP 8 attributes for PHP 7"
     },
     "minimum-stability": "dev",
     "prefer-stable": true

phpstan.neon.dist

@@ -5,3 +5,7 @@ parameters:
     level: 2
     paths: [src]
     checkGenericClassInNonGenericObjectType: false
+
+    ignoreErrors:
+        - "#^Construct empty\\(\\) is not allowed. Use more strict comparison.$#"
+        - "#^Call to an undefined method Reflector\\:\\:getAttributes\\(\\).|Parameter \\$attribute of anonymous function has invalid typehint type ReflectionAttribute.|Call to method newInstance\\(\\) on an unknown class ReflectionAttribute.$#"

psalm.xml.dist

@@ -21,10 +21,10 @@
     </projectFiles>
 
     <issueHandlers>
-        <MethodSignatureMismatch>
+        <UndefinedClass>
             <errorLevel type="suppress">
-                <directory name="src/Locate"/>
+                <referencedClass name="ReflectionAttribute"/>
             </errorLevel>
-        </MethodSignatureMismatch>
+        </UndefinedClass>
     </issueHandlers>
 </psalm>

src/AnnotationLoader.php

@@ -26,13 +26,13 @@
  */
 class AnnotationLoader implements LoaderInterface
 {
-    /** @var ReaderInterface */
+    /** @var ReaderInterface|null */
     private $reader;
 
     /** @var mixed[] */
     private $annotations;
 
-    /** @var ListenerInterface[] */
+    /** @var array<string,ListenerInterface> */
     private $listeners = [];
 
     /** @var string[] */
@@ -44,8 +44,12 @@ class AnnotationLoader implements LoaderInterface
     /**
      * @param callable $classLoader
      */
-    public function __construct(ReaderInterface $reader, callable $classLoader = null)
+    public function __construct(ReaderInterface $reader = null, callable $classLoader = null)
     {
+        if (\PHP_VERSION_ID < 80000 && null === $reader) {
+            throw new \RuntimeException(\sprintf('A "%s" instance to read annotations/attributes not available.', ReaderInterface::class));
+        }
+
         $this->reader = $reader;
         $this->classLoader = $classLoader;
     }
@@ -55,119 +59,118 @@ public function __construct(ReaderInterface $reader, callable $classLoader = nul
      */
     public function listener(ListenerInterface ...$listeners): void
     {
-        $this->listeners += $listeners;
+        foreach ($listeners as $listener) {
+            $this->listeners[$listener->getAnnotation()] = $listener;
+        }
     }
 
     /**
      * {@inheritdoc}
      */
     public function resource(string ...$resources): void
     {
-        $this->resources += $resources;
+        foreach ($resources as $resource) {
+            $this->resources[] = $resource;
+        }
     }
 
     /**
      * {@inheritdoc}
      */
-    public function build(): void
+    public function build(?string ...$annotationClass): void
     {
-        $this->annotations = $annotations = $classes = $files = [];
+        $this->annotations = $annotations = $files = [];
+
+        if (1 === \count($annotationClass = \array_merge($annotationClass, \array_keys($this->listeners)))) {
+            $annotationClass = $annotationClass[0];
+        }
 
         foreach ($this->resources as $resource) {
             if (\is_dir($resource)) {
                 $files += $this->findFiles($resource);
-
-                continue;
-            }
-
-            if (!(\class_exists($resource) || \function_exists($resource))) {
-                continue;
+            } elseif (\function_exists($resource) || \class_exists($resource)) {
+                $annotations = \array_replace_recursive($annotations, $this->findAnnotations($resource, $annotationClass));
             }
-
-            $classes[] = $resource;
         }
 
-        $classes += $this->findClasses($files);
-
-        foreach ($classes as $class) {
-            $annotations[] = $this->findAnnotations($class);
+        if (!empty($files)) {
+            foreach ($this->findClasses($files) as $class) {
+                $annotations = \array_replace_recursive($annotations, $this->findAnnotations($class, $annotationClass));
+            }
         }
 
-        foreach ($this->listeners as $listener) {
-            $listenerAnnotations = [];
+        foreach ((array) $annotationClass as $annotation) {
+            $loadedAnnotation = \array_filter($annotations[$annotation] ?? []);
 
-            foreach ($annotations as $annotation) {
-                if (isset($annotation[$listener->getAnnotation()])) {
-                    $listenerAnnotations[] = $annotation[$listener->getAnnotation()];
-                }
+            if (isset($this->listeners[$annotation])) {
+                $loadedAnnotation = $this->listeners[$annotation]->load($loadedAnnotation);
             }
 
-            $found = $listener->load($listenerAnnotations);
-
-            if (null !== $found) {
-                $this->annotations[] = $found;
-            }
+            $this->annotations[$annotation] = $loadedAnnotation;
         }
-
-        \gc_mem_caches();
     }
 
     /**
      * {@inheritdoc}
      */
-    public function load(): iterable
+    public function load(string $annotationClass = null, bool $stale = true)
     {
-        if (null === $this->annotations) {
-            $this->build();
+        if (!$stale || null === $this->annotations) {
+            $this->build($annotationClass);
         }
 
-        return $this->annotations;
+        if (isset($annotationClass, $this->annotations[$annotationClass])) {
+            return $this->annotations[$annotationClass] ?? null;
+        }
+
+        return \array_filter($this->annotations);
     }
 
     /**
      * Finds annotations in the given resource.
      *
      * @param class-string|string $resource
+     * @param string[]|string     $annotationClass
      *
      * @return Locate\Class_[]|Locate\Function_[]
      */
-    private function findAnnotations(string $resource)
+    private function findAnnotations(string $resource, $annotationClass): iterable
     {
-        $annotations = [];
-
-        foreach ($this->listeners as $listener) {
-            $annotationClass = $listener->getAnnotation();
-
-            if (\function_exists($resource)) {
-                $funcReflection = new \ReflectionFunction($resource);
-                $function = $this->fetchFunctionAnnotation($funcReflection, $this->getAnnotations($funcReflection, $annotationClass), $annotationClass);
+        if (empty($annotationClass)) {
+            return [];
+        }
 
-                if (null !== $function) {
-                    $annotations[$annotationClass] = $function;
-                }
+        if (\is_array($annotationClass)) {
+            $annotations = [];
 
-                continue;
+            foreach ($annotationClass as $annotation) {
+                $annotations = \array_replace_recursive($annotations, $this->findAnnotations($resource, $annotation));
             }
 
-            $classReflection = new \ReflectionClass($resource);
+            return $annotations;
+        }
 
-            if ($classReflection->isAbstract()) {
-                continue;
-            }
+        if (\function_exists($resource)) {
+            $funcReflection = new \ReflectionFunction($resource);
+            $annotation = $this->fetchFunctionAnnotation($funcReflection, $this->getAnnotations($funcReflection, $annotationClass), $annotationClass);
 
-            $annotation = new Locate\Class_($this->getAnnotations($classReflection, $annotationClass), $classReflection);
+            goto annotation;
+        }
 
-            // Reflections belonging to class object.
-            $reflections = \array_merge(
-                $classReflection->getMethods(),
-                $classReflection->getProperties(),
-                $classReflection->getConstants()
-            );
+        $classReflection = new \ReflectionClass($resource);
 
-            $annotations[$annotationClass] = $this->fetchAnnotations($annotation, $reflections, $annotationClass);
+        if ($classReflection->isAbstract()) {
+            return [];
         }
 
-        return $annotations;
+        $annotation = $this->fetchAnnotations(
+            new Locate\Class_($this->getAnnotations($classReflection, $annotationClass), $classReflection),
+            \array_merge($classReflection->getMethods(), $classReflection->getProperties(), $classReflection->getConstants()),
+            $annotationClass
+        );
+
+        annotation:
+        return [$annotationClass => [$resource => $annotation]];
     }
 
     /**
@@ -179,29 +182,22 @@ private function getAnnotations(\Reflector $reflection, string $annotation): ite
     {
         $annotations = [];
 
-        switch (true) {
-            case $reflection instanceof \ReflectionClass:
-                $annotations = $this->reader->getClassMetadata($reflection, $annotation);
-
-                break;
-
-            case $reflection instanceof \ReflectionFunctionAbstract:
-                $annotations = $this->reader->getFunctionMetadata($reflection, $annotation);
-
-                break;
-
-            case $reflection instanceof \ReflectionProperty:
-                $annotations = $this->reader->getPropertyMetadata($reflection, $annotation);
-
-                break;
-
-            case $reflection instanceof \ReflectionClassConstant:
-                $annotations = $this->reader->getConstantMetadata($reflection, $annotation);
-
-                break;
+        if (null === $this->reader) {
+            return \array_map(static function (\ReflectionAttribute $attribute): object {
+                return $attribute->newInstance();
+            }, $reflection->getAttributes($annotation));
+        }
 
-            case $reflection instanceof \ReflectionParameter:
-                $annotations = $this->reader->getParameterMetadata($reflection, $annotation);
+        if ($reflection instanceof \ReflectionClass) {
+            $annotations = $this->reader->getClassMetadata($reflection, $annotation);
+        } elseif ($reflection instanceof \ReflectionFunctionAbstract) {
+            $annotations = $this->reader->getFunctionMetadata($reflection, $annotation);
+        } elseif ($reflection instanceof \ReflectionProperty) {
+            $annotations = $this->reader->getPropertyMetadata($reflection, $annotation);
+        } elseif ($reflection instanceof \ReflectionClassConstant) {
+            $annotations = $this->reader->getConstantMetadata($reflection, $annotation);
+        } elseif ($reflection instanceof \ReflectionParameter) {
+            $annotations = $this->reader->getParameterMetadata($reflection, $annotation);
         }
 
         return $annotations instanceof \Generator ? \iterator_to_array($annotations) : $annotations;
@@ -286,7 +282,7 @@ private function fetchFunctionAnnotation(\ReflectionFunctionAbstract $reflection
      *
      * @param string[] $files
      *
-     * @return class-string[]
+     * @return string[]
      */
     private function findClasses(array $files): array
     {

src/LoaderInterface.php

@@ -20,28 +20,32 @@
 interface LoaderInterface
 {
     /**
-     * Attache(s) the given resource(s) to the loader
+     * Attache(s) the given resource(s) to the loader.
      *
-     * @param string ...$resources type of class string, file, or directory
+     * @param string ...$resources type of class string, function name, file, or directory
      */
     public function resource(string ...$resources): void;
 
     /**
-     * Attache(s) the given listener(s) to the loader
+     * Attache(s) the given listener(s) to the loader.
      *
      * @param ListenerInterface ...$listeners
      */
     public function listener(ListenerInterface ...$listeners): void;
 
     /**
-     * Loads annotations from attached resources
+     * Loads annotations from attached resources.
      *
-     * @return iterable|mixed[]
+     * @param bool $stale If true rebuilding annotations/attributes is locked
+     *
+     * @return mixed
      */
-    public function load(): iterable;
+    public function load(string $annotationClass = null, bool $stale = true);
 
     /**
-     * This finds and build annotations once
+     * This finds and build annotations once.
+     *
+     * @param string|null ...$annotationClass
      */
-    public function build(): void;
+    public function build(?string ...$annotationClass): void;
 }