Updated implementation for annotations/attributes listener

Author: divineniiquaye

src/AnnotationLoader.php

@@ -102,7 +102,7 @@ public function build(): void
                 }
             }
 
-            $found = $listener->onAnnotation($listenerAnnotations);
+            $found = $listener->load($listenerAnnotations);
 
             if (null !== $found) {
                 $this->annotations[] = $found;

src/ListenerInterface.php

@@ -22,38 +22,14 @@ interface ListenerInterface
     /**
      * This method utilises found annotations and return collector.
      *
-     * The array that is received contains eg:
-     *  ```php
-     * $annotations = [
-     *     ClassName::class => [
-     *        'class' => [$annotation, ...],
-     *        'methods' => [[$reflection, $annotation], ..],
-     *        'property' => [[$reflection, $annotation], ..],
-     *        'constant' => [[$reflection, $annotation], ..],
-     *        'method_propert' => [[$reflection, $annotation], ..],
-     *    ],
-     *    ...
-     * ];
-     * ```
-     *
-     * @param array<string,array<string,mixed>> $annotations
+     * @param Locate\Class_[]|Locate\Function_[] $annotations
      *
      * @return mixed
      */
-    public function onAnnotation(array $annotations);
+    public function load(array $annotations);
 
     /**
-     * The annotation class to find
-     *
-     * @return string
+     * The annotation class to find.
      */
     public function getAnnotation(): string;
-
-    /**
-     * This methods gets the annotation from a function or method's
-     * paramater.
-     *
-     * @return string[]
-     */
-    public function getArguments(): array;
 }

tests/Fixtures/SampleListener.php

@@ -18,6 +18,9 @@
 namespace Biurad\Annotations\Tests\Fixtures;
 
 use Biurad\Annotations\ListenerInterface;
+use Biurad\Annotations\Locate\Annotation;
+use Biurad\Annotations\Locate\Class_;
+use Biurad\Annotations\Locate\Method;
 
 class SampleListener implements ListenerInterface
 {
@@ -29,14 +32,6 @@ public function __construct(?SampleCollector $collector = null)
         $this->collector = $collector ?? new SampleCollector();
     }
 
-    /**
-     * {@inheritdoc}
-     */
-    public function getArguments(): array
-    {
-        return ['parameter'];
-    }
-
     /**
      * {@inheritdoc}
      */
@@ -48,72 +43,65 @@ public function getAnnotation(): string
     /**
      * {@inheritdoc}
      */
-    public function onAnnotation(array $annotations): SampleCollector
+    public function load(array $annotations): SampleCollector
     {
-        foreach ($annotations as $class => $collection) {
-            $reflections = \array_merge(
-                $collection['method'] ?? [],
-                $collection['property'] ?? [],
-                $collection['constant'] ?? [],
-                $collection['method_property'] ?? []
-            );
+        foreach ($annotations as $annotation) {
+            if ($annotation instanceof Class_) {
+                $attributes = \array_merge($annotation->methods, $annotation->properties, $annotation->constants);
+
+                if ([] === $attributes) {
+                    $this->addSample(null, $annotation);
+
+                    continue;
+                }
 
-            if (!empty($reflections)) {
-                $this->addSampleGroup($collection['class'] ?? [], $reflections);
+                foreach ($attributes as $attribute) {
+                    $this->addSample($annotation->getAnnotation(), $attribute);
+
+                    if ($attribute instanceof Method) {
+                        foreach ($attribute->parameters as $parameter) {
+                            $this->addSample($annotation->getAnnotation(), $parameter);
+                        }
+                    }
+                }
 
                 continue;
             }
 
-            foreach ($collection['class'] ?? [] as $annotation) {
-                $this->addSample($annotation, $class);
+            $this->addSample(null, $annotation);
+
+            foreach ($annotation->parameters as $parameter) {
+                $this->addSample(null, $parameter);
             }
         }
 
         return $this->collector;
     }
 
     /**
-     * @param Sample            $annotation
-     * @param \Reflector|string $handler
-     * @param null|Sample       $group
+     * @param Sample[]|Sample|null $attribute
      */
-    private function addSample(Sample $annotation, $handler, ?Sample $group = null): void
+    private function addSample($attribute, Annotation $listener): void
     {
-        $name     = $annotation->getName();
-        $priority = $annotation->getPriority();
+        if (is_array($attribute) && [] !== $attribute) {
+            foreach ($attribute as $annotation) {
+                $this->addSample($annotation, $listener);
+            }
 
-        if (null !== $group) {
-            $name = $group->getName() . '_' . $name;
-            $priority += $group->getPriority();
+            return;
         }
 
-        $this->collector->add($name, $priority, $handler);
-    }
+        /** @var Sample $annotated */
+        foreach ($listener->getAnnotation() as $annotated) {
+            $name = $annotated->getName();
+            $priority = $annotated->getPriority();
 
-    /**
-     * @param Sample[] $groups
-     * @param mixed[]  $collection
-     */
-    private function addSampleGroup(array $groups, array $collection): void
-    {
-        $handleCollection = function (array $collection, ?Sample $group = null): void {
-            /**
-             * @var \ReflectionMethod|\ReflectionProperty $reflector
-             * @var Sample                              $annotation
-             */
-            foreach ($collection as [$reflector, $annotation]) {
-                $this->addSample($annotation, $reflector, $group);
+            if ($attribute instanceof Sample) {
+                $name = $attribute->getName() . '_' . $name;
+                $priority += $attribute->getPriority();
             }
-        };
-
-        if (empty($groups)) {
-            $handleCollection($collection);
-
-            return;
-        }
 
-        foreach ($groups as $group) {
-            $handleCollection($collection, $group);
+            $this->collector->add($name, $priority, $listener->getReflection());
         }
     }
 }