Move transforming filter serialization methods to SerializationPostProcessor

Author: wol-soft

src/Model/Property/Serializer/TransformingFilterSerializer.php

@@ -24,6 +24,8 @@ class FilterValidator extends PropertyTemplateValidator
 {
     /** @var FilterInterface $filter */
     protected $filter;
+    /** @var array */
+    protected $filterOptions;
 
     /**
      * FilterValidator constructor.
@@ -45,6 +47,7 @@ public function __construct(
         ?TransformingFilterInterface $transformingFilter = null
     ) {
         $this->filter = $filter;
+        $this->filterOptions = $filterOptions;
 
         $transformingFilter === null
             ? $this->validateFilterCompatibilityWithBaseType($filter, $property)
@@ -199,4 +202,20 @@ private function mapDataTypes(array $acceptedTypes): array
             }
         }, $acceptedTypes);
     }
+
+    /**
+     * @return FilterInterface
+     */
+    public function getFilter(): FilterInterface
+    {
+        return $this->filter;
+    }
+
+    /**
+     * @return array
+     */
+    public function getFilterOptions(): array
+    {
+        return $this->filterOptions;
+    }
 }

src/Model/Validator/FilterValidator.php

@@ -100,18 +100,6 @@ public function process(
                     if (!$typeAfterFilter->isBuiltin()) {
                         $schema->addUsedClass($typeAfterFilter->getName());
                     }
-
-                    if ($generatorConfiguration->hasSerializationEnabled()) {
-                        $schema->addMethod(
-                            "serialize{$property->getAttribute()}",
-                            new TransformingFilterSerializer(
-                                $property->getAttribute(),
-                                $filter,
-                                $filterOptions,
-                                $generatorConfiguration
-                            )
-                        );
-                    }
                 }
             }
         }

src/PropertyProcessor/Filter/FilterProcessor.php

@@ -7,7 +7,10 @@
 use JsonSerializable;
 use PHPModelGenerator\Interfaces\SerializationInterface;
 use PHPModelGenerator\Model\GeneratorConfiguration;
+use PHPModelGenerator\Model\Property\Serializer\TransformingFilterSerializer;
 use PHPModelGenerator\Model\Schema;
+use PHPModelGenerator\Model\Validator\FilterValidator;
+use PHPModelGenerator\PropertyProcessor\Filter\TransformingFilterInterface;
 use PHPModelGenerator\Traits\SerializableTrait;
 
 /**
@@ -17,11 +20,57 @@
  */
 class SerializationPostProcessor implements PostProcessorInterface
 {
+    /**
+     * Add serialization support to the provided schema
+     *
+     * @param Schema $schema
+     * @param GeneratorConfiguration $generatorConfiguration
+     */
     public function process(Schema $schema, GeneratorConfiguration $generatorConfiguration): void
     {
         $schema
             ->addTrait(SerializableTrait::class)
             ->addInterface(JsonSerializable::class)
             ->addInterface(SerializationInterface::class);
+
+        $this->addSerializeFunctionsForTransformingFilters($schema, $generatorConfiguration);
+    }
+
+    /**
+     * Each transforming filter must provide a method to serialize the value. Add a method to the schema to call the
+     * serialization for each property with a transforming filter
+     *
+     * @param Schema $schema
+     * @param GeneratorConfiguration $generatorConfiguration
+     */
+    private function addSerializeFunctionsForTransformingFilters(
+        Schema $schema,
+        GeneratorConfiguration $generatorConfiguration
+    ): void {
+        foreach ($schema->getProperties() as $property) {
+            foreach ($property->getValidators() as $validator) {
+                $validator = $validator->getValidator();
+
+                if ($validator instanceof FilterValidator &&
+                    $validator->getFilter() instanceof TransformingFilterInterface
+                ) {
+                    $schema->addMethod(
+                        "serialize{$property->getAttribute()}",
+                        new RenderedMethod(
+                            $schema,
+                            $generatorConfiguration,
+                            'TransformingFilterSerializer.phptpl',
+                            [
+
+                                'property' => $property->getAttribute(),
+                                'serializerClass' => $validator->getFilter()->getSerializer()[0],
+                                'serializerMethod' => $validator->getFilter()->getSerializer()[1],
+                                'serializerOptions' => var_export($validator->getFilterOptions(), true),
+                            ]
+                        )
+                    );
+                }
+            }
+        }
     }
 }