First implementation of lazy services via proxy manager

symfony · Ocramius · Mar 29, 2013 · Mar 30, 2013 · Mar 30, 2013 · Mar 30, 2013
commit f503ad8026457d91a503c86f6113589be1183db4
diff --git a/composer.json b/composer.json
@@ -61,6 +61,7 @@
         "symfony/yaml": "self.version"
     },
     "require-dev": {
+        "ocramius/proxy-manager": "0.2.*",
         "doctrine/data-fixtures": "1.0.*",
         "doctrine/dbal": "~2.2",
         "doctrine/orm": "~2.2,>=2.2.3",

diff --git a/src/Symfony/Component/DependencyInjection/ContainerBuilder.php b/src/Symfony/Component/DependencyInjection/ContainerBuilder.php
@@ -11,6 +11,9 @@
 
 namespace Symfony\Component\DependencyInjection;
 
+use ProxyManager\Configuration;
+use ProxyManager\Factory\LazyLoadingValueHolderFactory;
+use ProxyManager\Proxy\LazyLoadingInterface;
 use Symfony\Component\DependencyInjection\Compiler\Compiler;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\Compiler\PassConfig;
@@ -873,8 +876,22 @@ public function findDefinition($id)
      * @throws RuntimeException When the service is a synthetic service
      * @throws InvalidArgumentException When configure callable is not callable
      */
-    private function createService(Definition $definition, $id)
+    public function createService(Definition $definition, $id, $tryProxy = true)
     {
+        if ($tryProxy && ($className = $definition->getClass()) && $definition->isLazy()) {
+            $factory   = new LazyLoadingValueHolderFactory(new Configuration());
+            $container = $this;
+
+            return $factory->createProxy(
+                $className,
+                function (& $wrappedInstance, LazyLoadingInterface $proxy) use ($container, $definition, $id) {
+                    $proxy->setProxyInitializer(null);
+
+                    $wrappedInstance = $container->createService($definition, $id, false);
+                }
+            );
+        }
+
         if ($definition->isSynthetic()) {
             throw new RuntimeException(sprintf('You have requested a synthetic service ("%s"). The DIC does not know how to construct this service.', $id));
         }

diff --git a/src/Symfony/Component/DependencyInjection/Definition.php b/src/Symfony/Component/DependencyInjection/Definition.php
@@ -37,6 +37,7 @@ class Definition
     private $synthetic;
     private $abstract;
     private $synchronized;
+    private $lazy;
 
     protected $arguments;
 
@@ -58,6 +59,7 @@ public function __construct($class = null, array $arguments = array())
         $this->public = true;
         $this->synthetic = false;
         $this->synchronized = false;
+        $this->lazy = false;
         $this->abstract = false;
         $this->properties = array();
     }
@@ -599,6 +601,34 @@ public function isSynchronized()
         return $this->synchronized;
     }
 
+    /**
+     
A3DB
* Sets the lazy flag of this service.
+     *
+     * @param Boolean $lazy
+     *
+     * @return Definition The current instance
+     *
+     * @api
+     */
+    public function setLazy($lazy)
+    {
+        $this->lazy = (Boolean) $lazy;
+
+        return $this;
+    }
+
+    /**
+     * Whether this service is lazy.
+     *
+     * @return Boolean
+     *
+     * @api
+     */
+    public function isLazy()
+    {
+        return $this->lazy;
+    }
+
     /**
      * Sets whether this definition is synthetic, that is not constructed by the
      * container, but dynamically injected.

diff --git a/src/Symfony/Component/DependencyInjection/Dumper/XmlDumper.php b/src/Symfony/Component/DependencyInjection/Dumper/XmlDumper.php
@@ -133,6 +133,9 @@ private function addService($definition, $id, \DOMElement $parent)
         if ($definition->isSynchronized()) {
             $service->setAttribute('synchronized', 'true');
         }
+        if ($definition->isLazy()) {
+            $service->setAttribute('lazy', 'true');
+        }
 
         foreach ($definition->getTags() as $name => $tags) {
             foreach ($tags as $attributes) {

diff --git a/src/Symfony/Component/DependencyInjection/Dumper/YamlDumper.php b/src/Symfony/Component/DependencyInjection/Dumper/YamlDumper.php
@@ -106,6 +106,10 @@ private function addService($id, $definition)
             $code .= sprintf("        factory_class: %s\n", $definition->getFactoryClass());
         }
 
+        if ($definition->isLazy()) {
+            $code .= sprintf("        lazy: true\n");
+        }
+
         if ($definition->getFactoryMethod()) {
             $code .= sprintf("        factory_method: %s\n", $definition->getFactoryMethod());
         }

diff --git a/src/Symfony/Component/DependencyInjection/Loader/XmlFileLoader.php b/src/Symfony/Component/DependencyInjection/Loader/XmlFileLoader.php
@@ -148,7 +148,7 @@ private function parseDefinition($id, $service, $file)
             $definition = new Definition();
         }
 
-        foreach (array('class', 'scope', 'public', 'factory-class', 'factory-method', 'factory-service', 'synthetic', 'synchronized', 'abstract') as $key) {
+        foreach (array('class', 'scope', 'public', 'factory-class', 'factory-method', 'factory-service', 'synthetic', 'synchronized', 'lazy', 'abstract') as $key) {
             if (isset($service[$key])) {
                 $method = 'set'.str_replace('-', '', $key);
                 $definition->$method((string) $service->getAttributeAsPhp($key));

diff --git a/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php b/src/Symfony/Component/DependencyInjection/Loader/YamlFileLoader.php
@@ -157,6 +157,10 @@ private function parseDefinition($id, $service, $file)
             $definition->setSynchronized($service['synchronized']);
         }
 
+        if (isset($service['lazy'])) {
+            $definition->setLazy($service['lazy']);
+        }
+
         if (isset($service['public'])) {
             $definition->setPublic($service['public']);
         }

diff --git a/src/Symfony/Component/DependencyInjection/Loader/schema/dic/services/services-1.0.xsd b/src/Symfony/Component/DependencyInjection/Loader/schema/dic/services/services-1.0.xsd
@@ -87,6 +87,7 @@
     <xsd:attribute name="public" type="boolean" />
     <xsd:attribute name="synthetic" type="boolean" />
     <xsd:attribute name="synchronized" type="boolean" />
+    <xsd:attribute name="lazy" type="boolean" />
     <xsd:attribute name="abstract" type="boolean" />
     <xsd:attribute name="factory-class" type="xsd:string" />
     <xsd:attribute name="factory-method" type="xsd:string" />

diff --git a/src/Symfony/Component/DependencyInjection/Tests/ContainerBuilderTest.php b/src/Symfony/Component/DependencyInjection/Tests/ContainerBuilderTest.php
@@ -263,6 +263,30 @@ public function testCreateService()
         $this->assertInstanceOf('\FooClass', $builder->get('foo2'), '->createService() replaces parameters in the file provided by the service definition');
     }
 
+    /**
+     * @covers Symfony\Component\DependencyInjection\ContainerBuilder::createService
+     */
+    public function testCreateServiceWithDelegateFactory()
+    {
+        $builder = new ContainerBuilder();
+
+        $builder->register('foo1', 'FooClass')->setFile(__DIR__.'/Fixtures/includes/foo.php');
+        $builder->getDefinition('foo1')->setLazy(true);
+
+        /* @var $foo1 \ProxyManager\Proxy\LazyLoadingInterface|\ProxyManager\Proxy\ValueHolderInterface */
+        $foo1 = $builder->get('foo1');
+
+        $this->assertInstanceOf('\FooClass', $foo1);
+        $this->assertInstanceOf('\ProxyManager\Proxy\LazyLoadingInterface', $foo1);
+        $this->assertFalse($foo1->isProxyInitialized());
+
+        $foo1->initializeProxy();
+
+        $this->assertTrue($foo1->isProxyInitialized());
+        $this->assertInstanceOf('\FooClass', $foo1->getWrappedValueHolderValue());
+        $this->assertNotInstanceOf('\ProxyManager\Proxy\LazyLoadingInterface', $foo1->getWrappedValueHolderValue());
+    }
+
     /**
      * @covers Symfony\Component\DependencyInjection\ContainerBuilder::createService
      */

diff --git a/src/Symfony/Component/DependencyInjection/Tests/DefinitionTest.php b/src/Symfony/Component/DependencyInjection/Tests/DefinitionTest.php
@@ -164,6 +164,18 @@ public function testSetIsSynchronized()
         $this->assertTrue($def->isSynchronized(), '->isSynchronized() returns true if the service is synchronized.');
     }
 
+    /**
+     * @covers Symfony\Component\DependencyInjection\Definition::setLazy
+     * @covers Symfony\Component\DependencyInjection\Definition::isLazy
+     */
+    public function testSetIsLazy()
+    {
+        $def = new Definition('stdClass');
+        $this->assertFalse($def->isLazy(), '->isLazy() returns false by default');
+        $this->assertSame($def, $def->setLazy(true), '->setLazy() implements a fluent interface');
+        $this->assertTrue($def->isLazy(), '->isLazy() returns true if the service is lazy.');
+    }
+
     /**
      * @covers Symfony\Component\DependencyInjection\Definition::setAbstract
      * @covers Symfony\Component\DependencyInjection\Definition::isAbstract

diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/xml/services6.xml b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/xml/services6.xml
@@ -46,6 +46,6 @@
     <service id="alias_for_foo" alias="foo" />
     <service id="another_alias_for_foo" alias="foo" public="false" />
     <service id="factory_service" factory-method="getInstance" factory-service="baz_factory" />
-    <service id="request" class="Request" synthetic="true" synchronized="true"/>
+    <service id="request" class="Request" synthetic="true" synchronized="true" lazy="true"/>
   </services>
 </container>
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/yaml/services6.yml b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/yaml/services6.yml
@@ -28,3 +28,4 @@ services:
         class: Request
         synthetic: true
         synchronized: true
+        lazy: true
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Loader/XmlFileLoaderTest.php b/src/Symfony/Component/DependencyInjection/Tests/Loader/XmlFileLoaderTest.php
@@ -187,6 +187,7 @@ public function testLoadServices()
 
         $this->assertTrue($services['request']->isSynthetic(), '->load() parses the synthetic flag');
         $this->assertTrue($services['request']->isSynchronized(), '->load() parses the synchronized flag');
+        $this->assertTrue($services['request']->isLazy(), '->load() parses the lazy flag');
 
         $aliases = $container->getAliases();
         $this->assertTrue(isset($aliases['alias_for_foo']), '->load() parses <service> elements');

diff --git a/src/Symfony/Component/DependencyInjection/Tests/Loader/YamlFileLoaderTest.php b/src/Symfony/Component/DependencyInjection/Tests/Loader/YamlFileLoaderTest.php
@@ -130,6 +130,7 @@ public function testLoadServices()
 
         $this->assertTrue($services['request']->isSynthetic(), '->load() parses the synthetic flag');
         $this->assertTrue($services['request']->isSynchronized(), '->load() parses the synchronized flag');
+        $this->assertTrue($services['request']->isLazy(), '->load() parses the lazy flag');
 
         $aliases = $container->getAliases();
         $this->assertTrue(isset($aliases['alias_for_foo']), '->load() parses aliases');