You are here

class ResolveInvalidReferencesPass in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 vendor/symfony/dependency-injection/Compiler/ResolveInvalidReferencesPass.php \Symfony\Component\DependencyInjection\Compiler\ResolveInvalidReferencesPass

Emulates the invalid behavior if the reference is not found within the container.

@author Johannes M. Schmitt <schmittjoh@gmail.com>

Hierarchy

Expanded class hierarchy of ResolveInvalidReferencesPass

1 file declares its use of ResolveInvalidReferencesPass
ResolveInvalidReferencesPassTest.php in vendor/symfony/dependency-injection/Tests/Compiler/ResolveInvalidReferencesPassTest.php

File

vendor/symfony/dependency-injection/Compiler/ResolveInvalidReferencesPass.php, line 25

Namespace

Symfony\Component\DependencyInjection\Compiler
View source
class ResolveInvalidReferencesPass implements CompilerPassInterface {
  private $container;

  /**
   * Process the ContainerBuilder to resolve invalid references.
   *
   * @param ContainerBuilder $container
   */
  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()));
      $calls = array();
      foreach ($definition
        ->getMethodCalls() as $call) {
        try {
          $calls[] = array(
            $call[0],
            $this
              ->processArguments($call[1], true),
          );
        } catch (RuntimeException $e) {

          // this call is simply removed
        }
      }
      $definition
        ->setMethodCalls($calls);
      $properties = array();
      foreach ($definition
        ->getProperties() as $name => $value) {
        try {
          $value = $this
            ->processArguments(array(
            $value,
          ), true);
          $properties[$name] = reset($value);
        } catch (RuntimeException $e) {

          // ignore property
        }
      }
      $definition
        ->setProperties($properties);
    }
  }

  /**
   * Processes arguments to determine invalid references.
   *
   * @param array $arguments    An array of Reference objects
   * @param bool  $inMethodCall
   *
   * @return array
   *
   * @throws RuntimeException When the config is invalid
   */
  private function processArguments(array $arguments, $inMethodCall = false) {
    foreach ($arguments as $k => $argument) {
      if (is_array($argument)) {
        $arguments[$k] = $this
          ->processArguments($argument, $inMethodCall);
      }
      elseif ($argument instanceof Reference) {
        $id = (string) $argument;
        $invalidBehavior = $argument
          ->getInvalidBehavior();
        $exists = $this->container
          ->has($id);

        // resolve invalid behavior
        if (!$exists && ContainerInterface::NULL_ON_INVALID_REFERENCE === $invalidBehavior) {
          $arguments[$k] = null;
        }
        elseif (!$exists && ContainerInterface::IGNORE_ON_INVALID_REFERENCE === $invalidBehavior) {
          if ($inMethodCall) {
            throw new RuntimeException('Method shouldn\'t be called.');
          }
          $arguments[$k] = null;
        }
      }
    }
    return $arguments;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ResolveInvalidReferencesPass::$container private property
ResolveInvalidReferencesPass::process public function Process the ContainerBuilder to resolve invalid references. Overrides CompilerPassInterface::process
ResolveInvalidReferencesPass::processArguments private function Processes arguments to determine invalid references.