[5.8] Container - lazy load tagged services

Author: X-Coder264

src/Illuminate/Container/Container.php

@@ -454,19 +454,19 @@ public function tag($abstracts, $tags)
      * Resolve all of the bindings for a given tag.
      *
      * @param  string  $tag
-     * @return array
+     * @return iterable
      */
     public function tagged($tag)
     {
-        $results = [];
+        if (! isset($this->tags[$tag])) {
+            return [];
+        }
 
-        if (isset($this->tags[$tag])) {
+        return new RewindableGenerator(function () use ($tag) {
             foreach ($this->tags[$tag] as $abstract) {
-                $results[] = $this->make($abstract);
+                yield $this->make($abstract);
             }
-        }
-
-        return $results;
+        }, count($this->tags[$tag]));
     }
 
     /**

src/Illuminate/Container/RewindableGenerator.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Illuminate\Container;
+
+use Countable;
+use IteratorAggregate;
+
+class RewindableGenerator implements Countable, IteratorAggregate
+{
+    /**
+     * @var callable
+     */
+    private $generator;
+
+    /**
+     * @var callable|int
+     */
+    private $count;
+
+    /**
+     * @param callable     $generator
+     * @param callable|int $count
+     */
+    public function __construct(callable $generator, $count)
+    {
+        $this->generator = $generator;
+        $this->count = $count;
+    }
+
+    public function getIterator()
+    {
+        $generator = $this->generator;
+
+        return $generator();
+    }
+
+    /**
+     * @return int
+     */
+    public function count()
+    {
+        if (is_callable($count = $this->count)) {
+            $this->count = $count();
+        }
+
+        return $this->count;
+    }
+}

src/Illuminate/Contracts/Container/Container.php

@@ -38,7 +38,7 @@ public function tag($abstracts, $tags);
      * Resolve all of the bindings for a given tag.
      *
      * @param  string  $tag
-     * @return array
+     * @return iterable
      */
     public function tagged($tag);
 

tests/Container/ContainerTest.php

@@ -792,17 +792,77 @@ public function testContainerTags()
 
         $this->assertCount(1, $container->tagged('bar'));
         $this->assertCount(2, $container->tagged('foo'));
-        $this->assertInstanceOf(ContainerImplementationStub::class, $container->tagged('foo')[0]);
-        $this->assertInstanceOf(ContainerImplementationStub::class, $container->tagged('bar')[0]);
-        $this->assertInstanceOf(ContainerImplementationStubTwo::class, $container->tagged('foo')[1]);
+
+        $fooResults = [];
+        foreach ($container->tagged('foo') as $foo) {
+            $fooResults[] = $foo;
+        }
+
+        $barResults = [];
+        foreach ($container->tagged('bar') as $bar) {
+            $barResults[] = $bar;
+        }
+
+        $this->assertInstanceOf(ContainerImplementationStub::class, $fooResults[0]);
+        $this->assertInstanceOf(ContainerImplementationStub::class, $barResults[0]);
+        $this->assertInstanceOf(ContainerImplementationStubTwo::class, $fooResults[1]);
 
         $container = new Container;
         $container->tag([ContainerImplementationStub::class, ContainerImplementationStubTwo::class], ['foo']);
         $this->assertCount(2, $container->tagged('foo'));
-        $this->assertInstanceOf(ContainerImplementationStub::class, $container->tagged('foo')[0]);
-        $this->assertInstanceOf(ContainerImplementationStubTwo::class, $container->tagged('foo')[1]);
 
-        $this->assertEmpty($container->tagged('this_tag_does_not_exist'));
+        $fooResults = [];
+        foreach ($container->tagged('foo') as $foo) {
+            $fooResults[] = $foo;
+        }
+
+        $this->assertInstanceOf(ContainerImplementationStub::class, $fooResults[0]);
+        $this->assertInstanceOf(ContainerImplementationStubTwo::class, $fooResults[1]);
+
+        $this->assertCount(0, $container->tagged('this_tag_does_not_exist'));
+    }
+
+    public function testTaggedServicesAreLazyLoaded()
+    {
+        $container = $this->createPartialMock(Container::class, ['make']);
+        $container->expects($this->once())->method('make')->willReturn(new ContainerImplementationStub());
+
+        $container->tag(ContainerImplementationStub::class, ['foo']);
+        $container->tag(ContainerImplementationStubTwo::class, ['foo']);
+
+        $fooResults = [];
+        foreach ($container->tagged('foo') as $foo) {
+            $fooResults[] = $foo;
+            break;
+        }
+
+        $this->assertCount(2, $container->tagged('foo'));
+        $this->assertInstanceOf(ContainerImplementationStub::class, $fooResults[0]);
+    }
+
+    public function testLazyLoadedTaggedServicesCanBeLoopedOverMultipleTimes()
+    {
+        $container = new Container;
+        $container->tag(ContainerImplementationStub::class, 'foo');
+        $container->tag(ContainerImplementationStubTwo::class, ['foo']);
+
+        $services = $container->tagged('foo');
+
+        $fooResults = [];
+        foreach ($services as $foo) {
+            $fooResults[] = $foo;
+        }
+
+        $this->assertInstanceOf(ContainerImplementationStub::class, $fooResults[0]);
+        $this->assertInstanceOf(ContainerImplementationStubTwo::class, $fooResults[1]);
+
+        $fooResults = [];
+        foreach ($services as $foo) {
+            $fooResults[] = $foo;
+        }
+
+        $this->assertInstanceOf(ContainerImplementationStub::class, $fooResults[0]);
+        $this->assertInstanceOf(ContainerImplementationStubTwo::class, $fooResults[1]);
     }
 
     public function testForgetInstanceForgetsInstance()

tests/Container/RewindableGeneratorTest.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Illuminate\Tests\Container;
+
+use PHPUnit\Framework\TestCase;
+use Illuminate\Container\RewindableGenerator;
+
+class RewindableGeneratorTest extends TestCase
+{
+    public function testCountUsesProvidedValue()
+    {
+        $generator = new RewindableGenerator(function () {
+            yield 'foo';
+        }, 999);
+
+        $this->assertSame(999, count($generator));
+    }
+
+    public function testCountUsesProvidedValueAsCallback()
+    {
+        $called = 0;
+
+        $generator = new RewindableGenerator(function () {
+            yield 'foo';
+        }, function () use (&$called) {
+            $called++;
+
+            return 500;
+        });
+
+        // the count callback is called lazily
+        $this->assertSame(0, $called);
+
+        $this->assertCount(500, $generator);
+
+        count($generator);
+
+        // the count callback is called only once
+        $this->assertSame(1, $called);
+    }
+}