Adding basic logic to generate proxy instantiation into a php dumped …

…container
symfony · Ocramius · Mar 29, 2013 · Mar 30, 2013 · Mar 30, 2013 · Mar 30, 2013
commit 67aef456ba5c7d4a2e8ba6b1170d9f6e1cfde25e
diff --git a/src/Symfony/Component/DependencyInjection/ContainerBuilder.php b/src/Symfony/Component/DependencyInjection/ContainerBuilder.php
@@ -888,6 +888,8 @@ function (& $wrappedInstance, LazyLoadingInterface $proxy) use ($container, $def
                     $proxy->setProxyInitializer(null);
 
                     $wrappedInstance = $container->createService($definition, $id, false);
+
+                    return true;
                 }
             );
         }

diff --git a/src/Symfony/Component/DependencyInjection/Dumper/PhpDumper.php b/src/Symfony/Component/DependencyInjection/Dumper/PhpDumper.php
@@ -149,6 +149,51 @@ private function addServiceLocalTempVariables($cId, $definition)
         return $code;
     }
 
+    /**
+     * Generates the logic required for proxy lazy loading
+     *
+     * @param string     $id         The service id
+     * @param Definition $definition
+     *
+     * @return string
+     */
+    private function addProxyLoading($id, Definition $definition)
+    {
+        if (!($definition->isLazy() && $definition->getClass())) {
+            return '';
+        }
+
+        $class = $this->dumpValue($definition->getClass());
+
+        if (0 === strpos($class, "'") && !preg_match('/^\'[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*(\\\{2}[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*)*\'$/', $class)) {
+            return '';
+        }
+
+        // @todo this should happen directly through the factory class, but we have to ensure that the proxy
+        // @todo class is generated during the dump process
+        $methodName = 'get' . Container::camelize($id) . 'Service';
+
+        return <<<EOF
+        if (\$lazyLoad) {
+            \$factory   = new \ProxyManager\Factory\LazyLoadingValueHolderFactory(new \ProxyManager\Configuration());
+            \$container = \$this;
+
+            return \$factory->createProxy(
+                $class,
+                function (& \$wrappedInstance, \ProxyManager\Proxy\LazyLoadingInterface \$proxy) use (\$container) {
+                    \$proxy->setProxyInitializer(null);
+
+                    \$wrappedInstance = \$container->$methodName(false);
+
+                    return true;
+                }
+            );
+        }
+
+
+EOF;
+    }
+
     /**
      * Generates the require_once statement for service includes.
      *
@@ -483,18 +528,29 @@ private function addService($id, $definition)
 EOF;
         }
 
-        $code = <<<EOF
+        if ($definition->isLazy()) {
+            $lazyInitialization    = '$lazyLoad = true';
+            $lazyInitializationDoc = "\n     * @param boolean \$lazyLoad whether to try lazy-loading the"
+                . " service with a proxy\n     *";
+        } else {
+            $lazyInitialization    = '';
+            $lazyInitializationDoc = '';
+        }
+
+        $code               = <<<EOF
 
     /**
      * Gets the '$id' service.$doc
-     *
+     *$lazyInitializationDoc
      * $return
      */
-    protected function get{$name}Service()
+    protected function get{$name}Service($lazyInitialization)
     {
 
 EOF;
 
+        $code .= $this->addProxyLoading($id, $definition);
+
         if (!in_array($scope, array(ContainerInterface::SCOPE_CONTAINER, ContainerInterface::SCOPE_PROTOTYPE))) {
             $code .= <<<EOF
         if (!isset(\$this->scopedServices['$scope'])) {

diff --git a/src/Symfony/Component/DependencyInjection/Tests/Dumper/PhpDumperTest.php b/src/Symfony/Component/DependencyInjection/Tests/Dumper/PhpDumperTest.php
@@ -52,6 +52,20 @@ public function testDumpFrozenContainerWithNoParameter()
         $this->assertNotRegexp("/function getDefaultParameters\(/", $dumpedString, '->dump() does not add getDefaultParameters() method definition.');
     }
 
+    public function testDumpContainerWithProxyService()
+    {
+        $container = new ContainerBuilder();
+        $container->register('foo', 'stdClass');
+        $container->getDefinition('foo')->setLazy(true);
+
+        $container->compile();
+
+        $dumper = new PhpDumper($container);
+
+        $dumpedString = $dumper->dump();
+        $this->assertStringEqualsFile(self::$fixturesPath.'/php/lazy_service.php', $dumpedString, '->dump() does generate proxy lazy loading logic.');
+    }
+
     public function testDumpOptimizationString()
     {
         $definition = new Definition();

diff --git a/src/Symfony/Component/DependencyInjection/Tests/Fixtures/php/lazy_service.php b/src/Symfony/Component/DependencyInjection/Tests/Fixtures/php/lazy_service.php
@@ -0,0 +1,66 @@
+<?php
+
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\DependencyInjection\Container;
+use Symfony\Component\DependencyInjection\Exception\InactiveScopeException;
+use Symfony\Component\DependencyInjection\Exception\InvalidArgumentException;
+use Symfony\Component\DependencyInjection\Exception\LogicException;
+use Symfony\Component\DependencyInjection\Exception\RuntimeException;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Component\DependencyInjection\Parameter;
+use Symfony\Component\DependencyInjection\ParameterBag\FrozenParameterBag;
+
+/**
+ * ProjectServiceContainer
+ *
+ * This class has been auto-generated
+ * by the Symfony Dependency Injection Component.
+ */
+class ProjectServiceContainer extends Container
+{
+    /**
+     * Constructor.
+     */
+    public function __construct()
+    {
+        $this->services =
+        $this->scopedServices =
+        $this->scopeStacks = array();
+
+        $this->set('service_container', $this);
+
        $this->scopes = array();
+        $this->scopeChildren = array();
+    }
+
+    /**
+     * Gets the 'foo' service.
+     *
+     * This service is shared.
+     * This method always returns the same instance of the service.
+     *
+     * @param boolean $lazyLoad whether to try lazy-loading the service with a proxy
+     *
+     * @return stdClass A stdClass instance.
+     */
+    protected function getFooService($lazyLoad = true)
+    {
+        if ($lazyLoad) {
+            $factory   = new \ProxyManager\Factory\LazyLoadingValueHolderFactory(new \ProxyManager\Configuration());
+            $container = $this;
+
+            return $factory->createProxy(
+                'stdClass',
+                function (& $wrappedInstance, \ProxyManager\Proxy\LazyLoadingInterface $proxy) use ($container) {
+                    $proxy->setProxyInitializer(null);
+
+                    $wrappedInstance = $container->getFooService(false);
+
+                    return true;
+                }
+            );
+        }
+
+        return $this->services['foo'] = new \stdClass();
+    }
+}
-Original file line number
+Diff line change
@@ Expand Up @@
                         $proxy->setProxyInitializer(null);
                         $wrappedInstance = $container->createService($definition, $id, false);
+                        return true;
                     }
                 );
             }
@@ Expand Down @@