feat: Handle enum with constructor data mapper

src/DataMapper/ConstructorDataMapper.php

@@ -163,7 +163,7 @@
                 $required = $fallback !== null; // Null fallback means that the parameter is nullable, so it's not required
                 $requiredMessage = $baseRequired->message;
 
                 if ($required && $parameter->isPromoted()) {
                     // Get the actual required error message
                     foreach ((new ReflectionProperty($this->className, $parameter->name))->getAttributes(Required::class) as $attribute) {
                         $requiredMessage = $attribute->newInstance()->message;
@@ -184,24 +184,30 @@
 
     private function resolveFallbackValueFromType(?ReflectionType $type): mixed
     {
         if (!$type || $type->allowsNull()) {
             return null;
         }
 
         if (!$type instanceof ReflectionNamedType) {
             throw new LogicException(sprintf('Cannot use complex type with %s on %s', self::class, $this->className));
         }
 
         if (!$type->isBuiltin()) {
             // @phpstan-ignore-next-line
-            return (new ReflectionClass($type->getName()))->newInstanceWithoutConstructor();
+            $class = new ReflectionClass($type->getName());
+
+            if ($class->isEnum()) {
+                return $type->getName()::cases()[0];
+            }
+
+            return $class->newInstanceWithoutConstructor();
         }
 
         return match ($type->getName()) {
             'int' => 0,
             'float' => 0.0,
             'string' => '',
             'bool' => false,
             'array' => [],
             'object' => new stdClass(),
             default => throw new LogicException(sprintf('Cannot resolve fallback value for type %s on %s', $type->getName(), $this->className)),

src/DataMapper/ConstructorParameterMetadata.php

@@ -6,6 +6,7 @@
 use Quatrevieux\Form\Util\Expr;
 use ReflectionClass;
 use stdClass;
+use UnitEnum;
 
 use function is_object;
 
@@ -20,8 +21,12 @@
 
     public function compiledFallback(): string
     {
-        if (is_object($this->fallback) && $this->fallback::class !== stdClass::class) {
+        if (
+            is_object($this->fallback)
+            && $this->fallback::class !== stdClass::class
+            && !$this->fallback instanceof UnitEnum
+        ) {
             return (string) Expr::new(ReflectionClass::class, [$this->fallback::class])->newInstanceWithoutConstructor();
         }
 
         return Code::value($this->fallback);

tests/DataMapper/ConstructorDataMapperTest.php

@@ -5,7 +5,9 @@
 use PHPUnit\Framework\TestCase;
 use Quatrevieux\Form\DataMapper\Generator\DataMapperGenerator;
 use Quatrevieux\Form\DefaultRegistry;
+use Quatrevieux\Form\Fixtures\ConstructorWithSimpleEnum;
 use Quatrevieux\Form\Fixtures\EmbeddedFormConstructor;
+use Quatrevieux\Form\Fixtures\MySimpleEnum;
 use Quatrevieux\Form\Fixtures\RequestWithDefaultValueConstructor;
 use Quatrevieux\Form\Fixtures\RequiredParametersRequestConstructor;
 use Quatrevieux\Form\Fixtures\SimpleRequestConstructor;
@@ -148,7 +150,6 @@ public function test_with_embedded()
         $this->assertEquals('This value is required', (string) $dto->errors['bar']);
         $this->assertEquals('This value is required', (string) $dto->errors['embedded']);
 
-
         $dto = $mapper->toDataObject([
             'foo' => 'azerty',
             'bar' => 'uiop',
@@ -185,4 +186,45 @@ public function test_with_embedded()
             $mapper->generateToDataObject($mapper)
         );
     }
+
+    public function test_with_enum()
+    {
+        $mapper = new ConstructorDataMapper(ConstructorWithSimpleEnum::class, new DefaultRegistry());
+
+        $dto = $mapper->toDataObject([]);
+
+        $this->assertSame(ConstructorWithSimpleEnum::class, $mapper->className());
+        $this->assertInstanceOf(ConstructorWithSimpleEnum::class, $dto->dto);
+
+        $this->assertSame(MySimpleEnum::Foo, $dto->dto->enum);
+
+        $this->assertCount(1, $dto->errors);
+        $this->assertEquals('This value is required', (string) $dto->errors['enum']);
+
+        $dto = $mapper->toDataObject([
+            'enum' => MySimpleEnum::Bar,
+        ]);
+
+        $this->assertEquals(new ConstructorWithSimpleEnum(
+            enum: MySimpleEnum::Bar
+        ), $dto->dto);
+
+        $this->assertEmpty($dto->errors);
+
+        $this->assertSame(
+            <<<'PHP'
+                $errors = [];
+                $dto = new \Quatrevieux\Form\Fixtures\ConstructorWithSimpleEnum(enum: $fields['enum'] ?? \Quatrevieux\Form\Fixtures\MySimpleEnum::Foo);
+
+                foreach (['enum' => 'This value is required'] as $field => $message) {
+                    if (!isset($fields[$field])) {
+                        $errors[$field] = new \Quatrevieux\Form\Validator\FieldError($message, [], 'b1ac3a70-06db-5cd6-8f0e-8e6b98b3fcb5', $this->registry->getTranslator());
+                    }
+                }
+
+                return new \Quatrevieux\Form\DataMapper\DataMapperResult($dto, $errors);
+            PHP,
+            $mapper->generateToDataObject($mapper)
+        );
+    }
 }

tests/Fixtures/ConstructorWithSimpleEnum.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Quatrevieux\Form\Fixtures;
+
+class ConstructorWithSimpleEnum
+{
+    public function __construct(
+        public readonly MySimpleEnum $enum,
+    ) {}
+}
+
+enum MySimpleEnum
+{
+    case Foo;
+    case Bar;
+}