add handling for enum as haystack

src/InArray.php

@@ -2,14 +2,18 @@
 
 namespace Laminas\Validator;
 
+use BackedEnum;
 use RecursiveArrayIterator;
 use RecursiveIteratorIterator;
+use UnitEnum;
 
+use function array_map;
 use function in_array;
 use function is_bool;
 use function is_float;
 use function is_int;
 use function is_string;
+use function is_subclass_of;
 
 class InArray extends AbstractValidator
 {
@@ -46,6 +50,13 @@ class InArray extends AbstractValidator
      */
     protected $haystack;
 
+    /**
+     * Enum of possible values
+     *
+     * @var class-string<UnitEnum>|null
+     */
+    protected $enum;
+
     /**
      * Type of strict check to be used. Due to "foo" == 0 === TRUE with in_array when strict = false,
      * an option has been added to prevent this. When $strict = 0/false, the most
@@ -66,7 +77,7 @@ class InArray extends AbstractValidator
     /**
      * Returns the haystack option
      *
-     * @return mixed
+     * @return array
      * @throws Exception\RuntimeException If haystack option is not set.
      */
     public function getHaystack()
@@ -80,7 +91,7 @@ public function getHaystack()
     /**
      * Sets the haystack option
      *
-     * @param  mixed $haystack
+     * @param array $haystack
      * @return $this Provides a fluent interface
      */
     public function setHaystack(array $haystack)
@@ -89,6 +100,30 @@ public function setHaystack(array $haystack)
         return $this;
     }
 
+    /**
+     * @return class-string<UnitEnum>|null
+     */
+    public function getEnum(): ?string
+    {
+        return $this->enum;
+    }
+
+    /**
+     * Set the enum option
+     *
+     * @param class-string<UnitEnum> $enum
+     * @return $this Provides a fluent interface
+     */
+    public function setEnum(string $enum): self
+    {
+        if (! is_subclass_of($enum, UnitEnum::class)) {
+            throw new Exception\RuntimeException('enum has invalid type');
+        }
+
+        $this->enum = $enum;
+        return $this;
+    }
+
     /**
      * Returns the strict option
      *
@@ -169,6 +204,35 @@ public function setRecursive($recursive)
      */
     public function isValid($value)
     {
+        $enum = $this->getEnum();
+        if (is_string($enum)) {
+            if (is_subclass_of($enum, 'BackedEnum')) {
+                $enumHaystack = array_map(
+                    static fn (BackedEnum $case) => $case->value,
+                    $enum::cases()
+                );
+
+                if (in_array($value, $enumHaystack, (bool) $this->strict)) {
+                    return true;
+                }
+
+                $this->error(self::NOT_IN_ARRAY);
+                return false;
+            }
+
+            $enumHaystack = array_map(
+                static fn (UnitEnum $case): string => $case->name,
+                $enum::cases()
+            );
+
+            if (in_array($value, $enumHaystack, (bool) $this->strict)) {
+                return true;
+            }
+
+            $this->error(self::NOT_IN_ARRAY);
+            return false;
+        }
+
         // we create a copy of the haystack in case we need to modify it
         $haystack = $this->getHaystack();
 

test/InArrayTest.php

@@ -6,6 +6,10 @@
 
 use Laminas\Validator\Exception\RuntimeException;
 use Laminas\Validator\InArray;
+use LaminasTest\Validator\TestAsset\CustomTraversable;
+use LaminasTest\Validator\TestAsset\Enum\TestBackedIntEnum;
+use LaminasTest\Validator\TestAsset\Enum\TestBackedStringEnum;
+use LaminasTest\Validator\TestAsset\Enum\TestUnitEnum;
 use PHPUnit\Framework\TestCase;
 
 use function array_keys;
@@ -472,4 +476,52 @@ public function testBooleanNotStrictEnforcesNonStrictMode(array $haystack, mixed
         self::assertTrue($validator->isValid($valid));
         self::assertFalse($validator->isValid($invalid));
     }
+
+    /**
+     * @requires PHP 8.1
+     */
+    public function testEnumValidation(): void
+    {
+        $validator = new InArray([
+            'enum' => TestUnitEnum::class,
+        ]);
+
+        self::assertTrue($validator->isValid('foo'));
+        self::assertFalse($validator->isValid('baz'));
+
+        $validator = new InArray([
+            'enum' => TestBackedStringEnum::class,
+        ]);
+
+        self::assertTrue($validator->isValid('foo'));
+        self::assertFalse($validator->isValid('baz'));
+
+        $validator = new InArray([
+            'enum' => TestBackedIntEnum::class,
+        ]);
+
+        self::assertTrue($validator->isValid(1));
+        self::assertFalse($validator->isValid(3));
+
+        $validator = new InArray([
+            'enum'   => TestBackedIntEnum::class,
+            'strict' => true,
+        ]);
+
+        self::assertTrue($validator->isValid(1));
+        self::assertFalse($validator->isValid('2'));
+    }
+
+    /**
+     * @requires PHP 8.1
+     */
+    public function testEnumOptionException(): void
+    {
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('enum has invalid type');
+
+        $validator = new InArray([
+            'enum' => CustomTraversable::class,
+        ]);
+    }
 }

test/TestAsset/Enum/TestBackedIntEnum.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Validator\TestAsset\Enum;
+
+enum TestBackedIntEnum: int
+{
+    case Foo = 1;
+    case Bar = 2;
+}

test/TestAsset/Enum/TestBackedStringEnum.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Validator\TestAsset\Enum;
+
+enum TestBackedStringEnum: string
+{
+    case Foo = 'foo';
+    case Bar = 'bar';
+}

test/TestAsset/Enum/TestUnitEnum.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LaminasTest\Validator\TestAsset\Enum;
+
+enum TestUnitEnum
+{
+    case foo;
+    case bar;
+}