Merge pull request #5 from andreypostal/enums-support

Enums support
andreypostal · Aug 20, 2024 · 8e52941 · 8e52941
2 parents 042e672 + 574455c
commit 8e52941
Show file tree

Hide file tree

Showing 8 changed files with 225 additions and 16 deletions.
diff --git a/src/JsonHydratorTrait.php b/src/JsonHydratorTrait.php
@@ -7,12 +7,14 @@
 use JsonException;
 use LogicException;
 use ReflectionClass;
+use ReflectionException;
 use ReflectionProperty;
 
 trait JsonHydratorTrait
 {
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function hydrateObjectImmutable(string|array $json, object $obj): object
     {
@@ -21,6 +23,7 @@ public function hydrateObjectImmutable(string|array $json, object $obj): object
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function hydrateObject(string|array $json, object $obj): object
     {
@@ -39,6 +42,7 @@ public function hydrateObject(string|array $json, object $obj): object
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     private function processClass(ReflectionClass $class, array $jsonArr): array
     {
@@ -53,6 +57,7 @@ private function processClass(ReflectionClass $class, array $jsonArr): array
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     private function processProperty(ReflectionProperty $property, array $jsonArr, bool $skipAttributeCheck): mixed
     {
@@ -70,26 +75,48 @@ private function processProperty(ReflectionProperty $property, array $jsonArr, b
         }
 
         if ($property->getType()?->isBuiltin()) {
-            if ($item->type !== null && $property->getType()?->getName() === 'array') {
-                $output = [];
-                $classExists = class_exists($item->type);
-                foreach ($jsonArr[$key] ?? [] as $k => $v) {
-                    $value = $v;
-                    if ($classExists) {
-                        $value = $this->hydrateObject($v, new $item->type);
-                    } elseif (gettype($v) !== $item->type) {
-                        throw new LogicException(sprintf('expected array with items of type <%s> but found <%s>', $item->type, gettype($v)));
-                    }
-                    $output[$k] = $value;
+            return $this->handleBuiltin($jsonArr, $key, $property, $item);
+        }
+
+        return $this->handleCustomType($jsonArr[$key], $property->getType()?->getName());
+    }
+
+    /**
+     * @throws JsonException
+     * @throws ReflectionException
+     */
+    private function handleBuiltin(array $jsonArr, string $key, ReflectionProperty $property, JsonItemAttribute $item): mixed
+    {
+        if ($item->type !== null && $property->getType()?->getName() === 'array') {
+            $output = [];
+            $classExists = class_exists($item->type);
+            foreach ($jsonArr[$key] ?? [] as $k => $v) {
+                $value = $v;
+                if ($classExists) {
+                    $value = $this->handleCustomType($value, $item->type);
+                } elseif (gettype($v) !== $item->type) {
+                    throw new LogicException(sprintf('expected array with items of type <%s> but found <%s>', $item->type, gettype($v)));
                 }
-                return $output;
+                $output[$k] = $value;
             }
-            return $jsonArr[$key] ?? $property->getDefaultValue();
+            return $output;
         }
+        return $jsonArr[$key] ?? ($property->hasDefaultValue() ? $property->getDefaultValue() : null);
+    }
 
+    /**
+     * @throws ReflectionException
+     * @throws JsonException
+     */
+    private function handleCustomType(mixed $value, string $type): mixed
+    {
+        $typeReflection = new ReflectionClass($type);
+        if ($typeReflection->isEnum()) {
+            return call_user_func($type.'::tryFrom', $value);
+        }
         return $this->hydrateObject(
-            $jsonArr[$key],
-            new ($property->getType()?->getName())(),
+            $value,
+            new ($type)(),
         );
     }
 }
diff --git a/src/JsonSerializerTrait.php b/src/JsonSerializerTrait.php
@@ -3,13 +3,23 @@
 
 use Andrey\JsonHandler\Attributes\JsonItemAttribute;
 use Andrey\JsonHandler\Attributes\JsonObjectAttribute;
+use JsonException;
 use ReflectionClass;
+use ReflectionException;
 
 trait JsonSerializerTrait
 {
+    /**
+     * @throws ReflectionException
+     * @throws JsonException
+     */
     public function serialize(object $obj): array
     {
         $class = new ReflectionClass($obj);
+        if ($class->isEnum()) {
+            return $obj->value;
+        }
+
         $skipAttributeCheck = ($class->getAttributes(JsonObjectAttribute::class)[0] ?? null) !== null;
         $output = [];
         $properties = $class->getProperties();
@@ -24,11 +34,53 @@ public function serialize(object $obj): array
             $key = $item->key ?? $property->name;
 
             if ($property->getType()?->isBuiltin()) {
-                $output[$key] = $property->getValue($obj);
+                $output[$key] = $this->handleArray($item, $property->getValue($obj));
+                continue;
+            }
+
+            $class = new ReflectionClass($property->getValue($obj));
+            if ($class->isEnum()) {
+                $output[$key] = $property->getValue($obj)->value;
                 continue;
             }
             $output[$key] = $this->serialize($property->getValue($obj));
         }
         return $output;
     }
+
+    /**
+     * @param JsonItemAttribute $item
+     * @param mixed $value
+     * @return mixed
+     * @throws ReflectionException
+     * @throws JsonException
+     *
+     * @noinspection GetTypeMissUseInspection
+     */
+    private function handleArray(JsonItemAttribute $item, mixed $value): mixed
+    {
+        if (gettype($value) !== 'array') {
+            return $value;
+        }
+
+        if (!class_exists($item->type)) {
+            return $value;
+        }
+        $class = new ReflectionClass($item->type);
+        $isEnum = $class->isEnum();
+
+        return array_reduce(
+            array: $value,
+            callback: function(array $l, mixed $c) use ($isEnum): array {
+                if ($isEnum) {
+                    $v = $c->value;
+                } else {
+                    $v = $this->serialize($c);
+                }
+                $l[] = $v;
+                return $l;
+            },
+            initial: [],
+        );
+    }
 }
diff --git a/tests/HydratorTest.php b/tests/HydratorTest.php
@@ -17,6 +17,7 @@ final class HydratorTest extends TestCase
 {
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testSimpleHydrate(): void
     {
@@ -34,6 +35,7 @@ public function testSimpleHydrate(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testImmutableHydrate(): void
     {
@@ -58,6 +60,7 @@ public function testImmutableHydrate(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testHydrateWithoutOptionalItems(): void
     {
@@ -76,6 +79,7 @@ public function testHydrateWithoutOptionalItems(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testHydrateWithoutRequiredItem(): void
     {
@@ -90,6 +94,7 @@ public function testHydrateWithoutRequiredItem(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testHydrateWithMultipleLevels(): void
     {
@@ -106,6 +111,7 @@ public function testHydrateWithMultipleLevels(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testHydrateWithArray(): void
     {
@@ -123,6 +129,7 @@ public function testHydrateWithArray(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testHydrateWithInvalidArray(): void
     {
@@ -138,6 +145,7 @@ public function testHydrateWithInvalidArray(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testHydrateWithArrayOfObjects(): void
     {
@@ -155,6 +163,7 @@ public function testHydrateWithArrayOfObjects(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testHydrateWithObjectAttr(): void
     {
@@ -172,6 +181,7 @@ public function testHydrateWithObjectAttr(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testMixedObjectAndItemAttributes(): void
     {
@@ -186,4 +196,42 @@ public function testMixedObjectAndItemAttributes(): void
         $this->assertEquals(1.5, $obj->float);
         $this->assertFalse($obj->bool);
     }
+
+    /**
+     * @throws JsonException
+     * @throws ReflectionException
+     */
+    public function testSimpleEnum(): void
+    {
+        $json = '{"id": "str", "enum": "aaa"}';
+        $obj = new WithEnumObject();
+
+        $handler = new JsonHandler();
+        $handler->hydrateObject($json, $obj);
+
+        $this->assertIsObject($obj->enum);
+        $this->assertEquals('aaa', $obj->enum->value);
+        $this->assertEquals('Aaa', $obj->enum->name);
+    }
+
+    /**
+     * @throws JsonException
+     * @throws ReflectionException
+     */
+    public function testArrayOfEnum(): void
+    {
+        $json = '{"id": "str", "enum": [ "aaa", "bbb", "abc" ]}';
+        $obj = new WithArrayOfEnumObject();
+
+        $handler = new JsonHandler();
+        $handler->hydrateObject($json, $obj);
+
+        $this->assertCount(3, $obj->enum);
+        $this->assertEquals('aaa', $obj->enum[0]->value);
+        $this->assertEquals('Aaa', $obj->enum[0]->name);
+        $this->assertEquals('bbb', $obj->enum[1]->value);
+        $this->assertEquals('Bbb', $obj->enum[1]->name);
+        $this->assertEquals('abc', $obj->enum[2]->value);
+        $this->assertEquals('Abc', $obj->enum[2]->name);
+    }
 }
diff --git a/tests/SerializerTest.php b/tests/SerializerTest.php
@@ -25,6 +25,7 @@ public function testSimpleSerialize(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testSerializeWithKeyModified(): void
     {
@@ -53,6 +54,7 @@ public function testSerializeWithKeyModified(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testSerializeMultiLevel(): void
     {
@@ -75,6 +77,7 @@ public function testSerializeMultiLevel(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testSerializeWithExtraItems(): void
     {
@@ -95,6 +98,47 @@ public function testSerializeWithExtraItems(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
+     */
+    public function testSimpleEnum(): void
+    {
+        $obj = new WithEnumObject();
+
+        $handler = new JsonHandler();
+        $arr = $handler->serialize($obj);
+
+        $this->assertArrayHasKey('id', $arr);
+        $this->assertArrayHasKey('enum', $arr);
+        $this->assertIsString($arr['enum']);
+        $this->assertEquals('abc', $arr['enum']);
+
+        JsonHandler::Encode($arr);
+    }
+
+    /**
+     * @throws JsonException
+     * @throws ReflectionException
+     */
+    public function testArrayEnum(): void
+    {
+        $obj = new WithArrayOfEnumObject();
+
+        $handler = new JsonHandler();
+        $arr = $handler->serialize($obj);
+
+        $this->assertArrayHasKey('id', $arr);
+        $this->assertArrayHasKey('enum', $arr);
+        $this->assertIsArray($arr['enum']);
+        $this->assertCount(2, $arr['enum']);
+        $this->assertEquals('abc', $arr['enum'][0]);
+        $this->assertEquals('aaa', $arr['enum'][1]);
+
+        JsonHandler::Encode($arr);
+    }
+
+    /**
+     * @throws JsonException
+     * @throws ReflectionException
      */
     public function testSerializeWithObjectAttr(): void
     {
@@ -103,6 +147,7 @@ public function testSerializeWithObjectAttr(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     public function testSerializeWithMixedAttrs(): void
     {
@@ -111,6 +156,7 @@ public function testSerializeWithMixedAttrs(): void
 
     /**
      * @throws JsonException
+     * @throws ReflectionException
      */
     private function assertSimpleSerializedObject(object $obj): void
     {

diff --git a/tests/bootstrap.php b/tests/bootstrap.php
@@ -7,3 +7,6 @@
 require_once __DIR__ . '/utils/WithArrayOfChildObject.php';
 require_once __DIR__ . '/utils/SimpleTestWithObjectAttr.php';
 require_once __DIR__ . '/utils/MixedAttributesObject.php';
+require_once __DIR__ . '/utils/EnumObject.php';
+require_once __DIR__ . '/utils/WithArrayOfEnumObject.php';
+require_once __DIR__ . '/utils/WithEnumObject.php';