symfony · Ninos · Jan 27, 2025 · smnandre · Jan 28, 2025 · smnandre
diff --git a/src/Symfony/Component/Validator/CHANGELOG.md b/src/Symfony/Component/Validator/CHANGELOG.md
@@ -56,6 +56,7 @@ CHANGELOG
   ```
 * Add support for ratio checks for SVG files to the `Image` constraint
 * Add the `Slug` constraint
+ * Add support for enums in `Choice` constraint

 7.2
 ---

diff --git a/src/Symfony/Component/Validator/ConstraintValidator.php b/src/Symfony/Component/Validator/ConstraintValidator.php
@@ -86,7 +86,7 @@ protected function formatValue(mixed $value, int $format = 0): string
        }

        if ($value instanceof \UnitEnum) {
-            return $value->name;
+            $value = $value instanceof \BackedEnum ? $value->value : $value->name;
        }

        if (\is_object($value)) {

diff --git a/src/Symfony/Component/Validator/Constraints/Choice.php b/src/Symfony/Component/Validator/Constraints/Choice.php
@@ -18,6 +18,7 @@
 * Validates that a value is one of a given set of valid choices.
 *
 * @author Bernhard Schussek <bschussek@gmail.com>
+ * @author Ninos Ego <me@ninosego.de>
 */
 #[\Attribute(\Attribute::TARGET_PROPERTY | \Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)]
 class Choice extends Constraint
@@ -32,7 +33,8 @@ class Choice extends Constraint
        self::TOO_MANY_ERROR => 'TOO_MANY_ERROR',
    ];

-    public ?array $choices = null;
+    /** @var \class-string|array|null */
+    public string|array|null $choices = null;
    /** @var callable|string|null */
    public $callback;
    public bool $multiple = false;
@@ -45,25 +47,27 @@ class Choice extends Constraint
    public string $maxMessage = 'You must select at most {{ limit }} choice.|You must select at most {{ limit }} choices.';
    public bool $match = true;

+    public ?\Closure $normalizer;
+
    public function getDefaultOption(): ?string
    {
        return 'choices';
    }

    /**
-     * @param array|null           $choices  An array of choices (required unless a callback is specified)
-     * @param callable|string|null $callback Callback method to use instead of the choice option to get the choices
-     * @param bool|null            $multiple Whether to expect the value to be an array of valid choices (defaults to false)
-     * @param bool|null            $strict   This option defaults to true and should not be used
-     * @param int<0, max>|null     $min      Minimum of valid choices if multiple values are expected
-     * @param positive-int|null    $max      Maximum of valid choices if multiple values are expected
-     * @param string[]|null        $groups
-     * @param bool|null            $match    Whether to validate the values are part of the choices or not (defaults to true)
+     * @param \class-string|array|null $choices  An enum or array of choices (required unless a callback is specified)
+     * @param callable|string|null     $callback Callback method to use instead of the choice option to get the choices
+     * @param bool|null                $multiple Whether to expect the value to be an array of valid choices (defaults to false)
+     * @param bool|null                $strict   This option defaults to true and should not be used
+     * @param int<0, max>|null         $min      Minimum of valid choices if multiple values are expected
+     * @param positive-int|null        $max      Maximum of valid choices if multiple values are expected
+     * @param string[]|null            $groups
+     * @param bool|null                $match    Whether to validate the values are part of the choices or not (defaults to true)
     */
    #[HasNamedArguments]
    public function __construct(
        string|array $options = [],
-        ?array $choices = null,
+        string|array|null $choices = null,
        callable|string|null $callback = null,
        ?bool $multiple = null,
        ?bool $strict = null,
@@ -73,11 +77,12 @@ public function __construct(
        ?string $multipleMessage = null,
        ?string $minMessage = null,
        ?string $maxMessage = null,
+        ?callable $normalizer = null,
        ?array $groups = null,
        mixed $payload = null,
        ?bool $match = null,
    ) {
-        if (\is_array($options) && $options && array_is_list($options)) {
+        if (\is_array($options) && $options && \array_is_list($options)) {
            $choices ??= $options;
            $options = [];
        } elseif (\is_array($options) && [] !== $options) {
@@ -100,5 +105,6 @@ public function __construct(
        $this->minMessage = $minMessage ?? $this->minMessage;
        $this->maxMessage = $maxMessage ?? $this->maxMessage;
        $this->match = $match ?? $this->match;
+        $this->normalizer = null !== $normalizer ? $normalizer(...) : null;
    }
 }
diff --git a/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php b/src/Symfony/Component/Validator/Constraints/ChoiceValidator.php
@@ -24,6 +24,7 @@
 * @author Fabien Potencier <fabien@symfony.com>
 * @author Florian Eckerstorfer <florian@eckerstorfer.org>
 * @author Bernhard Schussek <bschussek@gmail.com>
+ * @author Ninos Ego <me@ninosego.de>
 */
 class ChoiceValidator extends ConstraintValidator
 {
@@ -33,16 +34,24 @@ public function validate(mixed $value, Constraint $constraint): void
            throw new UnexpectedTypeException($constraint, Choice::class);
        }

-        if (!\is_array($constraint->choices) && !$constraint->callback) {
+        if (null === $constraint->choices && !$constraint->callback) {
            throw new ConstraintDefinitionException('Either "choices" or "callback" must be specified on constraint Choice.');
        }

+        if (null !== $constraint->choices && !\is_array($constraint->choices) && (!\is_string($constraint->choices) || !\enum_exists($constraint->choices))) {
+            throw new ConstraintDefinitionException('"choices" must be of type array or enum-class.');
+        }
+
        if (null === $value) {
            return;
        }

-        if ($constraint->multiple && !\is_array($value)) {
-            throw new UnexpectedValueException($value, 'array');
+        if (null !== $constraint->normalizer) {
+            $value = ($constraint->normalizer)($value);
+        }
+
+        if ($constraint->multiple && !\is_array($value) && !$value instanceof \IteratorAggregate) {
+            throw new UnexpectedValueException($value, 'array|IteratorAggregate');
        }

        if ($constraint->callback) {
@@ -56,6 +65,10 @@ public function validate(mixed $value, Constraint $constraint): void
            if (!\is_array($choices)) {
                throw new ConstraintDefinitionException(\sprintf('The Choice constraint callback "%s" is expected to return an array, but returned "%s".', trim($this->formatValue($constraint->callback), '"'), get_debug_type($choices)));
            }
+        } elseif (\is_string($constraint->choices) && \enum_exists($constraint->choices)) {
+            $choices = \array_map(static function(\UnitEnum $value): string|int {
+                return $value instanceof \BackedEnum ? $value->value : $value->name;
+            }, $constraint->choices::cases());
        } else {
            $choices = $constraint->choices;
        }

diff --git a/src/Symfony/Component/Validator/Constraints/Cidr.php b/src/Symfony/Component/Validator/Constraints/Cidr.php
@@ -33,7 +33,7 @@ class Cidr extends Constraint

    protected const ERROR_NAMES = [
        self::INVALID_CIDR_ERROR => 'INVALID_CIDR_ERROR',
-        self::OUT_OF_RANGE_ERROR => 'OUT_OF_RANGE_VIOLATION',
+        self::OUT_OF_RANGE_ERROR => 'OUT_OF_RANGE_ERROR',
    ];

    private const NET_MAXES = [

diff --git a/src/Symfony/Component/Validator/Tests/ConstraintValidatorTest.php b/src/Symfony/Component/Validator/Tests/ConstraintValidatorTest.php
@@ -14,7 +14,9 @@
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Validator\Constraint;
 use Symfony\Component\Validator\ConstraintValidator;
-use Symfony\Component\Validator\Tests\Fixtures\TestEnum;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumBackendInteger;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumBackendString;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumUnit;

 class ConstraintValidatorTest extends TestCase
 {
@@ -49,7 +51,9 @@ public static function formatValueProvider(): array
            [class_exists(\IntlDateFormatter::class) ? static::normalizeIcuSpaces("Feb 2, 1971, 8:00\u{202F}AM") : '1971-02-02 08:00:00', $dateTime, ConstraintValidator::PRETTY_DATE],
            [class_exists(\IntlDateFormatter::class) ? static::normalizeIcuSpaces("Jan 1, 1970, 6:00\u{202F}AM") : '1970-01-01 06:00:00', new \DateTimeImmutable('1970-01-01T06:00:00Z'), ConstraintValidator::PRETTY_DATE],
            [class_exists(\IntlDateFormatter::class) ? static::normalizeIcuSpaces("Jan 1, 1970, 3:00\u{202F}PM") : '1970-01-01 15:00:00', (new \DateTimeImmutable('1970-01-01T23:00:00'))->setTimezone(new \DateTimeZone('America/New_York')), ConstraintValidator::PRETTY_DATE],
-            ['FirstCase', TestEnum::FirstCase],
+            ['"FirstCase"', TestEnumUnit::FirstCase],
+            ['"a"', TestEnumBackendString::FirstCase],
+            ['3', TestEnumBackendInteger::FirstCase],
        ];

        date_default_timezone_set($defaultTimezone);

diff --git a/src/Symfony/Component/Validator/Tests/Constraints/ChoiceTest.php b/src/Symfony/Component/Validator/Tests/Constraints/ChoiceTest.php
@@ -16,9 +16,19 @@
 use Symfony\Component\Validator\Mapping\ClassMetadata;
 use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
 use Symfony\Component\Validator\Tests\Fixtures\ConstraintChoiceWithPreset;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumBackendInteger;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumBackendString;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumUnit;

 class ChoiceTest extends TestCase
 {
+    public function testNormalizerCanBeSet()
+    {
+        $choice = new Choice(normalizer: 'trim');
+
+        $this->assertEquals(trim(...), $choice->normalizer);
+    }
+
    public function testSetDefaultPropertyChoice()
    {
        $constraint = new ConstraintChoiceWithPreset('A');
@@ -52,6 +62,18 @@ public function testAttributes()
        /** @var Choice $stringIndexedConstraint */
        [$stringIndexedConstraint] = $metadata->properties['stringIndexed']->getConstraints();
        self::assertSame(['one' => 1, 'two' => 2], $stringIndexedConstraint->choices);
+
+        /** @var Choice $enumUnitConstraint */
+        [$enumUnitConstraint] = $metadata->properties['enumUnit']->getConstraints();
+        self::assertSame(TestEnumUnit::class, $enumUnitConstraint->choices);
+
+        /** @var Choice $enumBackendStringConstraint */
+        [$enumBackendStringConstraint] = $metadata->properties['enumBackendString']->getConstraints();
+        self::assertSame(TestEnumBackendString::class, $enumBackendStringConstraint->choices);
+
+        /** @var Choice $enumBackendIntegerConstraint */
+        [$enumBackendIntegerConstraint] = $metadata->properties['enumBackendInteger']->getConstraints();
+        self::assertSame(TestEnumBackendInteger::class, $enumBackendIntegerConstraint->choices);
    }
 }

@@ -68,4 +90,13 @@ class ChoiceDummy

    #[Choice(choices: ['one' => 1, 'two' => 2])]
    private $stringIndexed;
+
+    #[Choice(choices: TestEnumUnit::class)]
+    private $enumUnit;
+
+    #[Choice(choices: TestEnumBackendString::class)]
+    private $enumBackendString;
+
+    #[Choice(choices: TestEnumBackendInteger::class)]
+    private $enumBackendInteger;
 }
diff --git a/src/Symfony/Component/Validator/Tests/Constraints/ChoiceValidatorTest.php b/src/Symfony/Component/Validator/Tests/Constraints/ChoiceValidatorTest.php
@@ -16,6 +16,9 @@
 use Symfony\Component\Validator\Exception\ConstraintDefinitionException;
 use Symfony\Component\Validator\Exception\UnexpectedValueException;
 use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumBackendInteger;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumBackendString;
+use Symfony\Component\Validator\Tests\Fixtures\TestEnumUnit;

 function choice_callback()
 {
@@ -119,8 +122,8 @@ public function testValidChoiceCallbackFunction(Choice $constraint)

    public static function provideConstraintsWithCallbackFunction(): iterable
    {
-        yield 'named arguments, namespaced function' => [new Choice(callback: __NAMESPACE__.'\choice_callback')];
-        yield 'named arguments, closure' => [new Choice(callback: fn () => ['foo', 'bar'])];
+        yield 'named arguments, namespaced function' => [new Choice(callback: __NAMESPACE__ . '\choice_callback')];
+        yield 'named arguments, closure' => [new Choice(callback: fn() => ['foo', 'bar'])];
        yield 'named arguments, static method' => [new Choice(callback: [__CLASS__, 'staticCallback'])];
    }

@@ -137,9 +140,9 @@ public function testValidChoiceCallbackFunctionDoctrineStyle(Choice $constraint)

    public static function provideLegacyConstraintsWithCallbackFunctionDoctrineStyle(): iterable
    {
-        yield 'doctrine style, namespaced function' => [new Choice(['callback' => __NAMESPACE__.'\choice_callback'])];
+        yield 'doctrine style, namespaced function' => [new Choice(['callback' => __NAMESPACE__ . '\choice_callback'])];
        yield 'doctrine style, closure' => [new Choice([
-            'callback' => fn () => ['foo', 'bar'],
+            'callback' => fn() => ['foo', 'bar'],
        ])];
        yield 'doctrine style, static method' => [new Choice(['callback' => [__CLASS__, 'staticCallback']])];
    }
@@ -232,8 +235,8 @@ public function testInvalidChoiceDoctrineStyle()
    public function testInvalidChoiceEmptyChoices()
    {
        $constraint = new Choice(
-            // May happen when the choices are provided dynamically, e.g. from
-            // the DB or the model
+        // May happen when the choices are provided dynamically, e.g. from
+        // the DB or the model
            choices: [],
            message: 'myMessage',
        );
@@ -262,6 +265,7 @@ public function testInvalidChoiceMultiple()
            ->setCode(Choice::NO_SUCH_CHOICE_ERROR)
            ->assertRaised();
    }
+
    /**
     * @group legacy
     */
@@ -443,4 +447,87 @@ public function testMatchFalseWithMultiple()
            ->setInvalidValue('bar')
            ->assertRaised();
    }
+
+    public function testValidEnumUnit()
+    {
+        $this->validator->validate('FirstCase', new Choice(
+            choices: TestEnumUnit::class,
+            message: 'myMessage',
+        ));
+
+        $this->assertNoViolation();
+    }
+
+    public function testInvalidEnumUnit()
+    {
+        $this->validator->validate('NoneCase', new Choice(
+            choices: TestEnumUnit::class,
+            message: 'myMessage',
+        ));
+
+        $this->buildViolation('myMessage')
+            ->setParameter('{{ value }}', '"NoneCase"')
+            ->setParameter('{{ choices }}', '"FirstCase", "SecondCase"')
+            ->setCode(Choice::NO_SUCH_CHOICE_ERROR)
+            ->assertRaised();
+    }
+
+    public function testValidEnumBackendString()
+    {
+        $this->validator->validate('a', new Choice(
+            choices: TestEnumBackendString::class,
+            message: 'myMessage',
+        ));
+
+        $this->assertNoViolation();
+    }
+
+    public function testInvalidEnumBackendString()
+    {
+        $this->validator->validate('none', new Choice(
+            choices: TestEnumBackendString::class,
+            message: 'myMessage',
+        ));
+
+        $this->buildViolation('myMessage')
+            ->setParameter('{{ value }}', '"none"')
+            ->setParameter('{{ choices }}', '"a", "b"')
+            ->setCode(Choice::NO_SUCH_CHOICE_ERROR)
+            ->assertRaised();
+    }
+
+    public function testValidEnumBackendInteger()
+    {
+        $this->validator->validate(3, new Choice(
+            choices: TestEnumBackendInteger::class,
+            message: 'myMessage',
+        ));
+
+        $this->assertNoViolation();
+    }
+
+    public function testValidEnumBackendIntegerNormalize()
+    {
+        $this->validator->validate('3', new Choice(
+            choices: TestEnumBackendInteger::class,
+            message: 'myMessage',
+            normalizer: 'intval',
+        ));
+
+        $this->assertNoViolation();
+    }
+
+    public function testInvalidEnumBackendInteger()
+    {
+        $this->validator->validate(9, new Choice(
+            choices: TestEnumBackendInteger::class,
+            message: 'myMessage',
+        ));
+
+        $this->buildViolation('myMessage')
+            ->setParameter('{{ value }}', '9')
+            ->setParameter('{{ choices }}', '3, 4')
+            ->setCode(Choice::NO_SUCH_CHOICE_ERROR)
+            ->assertRaised();
+    }
 }
diff --git a/src/Symfony/Component/Validator/Tests/Fixtures/TestEnumBackendInteger.php b/src/Symfony/Component/Validator/Tests/Fixtures/TestEnumBackendInteger.php
@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Validator\Tests\Fixtures;
+
+/**
+ * @author Ninos Ego <me@ninosego.de>
+ */
+enum TestEnumBackendInteger: int
+{
+    case FirstCase = 3;
+    case SecondCase = 4;
+}
-Original file line number
+Diff line change
@@ -56,6 +56,7 @@ CHANGELOG
        ```
      * Add support for ratio checks for SVG files to the `Image` constraint
      * Add the `Slug` constraint
+     * Add support for enums in `Choice` constraint
             Copy link

  
      
    
  

  
      

  
  Member


      

  

  
    
      

      
            smnandre
  

      

      

      


        Jan 28, 2025


      
    

  


        
      
  
  
  
    

    There was a problem hiding this comment.


  

 
  
    

    Choose a reason for hiding this comment

    
      The reason will be displayed to describe this comment to others. Learn more.
    

    
      
      


  


  
    
      Enums are already supported
This PR add  supports for using a class-string to specify the list of possible values ( integer or string )
    
  
  


    

        
      
  
  
    
  
  
  
    
    Sorry, something went wrong.
  

  
    
  
    
      

              Uh oh!

              
There was an error while loading. Please reload this page.


  
  


          
      
  
    
    
            Ninos reacted with thumbs up emoji
      
        
            
    All reactions
  


          
              
                👍
                  1 reaction
 .2
     ---
-          Expand Down