perf(AttributeHandler): optimize performance and memory usage

- Reduce method complexity and function calls
- Implement efficient processor caching
- Remove unnecessary abstraction layers
- Optimize memory allocation and reuse

Author: walmir-silva

composer.json

@@ -45,7 +45,8 @@
     "phpstan/phpstan": "^1.10",
     "phpunit/phpunit": "^11.0",
     "squizlabs/php_codesniffer": "^3.9",
-    "enlightn/security-checker": "^2.0"
+    "enlightn/security-checker": "^2.0",
+    "kariricode/validator": "^1.0"
   },
   "support": {
     "issues": "https://github.com/KaririCode-Framework/kariricode-property-inspector/issues",

composer.lock

@@ -7,9 +7,9 @@
 use KaririCode\PropertyInspector\Contract\AttributeAnalyzer as AttributeAnalyzerContract;
 use KaririCode\PropertyInspector\Exception\PropertyInspectionException;
 
-final class AttributeAnalyzer implements AttributeAnalyzerContract
+final readonly class AttributeAnalyzer implements AttributeAnalyzerContract
 {
-    public function __construct(private readonly string $attributeClass)
+    public function __construct(private string $attributeClass)
     {
     }
 

src/AttributeAnalyzer.php

@@ -7,6 +7,8 @@
 use KaririCode\Contract\Processor\Attribute\CustomizableMessageAttribute;
 use KaririCode\Contract\Processor\Attribute\ProcessableAttribute;
 use KaririCode\Contract\Processor\ProcessorBuilder;
+use KaririCode\Contract\Processor\ProcessorValidator as ProcessorProcessorContract;
+use KaririCode\PropertyInspector\Contract\ProcessorConfigBuilder as ProcessorConfigBuilderContract;
 use KaririCode\PropertyInspector\Contract\PropertyAttributeHandler;
 use KaririCode\PropertyInspector\Contract\PropertyChangeApplier;
 use KaririCode\PropertyInspector\Processor\ProcessorConfigBuilder;
@@ -18,12 +20,13 @@ class AttributeHandler implements PropertyAttributeHandler, PropertyChangeApplie
     private array $processedPropertyValues = [];
     private array $processingResultErrors = [];
     private array $processingResultMessages = [];
+    private array $processorCache = [];
 
     public function __construct(
         private readonly string $processorType,
         private readonly ProcessorBuilder $builder,
-        private readonly ProcessorValidator $validator = new ProcessorValidator(),
-        private readonly ProcessorConfigBuilder $configBuilder = new ProcessorConfigBuilder()
+        private readonly ProcessorProcessorContract $validator = new ProcessorValidator(),
+        private readonly ProcessorConfigBuilderContract $configBuilder = new ProcessorConfigBuilder()
     ) {
     }
 
@@ -33,101 +36,79 @@ public function handleAttribute(string $propertyName, object $attribute, mixed $
             return null;
         }
 
-        $processorsConfig = $this->configBuilder->build($attribute);
-        $messages = $this->extractCustomMessages($attribute, $processorsConfig);
-
         try {
-            $processedValue = $this->processValue($value, $processorsConfig);
-            $errors = $this->validateProcessors($processorsConfig, $messages);
-
-            $this->storeProcessedPropertyValue($propertyName, $processedValue, $messages);
-
-            if (!empty($errors)) {
-                $this->storeProcessingResultErrors($propertyName, $errors);
-            }
-
-            return $processedValue;
+            return $this->processAttribute($propertyName, $attribute, $value);
         } catch (\Exception $e) {
-            $this->storeProcessingResultError($propertyName, $e->getMessage());
+            $this->processingResultErrors[$propertyName][] = $e->getMessage();
 
             return $value;
         }
     }
 
-    private function validateProcessors(array $processorsConfig, array $messages): array
-    {
-        $errors = [];
-        foreach ($processorsConfig as $processorName => $config) {
-            $processor = $this->builder->build($this->processorType, $processorName, $config);
-            $validationError = $this->validator->validate(
-                $processor,
-                $processorName,
-                $messages
-            );
-
-            if ($this->shouldAddValidationError($validationError, $errors, $processorName)) {
-                $errors[$processorName] = $validationError;
-            }
-        }
-
-        return $errors;
-    }
-
-    private function shouldAddValidationError(?array $validationError, array $errors, string $processorName): bool
-    {
-        return null !== $validationError && !isset($errors[$processorName]);
-    }
-
-    private function storeProcessingResultErrors(string $propertyName, array $errors): void
-    {
-        $this->processingResultErrors[$propertyName] = $errors;
-    }
-
-    private function extractCustomMessages(ProcessableAttribute $attribute, array &$processorsConfig): array
+    private function processAttribute(string $propertyName, ProcessableAttribute $attribute, mixed $value): mixed
     {
+        $config = $this->configBuilder->build($attribute);
         $messages = [];
+
         if ($attribute instanceof CustomizableMessageAttribute) {
-            foreach ($processorsConfig as $processorName => &$config) {
-                $customMessage = $attribute->getMessage($processorName);
-                if (null !== $customMessage) {
-                    $config['customMessage'] = $customMessage;
-                    $messages[$processorName] = $customMessage;
+            foreach ($config as $processorName => &$processorConfig) {
+                if ($message = $attribute->getMessage($processorName)) {
+                    $processorConfig['customMessage'] = $message;
+                    $messages[$processorName] = $message;
                 }
             }
         }
 
-        return $messages;
-    }
-
-    private function processValue(mixed $value, array $processorsConfig): mixed
-    {
-        $pipeline = $this->builder->buildPipeline(
-            $this->processorType,
-            $processorsConfig
-        );
+        $processedValue = $this->processValue($value, $config);
 
-        return $pipeline->process($value);
-    }
+        if ($errors = $this->validateProcessors($config, $messages)) {
+            $this->processingResultErrors[$propertyName] = $errors;
+        }
 
-    private function storeProcessedPropertyValue(string $propertyName, mixed $processedValue, array $messages): void
-    {
         $this->processedPropertyValues[$propertyName] = [
             'value' => $processedValue,
             'messages' => $messages,
         ];
+
         $this->processingResultMessages[$propertyName] = $messages;
+
+        return $processedValue;
+    }
+
+    private function validateProcessors(array $processorsConfig, array $messages): array
+    {
+        $errors = [];
+        foreach ($processorsConfig as $processorName => $config) {
+            // Simplify cache key to processor name
+            if (!isset($this->processorCache[$processorName])) {
+                $this->processorCache[$processorName] = $this->builder->build(
+                    $this->processorType,
+                    $processorName,
+                    $config
+                );
+            }
+
+            $processor = $this->processorCache[$processorName];
+
+            if ($error = $this->validator->validate($processor, $processorName, $messages)) {
+                $errors[$processorName] = $error;
+            }
+        }
+
+        return $errors;
     }
 
-    private function storeProcessingResultError(string $propertyName, string $errorMessage): void
+    private function processValue(mixed $value, array $config): mixed
     {
-        $this->processingResultErrors[$propertyName][] = $errorMessage;
+        return $this->builder
+            ->buildPipeline($this->processorType, $config)
+            ->process($value);
     }
 
     public function applyChanges(object $entity): void
     {
         foreach ($this->processedPropertyValues as $propertyName => $data) {
-            $accessor = new PropertyAccessor($entity, $propertyName);
-            $accessor->setValue($data['value']);
+            (new PropertyAccessor($entity, $propertyName))->setValue($data['value']);
         }
     }
 

src/AttributeHandler.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\PropertyInspector\Contract;
+
+use KaririCode\Contract\Processor\Attribute\ProcessableAttribute;
+
+interface ProcessorConfigBuilder
+{
+    /**
+     * Constrói a configuração dos processadores a partir de um atributo processável.
+     *
+     * @param ProcessableAttribute $attribute o atributo que fornece os processadores
+     *
+     * @return array a configuração dos processadores
+     */
+    public function build(ProcessableAttribute $attribute): array;
+}

src/Contract/ProcessorConfigBuilder.php

@@ -5,8 +5,9 @@
 namespace KaririCode\PropertyInspector\Processor;
 
 use KaririCode\Contract\Processor\Attribute\ProcessableAttribute;
+use KaririCode\PropertyInspector\Contract\ProcessorConfigBuilder as ProcessorConfigBuilderContract;
 
-readonly class ProcessorConfigBuilder
+readonly class ProcessorConfigBuilder implements ProcessorConfigBuilderContract
 {
     public function build(ProcessableAttribute $attribute): array
     {