Support for iterable type

README.md

@@ -130,6 +130,13 @@ class PostData extends DataTransferObject
      */
     public $property;
 
+    /**
+     * Iterator of types: 
+     *
+     * @var iterator<\App\Models\Author>
+     */
+    public $property;
+
     /**
      * Union types: 
      *
@@ -151,6 +158,13 @@ class PostData extends DataTransferObject
      */
     public $property;
 
+    /**
+     * Any iterator : 
+     *
+     * @var iterator
+     */
+    public $property;
+
     /**
      * No type, which allows everything
      */

src/Property.php

@@ -87,7 +87,7 @@ protected function resolveTypeDefinition()
             return;
         }
 
-        preg_match('/\@var ((?:(?:[\w|\\\\])+(?:\[\])?)+)/', $docComment, $matches);
+        preg_match('/\@var ((?:(?:[\w|\\\\<>])+(?:\[\])?)+)/', $docComment, $matches);
 
         if (! count($matches)) {
             $this->isNullable = true;
@@ -102,6 +102,10 @@ protected function resolveTypeDefinition()
         $this->types = explode('|', $varDocComment);
         $this->arrayTypes = str_replace('[]', '', $this->types);
 
+        if (preg_match_all('/iterable<([^|]*)>/', $varDocComment, $matches)) {
+            $this->arrayTypes = array_merge($this->arrayTypes, $matches[1]);
+        }
+
         $this->isNullable = strpos($varDocComment, 'null') !== false;
     }
 
@@ -196,7 +200,11 @@ protected function shouldBeCastToCollection(array $values): bool
     protected function assertTypeEquals(string $type, $value): bool
     {
         if (strpos($type, '[]') !== false) {
-            return $this->isValidGenericCollection($type, $value);
+            return $this->isValidArray($type, $value);
+        }
+
+        if ($type === 'iterable' || strpos($type, 'iterable<') === 0) {
+            return $this->isValidIterable($type, $value);
         }
 
         if ($type === 'mixed' && $value !== null) {
@@ -207,16 +215,34 @@ protected function assertTypeEquals(string $type, $value): bool
             || gettype($value) === (self::$typeMapping[$type] ?? $type);
     }
 
-    protected function isValidGenericCollection(string $type, $collection): bool
+    protected function isValidArray(string $type, $collection): bool
     {
         if (! is_array($collection)) {
             return false;
         }
 
         $valueType = str_replace('[]', '', $type);
 
+        return $this->isValidGenericCollection($valueType, $collection);
+    }
+
+    protected function isValidIterable(string $type, $collection): bool
+    {
+        if (! is_iterable($collection)) {
+            return false;
+        }
+
+        if (preg_match('/^iterable<(.*)>$/', $type, $matches)) {
+            return $this->isValidGenericCollection($matches[1], $collection);
+        }
+
+        return true;
+    }
+
+    protected function isValidGenericCollection(string $type, $collection): bool
+    {
         foreach ($collection as $value) {
-            if (! $this->assertTypeEquals($valueType, $value)) {
+            if (! $this->assertTypeEquals($type, $value)) {
                 return false;
             }
         }

tests/DataTransferObjectTest.php

@@ -4,14 +4,15 @@
 
 namespace Spatie\DataTransferObject\Tests;
 
+use ArrayIterator;
 use Spatie\DataTransferObject\DataTransferObject;
 use Spatie\DataTransferObject\DataTransferObjectError;
 use Spatie\DataTransferObject\Tests\TestClasses\DummyClass;
 use Spatie\DataTransferObject\Tests\TestClasses\EmptyChild;
-use Spatie\DataTransferObject\Tests\TestClasses\OtherClass;
 use Spatie\DataTransferObject\Tests\TestClasses\NestedChild;
 use Spatie\DataTransferObject\Tests\TestClasses\NestedParent;
 use Spatie\DataTransferObject\Tests\TestClasses\NestedParentOfMany;
+use Spatie\DataTransferObject\Tests\TestClasses\OtherClass;
 
 class DataTransferObjectTest extends TestCase
 {
@@ -383,4 +384,63 @@ public function empty_constructor_is_supported()
 
         $this->assertEquals(['foo' => 'abc', 'bar' => null], $valueObject->all());
     }
+
+    /** @test */
+    public function iterable_is_supported()
+    {
+        new class(['strings' => ['foo', 'bar']]) extends DataTransferObject {
+            /** @var iterable<string> */
+            public $strings;
+        };
+
+        new class(['strings' => new ArrayIterator(['foo', 'bar'])]) extends DataTransferObject {
+            /** @var iterable<string> */
+            public $strings;
+        };
+
+        new class(['mixeds' => ['foo', 1]]) extends DataTransferObject {
+            /** @var iterable */
+            public $mixeds;
+        };
+
+        new class(['mixeds' => new ArrayIterator(['foo', 1])]) extends DataTransferObject {
+            /** @var iterable */
+            public $mixeds;
+        };
+
+        $this->markTestSucceeded();
+    }
+
+    /** @test */
+    public function an_exception_is_thrown_for_incoherent_iterator_type()
+    {
+        $this->expectException(DataTransferObjectError::class);
+
+        new class(['strings' => ['foo', 1]]) extends DataTransferObject {
+            /** @var iterable<string> */
+            public $strings;
+        };
+    }
+
+    /** @test */
+    public function nested_dtos_are_automatically_cast_from_arrays_to_objects_with_iterable_syntax()
+    {
+        $data = [
+            'children' => [
+                ['name' => 'Alice'],
+                ['name' => 'Bob'],
+            ],
+        ];
+
+        $object = new class($data) extends DataTransferObject {
+            /** @var iterable<\Spatie\DataTransferObject\Tests\TestClasses\NestedChild>|iterable<string> */
+            public $children;
+        };
+
+        $this->assertTrue(is_array($object->children));
+        $this->assertCount(2, $object->children);
+        $this->assertContainsOnly(NestedChild::class, $object->children);
+        $this->assertEquals('Alice', $object->children[0]->name);
+        $this->assertEquals('Bob', $object->children[1]->name);
+    }
 }