Add BackedEnumSerializer to serialize enums

Author: JulianVennen

src/BackedEnumSerializer.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Aternos\Serializer;
+
+use Aternos\Serializer\Exceptions\UnsupportedInputObjectException;
+use BackedEnum;
+use UnitEnum;
+
+class BackedEnumSerializer implements SerializerInterface
+{
+    /**
+     * @param BackedEnum|UnitEnum|mixed $item
+     * @return string
+     * @noinspection PhpUnhandledExceptionInspection,PhpDocMissingThrowsInspection
+     */
+    public function serialize(object $item): string
+    {
+        if (!$item instanceof BackedEnum) {
+            throw new UnsupportedInputObjectException(get_debug_type($item),
+                "Only BackedEnum and UnitEnum are supported by EnumSerializer."
+            );
+        }
+        return $item->value;
+    }
+}

src/Exceptions/UnsupportedInputObjectException.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Aternos\Serializer\Exceptions;
+
+/**
+ * An exception that is thrown when the object used as input to a serializer is not supported by the serializer.
+ */
+class UnsupportedInputObjectException extends SerializationException
+{
+    public function __construct(
+        protected string $type,
+        string $reason = null,
+    )
+    {
+        $message = "Unsupported input object '" . $type . "'";
+        if ($reason !== null) {
+            $message .= ": " . $reason;
+        }
+        parent::__construct($message);
+    }
+
+    public function getType(): string
+    {
+        return $this->type;
+    }
+}

tests/src/ArraySerializeTests.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Aternos\Serializer\Test\Src;
+
+use Aternos\Serializer\ArraySerializer;
+use Aternos\Serializer\BackedEnumSerializer;
+use Aternos\Serializer\Serialize;
+
+class ArraySerializeTests
+{
+    /** @noinspection PhpMissingFieldTypeInspection */
+    #[Serialize(itemType: BuiltInTypeTestClass::class, itemSerializer: new ArraySerializer())]
+    public $untypedArray = [];
+
+    #[Serialize(itemSerializer: new ArraySerializer())]
+    public array $array = [];
+
+    #[Serialize(itemType: BuiltInTypeTestClass::class, itemSerializer: new ArraySerializer())]
+    public array $typedArray = [];
+
+    #[Serialize(itemSerializer: new BackedEnumSerializer())]
+    protected array $backedEnumArray = [
+        TestBackedEnum::A,
+    ];
+
+    #[Serialize]
+    protected array $stringArray = [
+        "",
+    ];
+
+    #[Serialize]
+    protected array $intArray = [
+        0,
+    ];
+}

tests/tests/BackedEnumSerializerTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Aternos\Serializer\Test\Tests;
+
+use Aternos\Serializer\BackedEnumSerializer;
+use Aternos\Serializer\Exceptions\UnsupportedInputObjectException;
+use Aternos\Serializer\Test\Src\TestBackedEnum;
+use Aternos\Serializer\Test\Src\TestClass;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\Attributes\UsesClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(BackedEnumSerializer::class)]
+#[UsesClass(UnsupportedInputObjectException::class)]
+class BackedEnumSerializerTest extends TestCase
+{
+    public function testSerialize()
+    {
+        $serializer = new BackedEnumSerializer();
+
+        $this->assertSame("a", $serializer->serialize(TestBackedEnum::A));
+        $this->assertSame("b", $serializer->serialize(TestBackedEnum::B));
+        $this->assertSame("c", $serializer->serialize(TestBackedEnum::C));
+    }
+
+    public function testSerializeInvalidInput()
+    {
+        $this->expectException(UnsupportedInputObjectException::class);
+        $this->expectExceptionMessage("Unsupported input object 'Aternos\Serializer\Test\Src\TestClass': Only BackedEnum and UnitEnum are supported by EnumSerializer.");
+        $serializer = new BackedEnumSerializer();
+        $serializer->serialize(new TestClass());
+    }
+}

tests/tests/Exceptions/UnsupportedInputObjectExceptionTest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Aternos\Serializer\Test\Tests\Exceptions;
+
+use Aternos\Serializer\Exceptions\UnsupportedInputObjectException;
+use PHPUnit\Framework\Attributes\CoversClass;
+use PHPUnit\Framework\TestCase;
+
+#[CoversClass(UnsupportedInputObjectException::class)]
+class UnsupportedInputObjectExceptionTest extends TestCase
+{
+    public function testConstruct(): void
+    {
+        $exception = new UnsupportedInputObjectException("TestClass");
+        $this->assertSame("Unsupported input object 'TestClass'", $exception->getMessage());
+    }
+
+    public function testConstructWithReason(): void
+    {
+        $exception = new UnsupportedInputObjectException("TestClass", "test reason");
+        $this->assertSame("Unsupported input object 'TestClass': test reason", $exception->getMessage());
+    }
+
+    public function testGetType(): void
+    {
+        $exception = new UnsupportedInputObjectException("TestClass");
+        $this->assertSame("TestClass", $exception->getType());
+    }
+}

tests/tests/SerializerTest.php

@@ -3,18 +3,19 @@
 namespace Aternos\Serializer\Test\Tests;
 
 use Aternos\Serializer\ArraySerializer;
+use Aternos\Serializer\BackedEnumSerializer;
 use Aternos\Serializer\Exceptions\IncorrectTypeException;
 use Aternos\Serializer\Exceptions\MissingPropertyException;
 use Aternos\Serializer\Json\PropertyJsonSerializer;
 use Aternos\Serializer\Serialize;
+use Aternos\Serializer\Test\Src\ArraySerializeTests;
 use Aternos\Serializer\Test\Src\BackedEnumTestClass;
 use Aternos\Serializer\Test\Src\BuiltInTypeTestClass;
 use Aternos\Serializer\Test\Src\CustomSerializerTestClass;
 use Aternos\Serializer\Test\Src\DefaultValueTestClass;
 use Aternos\Serializer\Test\Src\EnumTestClass;
 use Aternos\Serializer\Test\Src\SecondTestClass;
 use Aternos\Serializer\Test\Src\SerializerTestClass;
-use Aternos\Serializer\Test\Src\TestBackedEnum;
 use Aternos\Serializer\Test\Src\TestClass;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\UsesClass;
@@ -25,6 +26,7 @@
 #[UsesClass(Serialize::class)]
 #[UsesClass(IncorrectTypeException::class)]
 #[UsesClass(MissingPropertyException::class)]
+#[UsesClass(BackedEnumSerializer::class)]
 class SerializerTest extends TestCase
 {
     public function testSerialize(): void
@@ -156,4 +158,50 @@ public function testSerializeUnbackedEnum(): void
         $this->expectExceptionMessage("Expected 'enum' to be 'BackedEnum' found: \Aternos\Serializer\Test\Src\TestEnum::A");
         $serializer->serialize(new EnumTestClass());
     }
+
+    public function testSerializeArrayItems(): void
+    {
+        $serializer = new ArraySerializer();
+        $testClass = new ArraySerializeTests();
+
+        $testClass->untypedArray = [new BuiltInTypeTestClass()];
+        $testClass->typedArray = [new BuiltInTypeTestClass()];
+        $testClass->array = [new BuiltInTypeTestClass()];
+
+        $this->assertEquals([
+            "untypedArray" => [[
+                "int" => null,
+                "float" => null,
+                "string" => null,
+                "array" => null,
+                "object" => null,
+                "self" => null,
+                "false" => null,
+                "true" => null,
+            ]],
+            "array" => [[
+                "int" => null,
+                "float" => null,
+                "string" => null,
+                "array" => null,
+                "object" => null,
+                "self" => null,
+                "false" => null,
+                "true" => null,
+            ]],
+            "typedArray" => [[
+                "int" => null,
+                "float" => null,
+                "string" => null,
+                "array" => null,
+                "object" => null,
+                "self" => null,
+                "false" => null,
+                "true" => null,
+            ]],
+            "backedEnumArray" => ["a"],
+            "stringArray" => [""],
+            "intArray" => [0],
+        ], $serializer->serialize($testClass));
+    }
 }