class RegisterListenersPass in Zircon Profile 8.0

Compiler pass to register tagged services for an event dispatcher.

Hierarchy

• class \Symfony\Component\EventDispatcher\DependencyInjection\RegisterListenersPass implements CompilerPassInterface

2 files declare their use of RegisterListenersPass

RegisterListenersPass.php in vendor/symfony/http-kernel/DependencyInjection/RegisterListenersPass.php

RegisterListenersPassTest.php in vendor/symfony/event-dispatcher/Tests/DependencyInjection/RegisterListenersPassTest.php

File

vendor/symfony/event-dispatcher/DependencyInjection/RegisterListenersPass.php, line 20

Namespace

Symfony\Component\EventDispatcher\DependencyInjection

class RegisterListenersPass implements CompilerPassInterface {

  /**
   * @var string
   */
  protected $dispatcherService;

  /**
   * @var string
   */
  protected $listenerTag;

  /**
   * @var string
   */
  protected $subscriberTag;

  /**
   * Constructor.
   *
   * @param string $dispatcherService Service name of the event dispatcher in processed container
   * @param string $listenerTag       Tag name used for listener
   * @param string $subscriberTag     Tag name used for subscribers
   */
  public function __construct($dispatcherService = 'event_dispatcher', $listenerTag = 'kernel.event_listener', $subscriberTag = 'kernel.event_subscriber') {
    $this->dispatcherService = $dispatcherService;
    $this->listenerTag = $listenerTag;
    $this->subscriberTag = $subscriberTag;
  }
  public function process(ContainerBuilder $container) {
    if (!$container
      ->hasDefinition($this->dispatcherService) && !$container
      ->hasAlias($this->dispatcherService)) {
      return;
    }
    $definition = $container
      ->findDefinition($this->dispatcherService);
    foreach ($container
      ->findTaggedServiceIds($this->listenerTag) as $id => $events) {
      $def = $container
        ->getDefinition($id);
      if (!$def
        ->isPublic()) {
        throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event listeners are lazy-loaded.', $id));
      }
      if ($def
        ->isAbstract()) {
        throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event listeners are lazy-loaded.', $id));
      }
      foreach ($events as $event) {
        $priority = isset($event['priority']) ? $event['priority'] : 0;
        if (!isset($event['event'])) {
          throw new \InvalidArgumentException(sprintf('Service "%s" must define the "event" attribute on "%s" tags.', $id, $this->listenerTag));
        }
        if (!isset($event['method'])) {
          $event['method'] = 'on' . preg_replace_callback(array(
            '/(?<=\\b)[a-z]/i',
            '/[^a-z0-9]/i',
          ), function ($matches) {
            return strtoupper($matches[0]);
          }, $event['event']);
          $event['method'] = preg_replace('/[^a-z0-9]/i', '', $event['method']);
        }
        $definition
          ->addMethodCall('addListenerService', array(
          $event['event'],
          array(
            $id,
            $event['method'],
          ),
          $priority,
        ));
      }
    }
    foreach ($container
      ->findTaggedServiceIds($this->subscriberTag) as $id => $attributes) {
      $def = $container
        ->getDefinition($id);
      if (!$def
        ->isPublic()) {
        throw new \InvalidArgumentException(sprintf('The service "%s" must be public as event subscribers are lazy-loaded.', $id));
      }
      if ($def
        ->isAbstract()) {
        throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as event subscribers are lazy-loaded.', $id));
      }

      // We must assume that the class value has been correctly filled, even if the service is created by a factory
      $class = $container
        ->getParameterBag()
        ->resolveValue($def
        ->getClass());
      $refClass = new \ReflectionClass($class);
      $interface = 'Symfony\\Component\\EventDispatcher\\EventSubscriberInterface';
      if (!$refClass
        ->implementsInterface($interface)) {
        throw new \InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, $interface));
      }
      $definition
        ->addMethodCall('addSubscriberService', array(
        $id,
        $class,
      ));
    }
  }

}

Members

Name	Modifiers	Type	Description	Overrides
RegisterListenersPass::$dispatcherService	protected	property
RegisterListenersPass::$listenerTag	protected	property
RegisterListenersPass::$subscriberTag	protected	property
RegisterListenersPass::process	public	function	You can modify the container here before it is dumped to PHP code. Overrides CompilerPassInterface::process
RegisterListenersPass::__construct	public	function	Constructor.