Handle plain array collections and improve object/array processing

magicsunday · May 21, 2021 · b04008c · b04008c
1 parent 40d8da1
commit b04008c
Show file tree

Hide file tree

Showing 5 changed files with 154 additions and 56 deletions.
diff --git a/src/JsonMapper.php b/src/JsonMapper.php
@@ -20,6 +20,7 @@
 
 use function array_key_exists;
 use function in_array;
+use function is_array;
 
 /**
  * JsonMapper
@@ -86,7 +87,7 @@ public function __construct(
         $this->extractor     = $extractor;
         $this->accessor      = $accessor;
         $this->nameConverter = $nameConverter;
-        $this->defaultType   = new Type('string');
+        $this->defaultType   = new Type(Type::BUILTIN_TYPE_STRING);
         $this->classMap      = $classMap;
     }
 
@@ -125,7 +126,7 @@ public function addCustomClassMapEntry(string $className, Closure $closure): Jso
      * @param string      $className           The class name of the initial element
      * @param null|string $collectionClassName The class name of a collection used to assign the initial elements
      *
-     * @return null|object|object[]
+     * @return null|mixed
      *
      * @throws InvalidArgumentException
      * @throws DomainException
@@ -134,15 +135,31 @@ public function map($json, string $className, string $collectionClassName = null
     {
         $this->assertClassesExists($className, $collectionClassName);
 
-        if ($collectionClassName) {
-            // Map all elements of the JSON array to this collection
-            return $this->makeInstance(
-                $collectionClassName,
-                $this->asCollection(
+        // Handle collections
+        if ($this->isArrayOrObject($json)) {
+            if ($collectionClassName) {
+                // Map array into collection class if given
+                return $this->makeInstance(
+                    $collectionClassName,
+                    $this->asCollection(
+                        $json,
+                        new Type(
+                            Type::BUILTIN_TYPE_OBJECT,
+                            false,
+                            $className
+                        )
+                    )
+                );
+            }
+
+            // Handle plain array collections
+            if ($this->isNumericIndexArray($json)) {
+                // Map all elements of the JSON array to an array
+                return $this->asCollection(
                     $json,
-                    new Type('object', false, $className, false)
-                )
-            );
+                    new Type(Type::BUILTIN_TYPE_OBJECT, false, $className)
+                );
+            }
         }
 
         $properties = $this->getProperties($className);
@@ -166,6 +183,42 @@ public function map($json, string $className, string $collectionClassName = null
         return $entity;
     }
 
+    /**
+     * Returns TRUE if the given json contains integer property keys.
+     *
+     * @param mixed $json
+     *
+     * @return bool
+     */
+    private function isNumericIndexArray($json): bool
+    {
+        foreach ($json as $propertyName => $propertyValue) {
+            if (is_int($propertyName)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Returns TRUE if the given json is an array or object.
+     *
+     * @param mixed $json
+     *
+     * @return bool
+     */
+    private function isArrayOrObject($json): bool
+    {
+        foreach ($json as $propertyValue) {
+            if (!is_array($propertyValue) && !is_object($propertyValue)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     /**
      * Assert that the given classes exists.
      *
@@ -192,9 +245,9 @@ private function assertClassesExists(string $className, string $collectionClassN
      * @param string|Closure $className                The class to instantiate
      * @param mixed          $constructorArguments,... The arguments for the constructor
      *
-     * @return object
+     * @return mixed
      */
-    private function makeInstance($className, ...$constructorArguments): object
+    private function makeInstance($className, ...$constructorArguments)
     {
         return new $className(...$constructorArguments);
     }
@@ -242,7 +295,7 @@ private function getType(string $className, string $propertyName): Type
      * @param mixed $json
      * @param Type  $type
      *
-     * @return null|array|bool|float|mixed
+     * @return null|mixed
      *
      * @throws DomainException
      */
@@ -253,7 +306,7 @@ private function getValue($json, Type $type)
             $collection     = $this->asCollection($json, $collectionType);
 
             // Create a new instance of the collection class
-            if ($type->getBuiltinType() === 'object') {
+            if ($type->getBuiltinType() === Type::BUILTIN_TYPE_OBJECT) {
                 return $this->makeInstance(
                     $this->getClassName($type),
                     $collection
@@ -270,7 +323,7 @@ private function getValue($json, Type $type)
 
         $builtinType = $type->getBuiltinType();
 
-        if ($builtinType === 'object') {
+        if ($builtinType === Type::BUILTIN_TYPE_OBJECT) {
             return $this->asObject($json, $type);
         }
 
@@ -312,12 +365,16 @@ private function getClassName(Type $type)
      * @param mixed $json
      * @param Type  $type
      *
-     * @return mixed[]
+     * @return null|array<mixed>
      *
      * @throws DomainException
      */
-    private function asCollection($json, Type $type): array
+    private function asCollection($json, Type $type): ?array
     {
+        if ($json === null) {
+            return null;
+        }
+
         $collection = [];
 
         foreach ($json as $key => $value) {
@@ -333,7 +390,7 @@ private function asCollection($json, Type $type): array
      * @param mixed $json
      * @param Type  $type
      *
-     * @return mixed
+     * @return null|mixed
      *
      * @throws DomainException
      */

diff --git a/test/JsonMapperTest.php b/test/JsonMapperTest.php
@@ -114,32 +114,28 @@ public function mapArrayOrCollection(string $jsonString): void
         self::assertSame('Item 2', $iterator->current()->name);
     }
 
-    /**
-     * @return string[][]
-     */
-    public function mapArrayOrCollectionWithStringKeysJsonDataProvider(): array
-    {
-        return [
-            'mapCollectionWithStringKeys' => [
-                DataProvider::mapCollectionWithStringKeys(),
-            ],
-        ];
-    }
-
     /**
      * Tests mapping an array or collection of objects.
      *
-     * @dataProvider mapArrayOrCollectionWithStringKeysJsonDataProvider
      * @test
-     *
-     * @param string $jsonString
      */
-    public function mapArrayOrCollectionWithStringKeys(string $jsonString): void
+    public function mapArrayOrCollectionWithStringKeys(): void
     {
         /** @var Collection<Base> $result */
         $result = $this->getJsonMapper()
             ->map(
-                $this->getJsonArray($jsonString),
+                $this->getJsonArray(
+                    <<<JSON
+{
+  "foo": {
+    "name": "Item 1"
+  },
+  "bar": {
+    "name": "Item 2"
+  }
+}
+JSON
+                ),
                 Base::class,
                 Collection::class
             );
@@ -268,7 +264,15 @@ public function mapCustomType(string $jsonString): void
             ->addType(
                 CustomConstructor::class,
                 static function ($value): ?CustomConstructor {
-                    return $value ? new CustomConstructor($value['name']) : null;
+                    if (is_array($value) && $value['name']) {
+                        return new CustomConstructor($value['name']);
+                    }
+
+                    if ($value->name) {
+                        return new CustomConstructor($value->name);
+                    }
+
+                    return null;
                 }
             )
             ->map(
@@ -356,7 +360,7 @@ public function mapObjectUsingCustomClassName(string $jsonString): void
                 Person::class,
                 // Map each entry of the collection to a separate class
                 static function ($value): string {
-                    if ($value['is_vip']) {
+                    if ((is_array($value) && $value['is_vip']) || (($value instanceof \stdClass) && $value->is_vip)) {
                         return VipPerson::class;
                     }
 
@@ -451,4 +455,57 @@ public function checkCamelCasePropertyConverter(): void
         self::assertInstanceOf(Base::class, $result);
         self::assertSame('Private property value', $result->getPrivateProperty());
     }
+
+    /**
+     * Tests mapping a JSON array with objects into a plain PHP array with objects of given class.
+     *
+     * @test
+     */
+    public function mapArrayOfObjects(): void
+    {
+        $result = $this->getJsonMapper()
+            ->map(
+                $this->getJsonArray(<<<JSON
+[
+    {
+        "name": "foo"
+    },
+    {
+        "name": "bar"
+    }
+]
+JSON
+                ),
+                Base::class
+            );
+
+        self::assertIsArray($result);
+        self::assertContainsOnlyInstancesOf(Base::class, $result);
+        self::assertSame('foo', $result[0]->name);
+        self::assertSame('bar', $result[1]->name);
+    }
+
+    /**
+     * Tests mapping a JSON object into an PHP object ignoring a given collection class as the
+     * JSON does not contain a collection.
+     *
+     * @test
+     */
+    public function mapSingleObjectWithGivenCollection(): void
+    {
+        $result = $this->getJsonMapper()
+            ->map(
+                $this->getJsonArray(<<<JSON
+{
+    "name": "foo"
+}
+JSON
+                ),
+                Base::class,
+                Collection::class
+            );
+
+        self::assertInstanceOf(Base::class, $result);
+        self::assertSame('foo', $result->name);
+    }
 }
diff --git a/test/Provider/DataProvider.php b/test/Provider/DataProvider.php
@@ -36,14 +36,6 @@ public static function mapCollectionJson(): string
         return (string) file_get_contents(__DIR__ . '/_files/MapCollection.json');
     }
 
-    /**
-     * @return string
-     */
-    public static function mapCollectionWithStringKeys(): string
-    {
-        return (string) file_get_contents(__DIR__ . '/_files/MapCollectionWithStringKeys.json');
-    }
-
     /**
      * @return string
      */

diff --git a/test/Provider/_files/MapCollectionWithStringKeys.json b/test/Provider/_files/MapCollectionWithStringKeys.json
diff --git a/test/TestCase.php b/test/TestCase.php
@@ -55,12 +55,12 @@ protected function getJsonMapper(array $classMap = []): JsonMapper
      *
      * @param string $jsonString
      *
-     * @return mixed[]
+     * @return object[]|object
      */
-    protected function getJsonArray(string $jsonString): array
+    protected function getJsonArray(string $jsonString)
     {
         try {
-            return json_decode($jsonString, true, 512, JSON_THROW_ON_ERROR);
+            return json_decode($jsonString, false, 512, JSON_THROW_ON_ERROR);
         } catch (JsonException $exception) {
             return [];
         }