[DependencyInjection] Allow anonymous DefinitionDecorator resolving

nicolas-grekas · nicolas-grekas · commit de9335b70b4b · 2015-06-25T12:05:56.000+02:00
diff --git a/src/Symfony/Component/DependencyInjection/Compiler/ResolveDefinitionTemplatesPass.php b/src/Symfony/Component/DependencyInjection/Compiler/ResolveDefinitionTemplatesPass.php
@@ -21,12 +21,13 @@
  * merged Definition instance.
  *
  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
+ * @author Nicolas Grekas <p@tchwork.com>
  */
 class ResolveDefinitionTemplatesPass implements CompilerPassInterface
 {
-    private $container;
     private $compiler;
     private $formatter;
+    private $currentId;
 
     /**
      * Process the ContainerBuilder to replace DefinitionDecorator instances with their real Definition instances.
@@ -35,44 +36,78 @@ class ResolveDefinitionTemplatesPass implements CompilerPassInterface
      */
     public function process(ContainerBuilder $container)
     {
-        $this->container = $container;
         $this->compiler = $container->getCompiler();
         $this->formatter = $this->compiler->getLoggingFormatter();
 
         foreach ($container->getDefinitions() as $id => $definition) {
+            $this->currentId = $id;
+
             // yes, we are specifically fetching the definition from the
             // container to ensure we are not operating on stale data
             $definition = $container->getDefinition($id);
-            if (!$definition instanceof DefinitionDecorator || $definition->isAbstract()) {
-                continue;
+            if ($definition instanceof DefinitionDecorator) {
+                $definition = $this->resolveDefinition($container, $definition);
+                $container->setDefinition($id, $definition);
             }
 
-            $this->resolveDefinition($id, $definition);
+            $definition->setArguments($this->resolveArguments($container, $definition->getArguments()));
+            $definition->setMethodCalls($this->resolveArguments($container, $definition->getMethodCalls()));
+            $definition->setProperties($this->resolveArguments($container, $definition->getProperties()));
         }
     }
 
+    /**
+     * Resolves definition decorator arguments.
+     *
+     * @param ContainerBuilder $container The ContainerBuilder
+     * @param array            $arguments An array of arguments
+     *
+     * @return array
+     */
+    private function resolveArguments(ContainerBuilder $container, array $arguments)
+    {
+        foreach ($arguments as $k => $argument) {
+            if (is_array($argument)) {
+                $arguments[$k] = $this->resolveArguments($container, $argument);
+            } elseif ($argument instanceof Definition) {
+                if ($argument instanceof DefinitionDecorator) {
+                    $arguments[$k] = $argument = $this->resolveDefinition($container, $argument);
+                }
+                $argument->setArguments($this->resolveArguments($container, $argument->getArguments()));
+                $argument->setMethodCalls($this->resolveArguments($container, $argument->getMethodCalls()));
+                $argument->setProperties($this->resolveArguments($container, $argument->getProperties()));
+            }
+        }
+
+        return $arguments;
+    }
+
     /**
      * Resolves the definition.
      *
-     * @param string              $id         The definition identifier
+     * @param ContainerBuilder    $container  The ContainerBuilder
      * @param DefinitionDecorator $definition
      *
      * @return Definition
      *
      * @throws \RuntimeException When the definition is invalid
      */
-    private function resolveDefinition($id, DefinitionDecorator $definition)
+    private function resolveDefinition(ContainerBuilder $container, DefinitionDecorator $definition)
     {
-        if (!$this->container->hasDefinition($parent = $definition->getParent())) {
-            throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $id));
+        if (!$container->hasDefinition($parent = $definition->getParent())) {
+            throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $this->currentId));
         }
 
-        $parentDef = $this->container->getDefinition($parent);
+        $parentDef = $container->getDefinition($parent);
         if ($parentDef instanceof DefinitionDecorator) {
-            $parentDef = $this->resolveDefinition($parent, $parentDef);
+            $id = $this->currentId;
+            $this->currentId = $parent;
+            $parentDef = $this->resolveDefinition($container, $parentDef);
+            $container->setDefinition($parent, $parentDef);
+            $this->currentId = $id;
         }
 
-        $this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $id, $parent));
+        $this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $this->currentId, $parent));
         $def = new Definition();
 
         // merge in parent definition
@@ -156,9 +191,6 @@ private function resolveDefinition($id, DefinitionDecorator $definition)
         $def->setScope($definition->getScope(false), false);
         $def->setTags($definition->getTags());
 
-        // set new definition on container
-        $this->container->setDefinition($id, $def);
-
         return $def;
     }
 }
diff --git a/src/Symfony/Component/DependencyInjection/Tests/Compiler/ResolveDefinitionTemplatesPassTest.php b/src/Symfony/Component/DependencyInjection/Tests/Compiler/ResolveDefinitionTemplatesPassTest.php
@@ -176,6 +176,32 @@ public function testSetLazyOnServiceIsParent()
         $this->assertTrue($container->getDefinition('child1')->isLazy());
     }
 
+    public function testDeepDefinitionsResolving()
+    {
+        $container = new ContainerBuilder();
+
+        $container->register('parent', 'parentClass');
+        $container->register('sibling', 'siblingClass')
+            ->addArgument(new DefinitionDecorator('parent'))
+            ->setProperty('prop', new DefinitionDecorator('parent'))
+            ->addMethodCall('meth', array(new DefinitionDecorator('parent')))
+        ;
+
+        $this->process($container);
+
+        $argument = $container->getDefinition('sibling')->getArgument(0);
+        $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($argument));
+        $this->assertSame('parentClass', $argument->getClass());
+
+        $properties = $container->getDefinition('sibling')->getProperties();
+        $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($properties['prop']));
+        $this->assertSame('parentClass', $properties['prop']->getClass());
+
+        $methodCalls = $container->getDefinition('sibling')->getMethodCalls();
+        $this->assertSame('Symfony\Component\DependencyInjection\Definition', get_class($methodCalls[0][1][0]));
+        $this->assertSame('parentClass', $methodCalls[0][1][0]->getClass());
+    }
+
     protected function process(ContainerBuilder $container)
     {
         $pass = new ResolveDefinitionTemplatesPass();
