int backed enums

Author: wol-soft

docs/source/nonStandardExtensions/filter.rst

@@ -91,7 +91,7 @@ Filters may change the type of the property. For example the builtin filter **da
 
 As the required check is executed before the filter a filter may transform a required value into a null value. Be aware when writing custom filters which transform values to not break your validation rules by adding filters to a property.
 
-Only one transforming filter per property is allowed. may be positioned anywhere in the filter chain of a single property. If multiple filters are applied and a transforming filter is among them you have to make sure the property types are compatible. If you use a custom filter after the dateTime filter for example the custom filter has to accept a DateTime value. Filters used before a transforming filter must accept the base type of the property the filter is applied to defined in the schema. If the transformation of a property fails (the transforming filter throws an exception), subsequent filters won't be executed as their execution would add another error due to incompatible types which is irrelevant for the currently provided value.
+Only one transforming filter per property is allowed. The filter may be positioned anywhere in the filter chain of a single property. If multiple filters are applied and a transforming filter is among them you have to make sure the property types are compatible. If you use a custom filter after the dateTime filter for example the custom filter has to accept a DateTime value. Filters used before a transforming filter must accept the base type of the property the filter is applied to defined in the schema. If the transformation of a property fails (the transforming filter throws an exception), subsequent filters won't be executed as their execution would add another error due to incompatible types which is irrelevant for the currently provided value.
 
 If you write a custom transforming filter you must define the return type of your filter function as the implementation uses Reflection methods to determine to which type a value is transformed by a filter.
 

src/SchemaProcessor/PostProcessor/EnumFilter.php

@@ -11,7 +11,7 @@ class EnumFilter implements TransformingFilterInterface
 {
     public function getAcceptedTypes(): array
     {
-        return ['string', 'null'];
+        return ['string', 'integer', 'null'];
     }
 
     public function getToken(): string

src/SchemaProcessor/PostProcessor/EnumPostProcessor.php

@@ -210,7 +210,7 @@ private function renderEnum(
                     'cases' => $cases,
                     'backedType' => match ($this->getArrayTypes($values)) {
                         ['string'] => 'string',
-                        ['int'] => 'int',
+                        ['integer'] => 'int',
                         default => null,
                     },
                 ]

src/SchemaProcessor/PostProcessor/Templates/Enum.phptpl

@@ -22,7 +22,7 @@ enum {{ name }}{% if backedType %}: {{ backedType }}{% endif %} {
             }
         }
 
-        public function to(): mixed
+        public function value(): mixed
         {
             switch ($this) {
                 {% foreach cases as case, value %}

tests/PostProcessor/EnumPostProcessorTest.php

@@ -5,26 +5,31 @@
 namespace PHPModelGenerator\Tests\PostProcessor;
 
 use BackedEnum;
+use Exception;
 use PHPModelGenerator\Exception\Generic\EnumException;
 use PHPModelGenerator\Exception\SchemaException;
 use PHPModelGenerator\Model\GeneratorConfiguration;
 use PHPModelGenerator\ModelGenerator;
 use PHPModelGenerator\SchemaProcessor\PostProcessor\EnumPostProcessor;
 use PHPModelGenerator\Tests\AbstractPHPModelGeneratorTest;
-use ReflectionClass;
 use ReflectionEnum;
 
 class EnumPostProcessorTest extends AbstractPHPModelGeneratorTest
 {
-    public function setUp(): void
+    /**
+     * @requires PHP < 8.1
+     */
+    public function testEnumPostProcessorThrowsAnExceptionPriorToPhp81(): void
     {
-        if (PHP_VERSION_ID < 80100) {
-            $this->markTestSkipped('Enumerations are only allowed since PHP 8.1');
-        }
+        $this->expectException(Exception::class);
+        $this->expectExceptionMessage('Enumerations are only allowed since PHP 8.1');
 
-        parent::setUp();
+        new EnumPostProcessor('', '');
     }
 
+    /**
+     * @requires PHP >= 8.1
+     */
     public function testStringOnlyEnum(): void
     {
         $this->addPostProcessor();
@@ -50,6 +55,8 @@ public function testStringOnlyEnum(): void
         $returnType = $this->getReturnType($object, 'getProperty');
         $this->assertTrue($returnType->allowsNull());
         $enum = $returnType->getName();
+        $this->assertTrue(enum_exists($enum));
+
         $reflectionEnum = new ReflectionEnum($enum);
         $enumName = $reflectionEnum->getShortName();
 
@@ -83,6 +90,9 @@ public function testStringOnlyEnum(): void
         $object->setProperty('Meier');
     }
 
+    /**
+     * @requires PHP >= 8.1
+     */
     public function testInvalidStringOnlyEnumValue(): void
     {
         $this->addPostProcessor();
@@ -95,6 +105,9 @@ public function testInvalidStringOnlyEnumValue(): void
         new $className(['property' => 'Meier']);
     }
 
+    /**
+     * @requires PHP >= 8.1
+     */
     public function testMappedStringOnlyEnum(): void
     {
         $this->addPostProcessor();
@@ -141,6 +154,7 @@ public function testMappedStringOnlyEnum(): void
 
     /**
      * @dataProvider unmappedEnumThrowsAnExceptionDataProvider
+     * @requires PHP >= 8.1
      */
     public function testUnmappedEnumThrowsAnException(string $enumValues): void
     {
@@ -163,6 +177,7 @@ public function unmappedEnumThrowsAnExceptionDataProvider(): array
 
     /**
      * @dataProvider invalidEnumMapThrowsAnExceptionDataProvider
+     * @requires PHP >= 8.1
      */
     public function testInvalidEnumMapThrowsAnException(string $enumValues, string $enumMap): void
     {
@@ -188,6 +203,72 @@ public function invalidEnumMapThrowsAnExceptionDataProvider(): array
         ];
     }
 
+    /**
+     * @requires PHP >= 8.1
+     */
+    public function testIntOnlyEnum(): void
+    {
+        $this->addPostProcessor();
+
+        $className = $this->generateClassFromFileTemplate(
+            'EnumPropertyMapped.json',
+            ['[10, 100]', '{"a": 10, "b": 100}'],
+            (new GeneratorConfiguration())->setImmutable(false)->setCollectErrors(false),
+            false
+        );
+
+        $this->includeGeneratedEnums(1);
+
+        $object = new $className(['property' => 10]);
+        $this->assertSame(10, $object->getProperty()->value);
+
+        $object->setProperty(100);
+        $this->assertSame(100, $object->getProperty()->value);
+
+        $object->setProperty(null);
+        $this->assertNull($object->getProperty());
+
+        $returnType = $this->getReturnType($object, 'getProperty');
+        $this->assertTrue($returnType->allowsNull());
+        $enum = $returnType->getName();
+
+        $this->assertTrue(enum_exists($enum));
+        $reflectionEnum = new ReflectionEnum($enum);
+        $enumName = $reflectionEnum->getShortName();
+
+        $this->assertEqualsCanonicalizing(
+            [$enumName, 'null'],
+            explode('|', $this->getReturnTypeAnnotation($object, 'getProperty'))
+        );
+
+        $this->assertSame('int', $reflectionEnum->getBackingType()->getName());
+
+        $this->assertEqualsCanonicalizing(
+            ['A', 'B'],
+            array_map(function (BackedEnum $value): string { return $value->name; }, $enum::cases())
+        );
+        $this->assertEqualsCanonicalizing(
+            [10, 100],
+            array_map(function (BackedEnum $value): int { return $value->value; }, $enum::cases())
+        );
+
+        $object->setProperty($enum::A);
+        $this->assertSame(10, $object->getProperty()->value);
+
+        $this->assertNull($this->getParameterType($object, 'setProperty'));
+        $this->assertEqualsCanonicalizing(
+            [$enumName, 'int', 'null'],
+            explode('|', $this->getParameterTypeAnnotation($object, 'setProperty'))
+        );
+
+        $this->expectException(EnumException::class);
+        $this->expectExceptionMessage('Invalid value for property declined by enum constraint');
+        $object->setProperty(1);
+    }
+
+    /**
+     * @requires PHP >= 8.1
+     */
     public function testEnumPropertyWithTransformingFilterThrowsAnException(): void
     {
         $this->expectException(SchemaException::class);