Added the Search API Synonym module to deal specifically with licence and license...

[yaffs-website] / vendor / symfony / dependency-injection / Compiler / ResolveReferencesToAliasesPass.php

diff --git a/vendor/symfony/dependency-injection/Compiler/ResolveReferencesToAliasesPass.php b/vendor/symfony/dependency-injection/Compiler/ResolveReferencesToAliasesPass.php
index c200cb4d9138af0ab1023842132e3a489057a9ce..839af1ae232d36160d8df29d7cdda8a8b2153650 100644 (file)
--- a/vendor/symfony/dependency-injection/Compiler/ResolveReferencesToAliasesPass.php
+++ b/vendor/symfony/dependency-injection/Compiler/ResolveReferencesToAliasesPass.php
@@ -11,113 +11,65 @@
 
 namespace Symfony\Component\DependencyInjection\Compiler;
 
-use Symfony\Component\DependencyInjection\Alias;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Exception\ServiceCircularReferenceException;
 use Symfony\Component\DependencyInjection\Reference;
-use Symfony\Component\DependencyInjection\ContainerBuilder;
 
 /**
  * Replaces all references to aliases with references to the actual service.
  *
  * @author Johannes M. Schmitt <schmittjoh@gmail.com>
  */
-class ResolveReferencesToAliasesPass implements CompilerPassInterface
+class ResolveReferencesToAliasesPass extends AbstractRecursivePass
 {
-    private $container;
-
     /**
-     * Processes the ContainerBuilder to replace references to aliases with actual service references.
-     *
-     * @param ContainerBuilder $container
+     * {@inheritdoc}
      */
     public function process(ContainerBuilder $container)
     {
-        $this->container = $container;
-
-        foreach ($container->getDefinitions() as $definition) {
-            if ($definition->isSynthetic() || $definition->isAbstract()) {
-                continue;
-            }
-
-            $definition->setArguments($this->processArguments($definition->getArguments()));
-            $definition->setMethodCalls($this->processArguments($definition->getMethodCalls()));
-            $definition->setProperties($this->processArguments($definition->getProperties()));
-            $definition->setFactory($this->processFactory($definition->getFactory()));
-            $definition->setFactoryService($this->processFactoryService($definition->getFactoryService(false)), false);
-        }
+        parent::process($container);
 
         foreach ($container->getAliases() as $id => $alias) {
-            $aliasId = (string) $alias;
-            if ($aliasId !== $defId = $this->getDefinitionId($aliasId)) {
-                $container->setAlias($id, new Alias($defId, $alias->isPublic()));
+            $aliasId = $container->normalizeId($alias);
+            if ($aliasId !== $defId = $this->getDefinitionId($aliasId, $container)) {
+                $container->setAlias($id, $defId)->setPublic($alias->isPublic())->setPrivate($alias->isPrivate());
             }
         }
     }
 
     /**
-     * Processes the arguments to replace aliases.
-     *
-     * @param array $arguments An array of References
-     *
-     * @return array An array of References
+     * {@inheritdoc}
      */
-    private function processArguments(array $arguments)
+    protected function processValue($value, $isRoot = false)
     {
-        foreach ($arguments as $k => $argument) {
-            if (is_array($argument)) {
-                $arguments[$k] = $this->processArguments($argument);
-            } elseif ($argument instanceof Reference) {
-                $defId = $this->getDefinitionId($id = (string) $argument);
+        if ($value instanceof Reference) {
+            $defId = $this->getDefinitionId($id = $this->container->normalizeId($value), $this->container);
 
-                if ($defId !== $id) {
-                    $arguments[$k] = new Reference($defId, $argument->getInvalidBehavior(), $argument->isStrict(false));
-                }
+            if ($defId !== $id) {
+                return new Reference($defId, $value->getInvalidBehavior());
             }
         }
 
-        return $arguments;
-    }
-
-    private function processFactoryService($factoryService)
-    {
-        if (null === $factoryService) {
-            return;
-        }
-
-        return $this->getDefinitionId($factoryService);
-    }
-
-    private function processFactory($factory)
-    {
-        if (null === $factory || !is_array($factory) || !$factory[0] instanceof Reference) {
-            return $factory;
-        }
-
-        $defId = $this->getDefinitionId($id = (string) $factory[0]);
-
-        if ($defId !== $id) {
-            $factory[0] = new Reference($defId, $factory[0]->getInvalidBehavior(), $factory[0]->isStrict(false));
-        }
-
-        return $factory;
+        return parent::processValue($value);
     }
 
     /**
      * Resolves an alias into a definition id.
      *
-     * @param string $id The definition or alias id to resolve
+     * @param string           $id        The definition or alias id to resolve
+     * @param ContainerBuilder $container
      *
      * @return string The definition id with aliases resolved
      */
-    private function getDefinitionId($id)
+    private function getDefinitionId($id, ContainerBuilder $container)
     {
         $seen = array();
-        while ($this->container->hasAlias($id)) {
+        while ($container->hasAlias($id)) {
             if (isset($seen[$id])) {
-                throw new ServiceCircularReferenceException($id, array_keys($seen));
+                throw new ServiceCircularReferenceException($id, array_merge(array_keys($seen), array($id)));
             }
             $seen[$id] = true;
-            $id = (string) $this->container->getAlias($id);
+            $id = $container->normalizeId($container->getAlias($id));
         }
 
         return $id;