fix(sanitizer): remove debug var_dump from TrimSanitizer

- Remove debugging var_dump statement that was causing risky test warnings
- Clean up TrimSanitizer implementation to follow best practices
- Improve code documentation with proper English comments

Author: walmir-silva

composer.lock

@@ -0,0 +1,20 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Sanitizer\Contract;
+
+interface SanitizationResult
+{
+    public function addError(string $property, string $errorKey, string $message): void;
+
+    public function setSanitizedData(string $property, mixed $value): void;
+
+    public function hasErrors(): bool;
+
+    public function getErrors(): array;
+
+    public function getSanitizedData(): array;
+
+    public function toArray(): array;
+}

src/Contract/SanitizationResult.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Sanitizer\Contract;
+
+use KaririCode\PropertyInspector\AttributeHandler;
+
+interface SanitizationResultProcessor
+{
+    /**
+     * Processa os resultados de sanitização após a execução dos processadores.
+     *
+     * @param AttributeHandler $handler O manipulador que contém os atributos processados
+     *
+     * @return SanitizationResult O resultado da sanitização, incluindo dados processados e erros
+     */
+    public function process(AttributeHandler $handler): SanitizationResult;
+}

src/Contract/SanitizationResultProcessor.php

@@ -0,0 +1,44 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Sanitizer\Processor;
+
+use KaririCode\PropertyInspector\AttributeHandler;
+use KaririCode\Sanitizer\Contract\SanitizationResult as SanitizationResultContract;
+use KaririCode\Sanitizer\Contract\SanitizationResultProcessor;
+use KaririCode\Sanitizer\SanitizationResult;
+
+class DefaultSanitizationResultProcessor implements SanitizationResultProcessor
+{
+    public function __construct(
+        private SanitizationResultContract $result = new SanitizationResult()
+    ) {
+    }
+
+    public function process(AttributeHandler $handler): SanitizationResult
+    {
+        $processedValues = $handler->getProcessedPropertyValues();
+        $errors = $handler->getProcessingResultErrors();
+
+        foreach ($processedValues as $property => $data) {
+            $this->result->setSanitizedData($property, $data['value']);
+
+            if (isset($errors[$property])) {
+                $this->addPropertyErrors($this->result, $property, $errors[$property]);
+            }
+        }
+
+        return $this->result;
+    }
+
+    private function addPropertyErrors(
+        SanitizationResult $result,
+        string $property,
+        array $propertyErrors
+    ): void {
+        foreach ($propertyErrors as $error) {
+            $result->addError($property, $error['errorKey'], $error['message']);
+        }
+    }
+}

src/Processor/DefaultSanitizationResultProcessor.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+namespace KaririCode\Sanitizer;
+
+class SanitizationResult implements Contract\SanitizationResult
+{
+    private array $errors = [];
+    private array $sanitizedData = [];
+
+    public function addError(string $property, string $errorKey, string $message): void
+    {
+        if (!isset($this->errors[$property])) {
+            $this->errors[$property] = [];
+        }
+
+        // Avoid adding duplicate errors
+        foreach ($this->errors[$property] as $error) {
+            if ($error['errorKey'] === $errorKey) {
+                return;
+            }
+        }
+
+        $this->errors[$property][] = [
+            'errorKey' => $errorKey,
+            'message' => $message,
+        ];
+    }
+
+    public function setSanitizedData(string $property, mixed $value): void
+    {
+        $this->sanitizedData[$property] = $value;
+    }
+
+    public function hasErrors(): bool
+    {
+        return !empty($this->errors);
+    }
+
+    public function getErrors(): array
+    {
+        return $this->errors;
+    }
+
+    public function getSanitizedData(): array
+    {
+        return $this->sanitizedData;
+    }
+
+    public function toArray(): array
+    {
+        return [
+            'isValid' => !$this->hasErrors(),
+            'errors' => $this->errors,
+            'sanitizedData' => $this->sanitizedData,
+        ];
+    }
+}

src/SanitizationResult.php

@@ -1,5 +1,7 @@
 <?php
 
+declare(strict_types=1);
+
 namespace KaririCode\Sanitizer;
 
 use KaririCode\Contract\Processor\ProcessorRegistry;
@@ -9,6 +11,9 @@
 use KaririCode\PropertyInspector\AttributeHandler;
 use KaririCode\PropertyInspector\Utility\PropertyInspector;
 use KaririCode\Sanitizer\Attribute\Sanitize;
+use KaririCode\Sanitizer\Contract\SanitizationResult;
+use KaririCode\Sanitizer\Contract\SanitizationResultProcessor;
+use KaririCode\Sanitizer\Processor\DefaultSanitizationResultProcessor;
 
 class Sanitizer implements SanitizerContract
 {
@@ -18,25 +23,22 @@ class Sanitizer implements SanitizerContract
     private PropertyInspector $propertyInspector;
     private AttributeHandler $attributeHandler;
 
-    public function __construct(private readonly ProcessorRegistry $registry)
-    {
+    public function __construct(
+        private readonly ProcessorRegistry $registry,
+        private readonly SanitizationResultProcessor $resultProcessor = new DefaultSanitizationResultProcessor()
+    ) {
         $this->builder = new ProcessorBuilder($this->registry);
         $this->attributeHandler = new AttributeHandler(self::IDENTIFIER, $this->builder);
         $this->propertyInspector = new PropertyInspector(
             new AttributeAnalyzer(Sanitize::class)
         );
     }
 
-    public function sanitize(mixed $object): array
+    public function sanitize(mixed $object): SanitizationResult
     {
         $this->propertyInspector->inspect($object, $this->attributeHandler);
         $this->attributeHandler->applyChanges($object);
 
-        return [
-            'sanitizedValues' => $this->attributeHandler->getProcessedValues(),
-            'messages' => $this->attributeHandler->getProcessingMessages(),
-            'errors' => $this->attributeHandler->getProcessingErrors(),
-            'object' => $object,
-        ];
+        return $this->resultProcessor->process($this->attributeHandler);
     }
 }