perf(attribute-analyzer): optimize performance and memory usage with caching

- Add class metadata caching to avoid repeated reflection
- Improve memory management and garbage collection
- Add comprehensive benchmarking suite

BREAKING CHANGE: OptimizedAttributeAnalyzer now implements AttributeAnalyzerContract directly

Performance improvements:
- Memory usage reduced by caching reflection metadata
- Processing time improved with optimized property access
- Better garbage collection handling
- More accurate benchmarking with warmup cycles

Author: walmir-silva

src/AttributeAnalyzer.php

@@ -7,51 +7,75 @@
 use KaririCode\PropertyInspector\Contract\AttributeAnalyzer as AttributeAnalyzerContract;
 use KaririCode\PropertyInspector\Exception\PropertyInspectionException;
 
-final readonly class AttributeAnalyzer implements AttributeAnalyzerContract
+final class AttributeAnalyzer implements AttributeAnalyzerContract
 {
-    public function __construct(private string $attributeClass)
+    private array $cache = [];
+
+    public function __construct(private readonly string $attributeClass)
     {
     }
 
     public function analyzeObject(object $object): array
     {
         try {
-            $results = [];
-            $reflection = new \ReflectionClass($object);
-
-            foreach ($reflection->getProperties() as $property) {
-                $propertyResult = $this->analyzeProperty($object, $property);
-                if (null !== $propertyResult) {
-                    $results[$property->getName()] = $propertyResult;
-                }
+            $className = $object::class;
+
+            // Usar cache se disponível
+            if (!isset($this->cache[$className])) {
+                $this->cacheObjectMetadata($object);
             }
 
-            return $results;
+            return $this->extractValues($object);
         } catch (\ReflectionException $e) {
             throw new PropertyInspectionException('Failed to analyze object: ' . $e->getMessage(), 0, $e);
         } catch (\Error $e) {
             throw new PropertyInspectionException('An error occurred during object analysis: ' . $e->getMessage(), 0, $e);
         }
     }
 
-    private function analyzeProperty(object $object, \ReflectionProperty $property): ?array
+    private function cacheObjectMetadata(object $object): void
     {
-        $attributes = $property->getAttributes($this->attributeClass, \ReflectionAttribute::IS_INSTANCEOF);
-        if (empty($attributes)) {
-            return null;
+        $className = $object::class;
+        $reflection = new \ReflectionClass($object);
+        $cachedProperties = [];
+
+        foreach ($reflection->getProperties() as $property) {
+            $attributes = $property->getAttributes($this->attributeClass, \ReflectionAttribute::IS_INSTANCEOF);
+
+            if (!empty($attributes)) {
+                $property->setAccessible(true);
+                $attributeInstances = array_map(
+                    static fn (\ReflectionAttribute $attr): object => $attr->newInstance(),
+                    $attributes
+                );
+
+                $cachedProperties[$property->getName()] = [
+                    'attributes' => $attributeInstances,
+                    'property' => $property,
+                ];
+            }
         }
 
-        $property->setAccessible(true);
-        $propertyValue = $property->getValue($object);
+        $this->cache[$className] = $cachedProperties;
+    }
 
-        $attributeInstances = array_map(
-            static fn (\ReflectionAttribute $attr): object => $attr->newInstance(),
-            $attributes
-        );
+    private function extractValues(object $object): array
+    {
+        $results = [];
+        $className = $object::class;
+
+        foreach ($this->cache[$className] as $propertyName => $data) {
+            $results[$propertyName] = [
+                'value' => $data['property']->getValue($object),
+                'attributes' => $data['attributes'],
+            ];
+        }
 
-        return [
-            'value' => $propertyValue,
-            'attributes' => $attributeInstances,
-        ];
+        return $results;
+    }
+
+    public function clearCache(): void
+    {
+        $this->cache = [];
     }
 }