/**
* Load the initializer.
*
* @param ContainerBuilder $container
* @param HttpKernelInterface $app
*/
private function loadInitializer(ContainerBuilder $container, $app)
{
$definition = new Definition('Laracasts\\Behat\\Context\\KernelAwareInitializer', [$app]);
$definition->addTag(EventDispatcherExtension::SUBSCRIBER_TAG, ['priority' => 0]);
$definition->addTag(ContextExtension::INITIALIZER_TAG, ['priority' => 0]);
$container->setDefinition('laravel.initializer', $definition);
}
/**
* Load the initializer.
*
* @param ContainerBuilder $container
* @param \Illuminate\Container\Container $app
*/
private function loadInitializer(ContainerBuilder $container, $app)
{
$definition = new Definition('Arisro\\Behat\\Context\\ApplicationAwareInitializer', [$app]);
$definition->addTag(EventDispatcherExtension::SUBSCRIBER_TAG, ['priority' => 0]);
$definition->addTag(ContextExtension::INITIALIZER_TAG, ['priority' => 0]);
$container->setDefinition('lumen.initializer', $definition);
}
/**
* @param ContainerBuilder $container
* @param MetadataInterface $metadata
*/
protected function addResourceListeners(ContainerBuilder $container, MetadataInterface $metadata)
{
$defaultOptions = ['parent_path_default' => null, 'parent_path_autocreate' => false, 'parent_path_force' => false, 'name_filter' => true, 'name_resolver' => true];
$metadataOptions = $metadata->hasParameter('options') ? $metadata->getParameter('options') : [];
if ($diff = array_diff(array_keys($metadataOptions), array_keys($defaultOptions))) {
throw new InvalidArgumentException(sprintf('Unknown PHPCR-ODM configuration options: "%s"', implode('", "', $diff)));
}
$options = array_merge($defaultOptions, $metadataOptions);
$createEventName = sprintf('%s.%s.pre_%s', $metadata->getApplicationName(), $metadata->getName(), 'create');
$updateEventName = sprintf('%s.%s.pre_%s', $metadata->getApplicationName(), $metadata->getName(), 'update');
if ($options['parent_path_default']) {
$defaultPath = new Definition(DefaultParentListener::class);
$defaultPath->setArguments([new Reference($metadata->getServiceId('manager')), $options['parent_path_default'], $options['parent_path_autocreate'], $options['parent_path_force']]);
$defaultPath->addTag('kernel.event_listener', ['event' => $createEventName, 'method' => 'onPreCreate']);
$container->setDefinition(sprintf('%s.resource.%s.doctrine.odm.phpcr.event_listener.default_path', $metadata->getApplicationName(), $metadata->getName()), $defaultPath);
}
if ($options['name_filter']) {
$nameFilter = new Definition(NameFilterListener::class);
$nameFilter->setArguments([new Reference($metadata->getServiceId('manager'))]);
$nameFilter->addTag('kernel.event_listener', ['event' => $createEventName, 'method' => 'onEvent']);
$nameFilter->addTag('kernel.event_listener', ['event' => $updateEventName, 'method' => 'onEvent']);
$container->setDefinition(sprintf('%s.resource.%s.doctrine.odm.phpcr.event_listener.name_filter', $metadata->getApplicationName(), $metadata->getName()), $nameFilter);
}
if ($options['name_resolver']) {
$nameResolver = new Definition(NameResolverListener::class);
$nameResolver->setArguments([new Reference($metadata->getServiceId('manager'))]);
$nameResolver->addTag('kernel.event_listener', ['event' => $createEventName, 'method' => 'onEvent']);
$nameResolver->addTag('kernel.event_listener', ['event' => $updateEventName, 'method' => 'onEvent']);
$container->setDefinition(sprintf('%s.resource.%s.doctrine.odm.phpcr.event_listener.name_resolver', $metadata->getApplicationName(), $metadata->getName()), $nameResolver);
}
}
/**
* Process the adaptor config configuration.
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function loadConfigs(array $config, ContainerBuilder $container)
{
foreach ($config['configs'] as $name => $arguments) {
if (!$arguments['enabled']) {
continue;
}
$id = 'integrated_channel.config.memory.' . $name;
if ($container->hasDefinition($id)) {
continue;
}
// first create the options and for that we need a unique service id
do {
$id_options = $id . '.options.' . uniqid();
} while ($container->hasDefinition($id_options));
$definition = new Definition('%integrated_channel.config.options.class%');
$definition->setPublic(false);
$definition->setArguments([$arguments['options']]);
$container->setDefinition($id_options, $definition);
// create the config it self
$definition = new Definition('%integrated_channel.config.class%');
$definition->setArguments([$name, $arguments['adaptor'], new Reference($id_options)]);
if ($arguments['channel']) {
foreach ($arguments['channel'] as $channel) {
$definition->addTag('integrated_channel.config', ['channel' => $channel]);
}
} else {
$definition->addTag('integrated_channel.config');
}
$container->setDefinition($id, $definition);
}
}
private function getElement()
{
$service = new Definition();
$service->setClass('stdClass');
$service->setArguments(array(new Reference('arg.one'), new Reference('arg.two', ContainerInterface::IGNORE_ON_INVALID_REFERENCE), new Reference('arg.three', ContainerInterface::NULL_ON_INVALID_REFERENCE), '@arg.four'));
$service->addTag('tag.one');
$service->addTag('tag.two', array('attr' => 'one'));
$service->addTag('tag.two', array('attr' => 'two'));
return new ServiceElement('service.one', $service);
}
/**
* @test
*/
public function it_adds_translation_loaders_using_only_the_first_tag_alias()
{
$this->setDefinition('sylius.theme.translation.loader_provider', new Definition(null, [[]]));
$translationLoaderDefinition = new Definition();
$translationLoaderDefinition->addTag('translation.loader', ['alias' => 'yml']);
$translationLoaderDefinition->addTag('translation.loader', ['alias' => 'yaml']);
$this->setDefinition('translation.loader.yml', $translationLoaderDefinition);
$this->compile();
$this->assertContainerBuilderHasServiceDefinitionWithArgument('sylius.theme.translation.loader_provider', 0, ['yml' => new Reference('translation.loader.yml')]);
}
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$container->setParameter('lexiphanic_encrypted_cookie.cookies', $config['cookies']);
$container->setParameter('lexiphanic_encrypted_cookie.encryption.service', $config['encryption']['service']);
$listener = new Definition('Lexiphanic\\EncryptedCookieBundle\\EventListener\\EncryptedCookieListener', ['%lexiphanic_encrypted_cookie.cookies%', new Reference($config['encryption']['service'])]);
$listener->addTag('kernel.event_listener', ['event' => 'kernel.request', 'method' => 'onKernelRequest', 'priority' => 8192]);
$listener->addTag('kernel.event_listener', ['event' => 'kernel.response', 'method' => 'onKernelResponse', 'priority' => -8192]);
$container->setDefinition('lexiphanic.encrypted_cookie_listener', $listener);
}
/**
* @param ContainerBuilder $container
* @param string $connection
* @param string $defaultConnection
*/
private function createConnectionListener(ContainerBuilder $container, $connection, string $defaultConnection)
{
$listenerArguments = [$connection, $connection === $defaultConnection, new Reference('algatux_influx_db.connection.' . $connection . '.http')];
if ($container->hasDefinition('algatux_influx_db.connection.' . $connection . '.udp')) {
array_push($listenerArguments, new Reference('algatux_influx_db.connection.' . $connection . '.udp'));
}
$listenerDefinition = new Definition(InfluxDbEventListener::class, $listenerArguments);
$listenerDefinition->addTag('kernel.event_listener', ['event' => 'influxdb.points_collected', 'method' => 'onPointsCollected']);
$listenerDefinition->addTag('kernel.event_listener', ['event' => 'kernel.terminate', 'method' => 'onKernelTerminate']);
$container->setDefinition('algatux_influx_db.event_listener.' . $connection, $listenerDefinition);
}
/**
* Adds the container scope listener.
*
* @param ContainerBuilder $container
*/
private function addContainerScopeListener(ContainerBuilder $container)
{
if (!method_exists('Symfony\\Component\\DependencyInjection\\Container', 'enterScope')) {
return;
}
$definition = new Definition('Contao\\CoreBundle\\EventListener\\ContainerScopeListener');
$definition->addArgument(new Reference('service_container'));
$definition->addTag('kernel.event_listener', ['event' => 'kernel.request', 'method' => 'onKernelRequest', 'priority' => 30]);
$definition->addTag('kernel.event_listener', ['event' => 'kernel.finish_request', 'method' => 'onKernelFinishRequest', 'priority' => -254]);
$container->setDefinition('contao.listener.container_scope', $definition);
}
public function definitionProvider()
{
$definitionWithoutTags = new Definition();
$definitionWithTwoTags = new Definition();
$tag = 'some_provider';
$attributesOfFirstTag = array('name' => 'attribute of first tag');
$definitionWithTwoTags->addTag($tag, $attributesOfFirstTag);
$attributesOfSecondTag = array('name' => 'attributes of second tag');
$definitionWithTwoTags->addTag($tag, $attributesOfSecondTag);
$otherAttributes = array('name' => 'some other attribute');
return array(array($definitionWithoutTags, $tag, array(), false), array($definitionWithTwoTags, $tag, $attributesOfFirstTag, true), array($definitionWithTwoTags, $tag, $attributesOfSecondTag, true), array($definitionWithTwoTags, $tag, $otherAttributes, false));
}
/**
* @param int|null $declaredPriority
* @param int $expectedPriority
*
* @covers eZ\Bundle\EzPublishCoreBundle\DependencyInjection\Compiler\ChainConfigResolverPass::process
* @dataProvider addResolverProvider
*/
public function testAddResolver($declaredPriority, $expectedPriority)
{
$resolverDef = new Definition();
$serviceId = 'some_service_id';
if ($declaredPriority !== null) {
$resolverDef->addTag('ezpublish.config.resolver', array('priority' => $declaredPriority));
} else {
$resolverDef->addTag('ezpublish.config.resolver');
}
$this->setDefinition($serviceId, $resolverDef);
$this->compile();
$this->assertContainerBuilderHasServiceDefinitionWithMethodCall('ezpublish.config.resolver.chain', 'addResolver', array(new Reference($serviceId), $expectedPriority));
}
/**
* @dataProvider addViewProviderProvider
*/
public function testAddViewProvider($declaredPriority, $expectedPriority)
{
$def = new Definition();
if ($declaredPriority !== null) {
$def->addTag(BlockViewPass::VIEW_PROVIDER_IDENTIFIER, array('priority' => $declaredPriority));
} else {
$def->addTag(BlockViewPass::VIEW_PROVIDER_IDENTIFIER);
}
$serviceId = 'service_id';
$this->setDefinition($serviceId, $def);
$this->compile();
$this->assertContainerBuilderHasServiceDefinitionWithMethodCall('ezpublish.view_manager', BlockViewPass::ADD_VIEW_PROVIDER_METHOD, array(new Reference($serviceId), $expectedPriority));
}
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
foreach ($config['zones'] as $rule => $zoneOptions) {
$zoneLoggerDefinition = new Definition('Vesax\\HttpKernelLoggerBundle\\EventListener\\TerminateListener', [new Reference('logger'), new Reference('vesax.http_kernel_logger.formatter'), '|' . $rule . '|']);
$zoneLoggerDefinition->addTag('kernel.event_subscriber');
$zoneLoggerDefinition->addTag('monolog.logger', ['channel' => $zoneOptions['channel']]);
$container->setDefinition('vesax.http_kernel_logger.loggers.' . md5($rule), $zoneLoggerDefinition);
}
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
}
public function testAddLocationAndContentHandlers()
{
$this->setDefinition('ezpublish.persistence.legacy.search.gateway.criteria_converter.content', new Definition());
$this->setDefinition('ezpublish.persistence.legacy.search.gateway.criteria_converter.location', new Definition());
$commonServiceId = 'common_service_id';
$def = new Definition();
$def->addTag('ezpublish.persistence.legacy.search.gateway.criterion_handler.content');
$def->addTag('ezpublish.persistence.legacy.search.gateway.criterion_handler.location');
$this->setDefinition($commonServiceId, $def);
$this->compile();
$this->assertContainerBuilderHasServiceDefinitionWithMethodCall('ezpublish.persistence.legacy.search.gateway.criteria_converter.content', 'addHandler', array(new Reference($commonServiceId)));
$this->assertContainerBuilderHasServiceDefinitionWithMethodCall('ezpublish.persistence.legacy.search.gateway.criteria_converter.location', 'addHandler', array(new Reference($commonServiceId)));
}
protected function addFormType(array $config, ContainerBuilder $container, $method)
{
$fullMethod = 'multisafepay_' . $method;
$definition = new Definition();
$definition->setClass('%ruudk_payment_multisafepay.form.default_type.class%');
$definition->addArgument($fullMethod);
if ($method === 'ideal') {
$definition->setClass('%ruudk_payment_multisafepay.form.ideal_type.class%');
$definition->addArgument(sprintf('%%ruudk_payment_multisafepay.ideal.issuers.%s%%', $config['test'] ? 'test' : 'live'));
}
$definition->addTag('payment.method_form_type');
$definition->addTag('form.type', array('alias' => $fullMethod));
$container->setDefinition(sprintf('ruudk_payment_multisafepay.form.%s_type', $method), $definition);
}
protected function addFormType(ContainerBuilder $container, $method)
{
$mollieMethod = 'mollie_' . $method;
$definition = new Definition();
$definition->setClass('%ruudk_payment_mollie.form.mollie_type.class%');
$definition->addArgument($mollieMethod);
if ($method === 'ideal') {
$definition->setClass('%ruudk_payment_mollie.form.ideal_type.class%');
$definition->addArgument('%kernel.cache_dir%');
}
$definition->addTag('payment.method_form_type');
$definition->addTag('form.type', array('alias' => $mollieMethod));
$container->setDefinition(sprintf('ruudk_payment_mollie.form.%s_type', $method), $definition);
}
protected function addFormType(array $config, ContainerBuilder $container, $method)
{
$mollieMethod = 'mollie_' . $method;
$definition = new Definition();
$definition->setClass('%ruudk_payment_mollie.form.mollie_type.class%');
$definition->addArgument($mollieMethod);
if ($method === 'ideal') {
$definition->setClass('%ruudk_payment_mollie.form.ideal_type.class%');
$definition->addArgument(sprintf('%%ruudk_payment_mollie.ideal.issuers.%s%%', substr($config['api_key'], 0, 4) == 'live' ? 'live' : 'test'));
}
$definition->addTag('payment.method_form_type');
$definition->addTag('form.type', array('alias' => $mollieMethod));
$container->setDefinition(sprintf('ruudk_payment_mollie.form.%s_type', $method), $definition);
}
/**
* @param bool $withOmnipay
* @param string|null $fakeGatewayAlias
*
* @return ContainerBuilder
*/
protected function createContainer($withOmnipay, $fakeGatewayAlias = null)
{
$container = new ContainerBuilder();
if ($withOmnipay) {
$container->setDefinition('omnipay', new Definition('ColinODell\\OmnipayBundle\\Service\\Omnipay'));
}
$gatewayDefinition = new Definition('My\\Fake\\Gateway');
if ($fakeGatewayAlias === null) {
$gatewayDefinition->addTag('omnipay.gateway');
} else {
$gatewayDefinition->addTag('omnipay.gateway', ['alias' => $fakeGatewayAlias]);
}
$container->setDefinition('test.gateway', $gatewayDefinition);
return $container;
}
/**
* @dataProvider processProvider
*/
public function testProcess($hasWarmer, $configIds)
{
$warmerId = 'yahoo_japan_config_cache.cache_warmer';
$container = new ContainerBuilder();
foreach ($configIds as $configId) {
$definition = new Definition($configId);
$definition->addTag(ConfigCache::TAG_CACHE_WARMER);
$container->setDefinition($configId, $definition);
}
if ($hasWarmer) {
$definition = new Definition($warmerId);
$container->setDefinition($warmerId, $definition);
}
$pass = new CacheWarmerPass();
$pass->process($container);
foreach ($configIds as $index => $configId) {
if ($hasWarmer) {
$calls = $container->getDefinition($warmerId)->getMethodCalls();
$this->assertTrue(isset($calls[$index][0]));
// method name
$this->assertSame('addConfig', $calls[$index][0]);
$this->assertTrue(isset($calls[$index][1][0]));
// argument
$this->assertEquals(new Reference($configId), $calls[$index][1][0]);
} else {
$this->assertFalse($container->hasDefinition($warmerId));
}
}
}
/**
* @inheritDoc
*/
public function process(ContainerBuilder $container)
{
$executorId = 'thruster_doctrine_actions.doctrine_persist_action.executor';
$executorDefinition = new Definition('Thruster\\Bundle\\DoctrineActionsBundle\\DoctrinePersistActionExecutor', [new Reference('doctrine')]);
$executorDefinition->addTag('thruster_action_executor', []);
$container->setDefinition($executorId, $executorDefinition);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$container->setParameter('eo_airbrake.api_key', $config['api_key']);
$container->setParameter('eo_airbrake.async', $config['async']);
$container->setParameter('eo_airbrake.host', $config['host']);
$container->setParameter('eo_airbrake.secure', $config['secure']);
// Exception Listener
if ($config['api_key']) {
// Airbreak Configuration
$class = $container->getParameter('eo_airbrake.configuration.class');
$definition = new Definition($class, array($config['api_key'], $config['async'], $container->getParameter('kernel.environment'), $config['host'], $config['secure']));
$container->setDefinition('eo_airbrake.configuration', $definition);
// Airbreak Client
$class = $container->getParameter('eo_airbrake.client.class');
$definition = new Definition($class, array(new Reference('eo_airbrake.configuration')));
$container->setDefinition('eo_airbrake.client', $definition);
// Exception Listener
$class = $container->getParameter('eo_airbrake.exception_listener.class');
$definition = new Definition($class, array(new Reference('eo_airbrake.client'), $config['ignored_exceptions']));
$definition->addTag('kernel.event_listener', array('event' => 'kernel.exception', 'method' => 'onKernelException'));
$container->setDefinition('php_airbrake.exception_listener', $definition);
// PHP Shutdown Listener
$class = $container->getParameter('eo_airbrake.shutdown_listener.class');
$definition = new Definition($class, array(new Reference('eo_airbrake.client')));
$definition->addTag('kernel.event_listener', array('event' => 'kernel.controller', 'method' => 'register'));
$container->setDefinition('php_airbrake.shutdown_listener', $definition);
}
}
/**
* {@inheritdoc}
*/
public function load(ContainerBuilder $container, array $config)
{
$container->setDefinition(self::CLIENT_ID, new Definition('GuzzleHttp\\Client', [$config]));
$definition = new Definition('Ingresse\\Behat\\ApiExtension\\Context\\Initializer\\ApiClientInitializer', [new Reference(self::CLIENT_ID), $config]);
$definition->addTag(ContextExtension::INITIALIZER_TAG);
$container->setDefinition('ingresse_api.context_initializer', $definition);
}
/**
* @param type $modelName
* @return Definition
*/
private function createDefinition($modelName)
{
$definition = new Definition(SyliusTrackerListener::class);
$definition->addArgument(new Reference('symedit_analytics.tracker'));
$definition->addTag('kernel.event_listener', ['event' => sprintf('symedit.%s.%s', $modelName, ResourceActions::SHOW), 'method' => 'track']);
return $definition;
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
foreach ($config['actions'] as $key => $value) {
if ($value['max_number_by_ip']) {
$definition = new Definition('Kunstmaan\\VotingBundle\\EventListener\\Security\\MaxNumberByIpEventListener');
$definition->addArgument(new Reference('kunstmaan_voting.services.repository_resolver'));
$definition->addArgument($value['max_number_by_ip']);
$definition->addTag('kernel.event_listener', array('event' => 'kunstmaan_voting.' . lcfirst(ContainerBuilder::camelize($key)), 'method' => 'onVote', 'priority' => 100));
$container->setDefinition('kunstmaan_voting.security.' . $key . '.max_number_by_ip_event_listener', $definition);
}
}
$possibleActions = array('up_vote', 'down_vote', 'facebook_like', 'facebook_send', 'linkedin_share');
$votingDefaultValue = $config['voting_default_value'];
// If the user overwrites the voting_default_value in paramters file, we use this one
if ($container->hasParameter('voting_default_value')) {
$votingDefaultValue = $container->getParameter('voting_default_value');
}
// When no values are defined, initialize with defaults
foreach ($possibleActions as $action) {
if (!isset($config['actions'][$action]) || !is_array($config['actions'][$action])) {
$config['actions'][$action]['default_value'] = $action == 'down_vote' ? -1 * $votingDefaultValue : $votingDefaultValue;
}
}
$container->setParameter('kuma_voting.actions', $config['actions']);
}
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition('fm_bbcode.decoda_manager')) {
return;
}
$filters = $container->getParameter('fm_bbcode.config.filters');
$definitions = array();
foreach ($filters as $id => $class) {
$definition = new Definition($class);
$definition->addTag('fm_bbcode.decoda.filter', array('id' => $id));
$definitions['fm_bbcode.decoda.filter.from_config.' . $id] = $definition;
}
$container->addDefinitions($definitions);
$definition = $container->getDefinition('fm_bbcode.decoda_manager');
$filters = array();
foreach ($container->findTaggedServiceIds('fm_bbcode.decoda.filter') as $id => $attributes) {
// We must assume that the class value has been correctly filled, even if the service is created by a factory
$class = $container->getDefinition($id)->getClass();
$refClass = new \ReflectionClass($class);
$interface = 'Decoda\\Filter';
if (!$refClass->implementsInterface($interface)) {
throw new \InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, $interface));
}
$name = isset($attributes[0]['id']) ? $attributes[0]['id'] : $id;
$name = strtolower($name);
if (isset($filters[$name])) {
throw new \InvalidArgumentException(sprintf('The hook identifier "%s" must be uniq, is already set on "%s" service.', $name, $filters[$name]));
}
$filters[$name] = $id;
$definition->addMethodCall('setFilter', array($name, new Reference($id)));
}
}
public function process(ContainerBuilder $container)
{
// log
$definition = $container->findDefinition('csa_guzzle.subscriber.log');
$logServiceId = $container->getParameter('csa_guzzle.subscriber.log.service');
if ($container->hasDefinition($logServiceId)) {
$definition->replaceArgument(0, new Reference($logServiceId));
}
$channel = $container->getParameter('csa_guzzle.subscriber.log.channel');
if (!empty($channel)) {
$definition->clearTag('monolog.logger');
$definition->addTag('monolog.logger', array('channel' => $channel));
}
// Cache
$cacheServiceId = $container->getParameter('csa_guzzle.subscriber.cache.service');
if ($container->hasDefinition($cacheServiceId)) {
$container->setDefinition('csa_guzzle.cache_storage', new Definition('%csa_guzzle.cache_storage.class%', array(new Reference($cacheServiceId), $container->getParameter('csa_guzzle.subscriber.cache.prefix'))));
$cacheSubscriber = new Definition('%csa_guzzle.subscriber.cache.class%', array(new Reference('csa_guzzle.cache_storage'), $container->getParameter('csa_guzzle.subscriber.cache.enable')));
$cacheSubscriber->addTag('csa_guzzle.subscriber');
$container->setDefinition('csa_guzzle.subscriber.cache', $cacheSubscriber);
}
// get all Guzzle subscribers
$subscribers = $container->findTaggedServiceIds('csa_guzzle.subscriber');
if (!count($subscribers)) {
return;
}
// Factory
$factory = $container->findDefinition('csa_guzzle.client_factory');
$arg = [];
foreach ($subscribers as $subscriber => $options) {
$arg[] = new Reference($subscriber);
}
$factory->replaceArgument(1, $arg);
}
/**
* @param array $config
* @param ContainerBuilder $container
* @return $this
*/
protected function parseValidateSchemaConfig(array $config, ContainerBuilder $container)
{
if ($config['enabled']) {
$validateSchemaDefinition = $container->getDefinition('dev.validate_schema');
foreach ($config['paths'] as $path) {
$validateSchemaDefinition->addMethodCall('addMappingPath', array($path));
}
if ($config['bundles']['enabled']) {
if (count($config['bundles']['bundles'])) {
$bundles = $config['bundles']['bundles'];
} else {
$bundles = array_keys($container->getParameter('kernel.bundles'));
}
foreach ($bundles as $bundleName) {
$validateSchemaDefinition->addMethodCall('addMappingBundle', array($bundleName));
}
}
$validateSchemaDefinition->addMethodCall('setExcludes', array($config['excludes']));
$listener = new Definition('steevanb\\DevBundle\\EventListener\\ValidateSchemaListener');
$listener->addArgument(new Reference('dev.validate_schema'));
$listener->addArgument($config['disabled_urls']);
$listener->addTag('kernel.event_listener', array('event' => $config['event'] == 'kernel.request' ? 'kernel.request' : 'kernel.response', 'method' => 'validateSchema'));
$container->setDefinition('dev.validate_schema.listener', $listener);
}
return $this;
}
public function testProcess()
{
// TEST 1
// must work with no tagged services
$containerBuilder = new ContainerBuilder();
$compilerPass = new RepositoryCompilerPass();
$compilerPass->process($containerBuilder);
// TEST 2
// must add repository tagged service into the repository pool
$containerBuilder = new ContainerBuilder();
$containerBuilder->setDefinition('lag.repository.repository_pool', new Definition());
$repository = new Definition();
$repository->addTag('doctrine.repository');
$containerBuilder->setDefinition('repository1', $repository);
$repository = new Definition();
$repository->addTag('doctrine.repository');
$containerBuilder->setDefinition('repository2', $repository);
$compilerPass = new RepositoryCompilerPass();
$compilerPass->process($containerBuilder);
$methodCalls = $containerBuilder->getDefinition('lag.repository.repository_pool')->getMethodCalls();
$this->assertCount(2, $methodCalls);
foreach ($methodCalls as $call) {
/** @var Reference $reference */
$reference = $call[1][0];
// test reference assignment
$this->assertEquals('add', $call[0]);
$this->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $reference);
$this->assertTrue(in_array($reference->__toString(), ['repository1', 'repository2']));
}
}
/**
* {@inheritdoc}
*/
protected function addDefinitions(ContainerBuilder $container, array $config)
{
$container->setParameter('kherge_uuid.serializer.uuid_handler.class', 'KHerGe\\Bundle\\UuidBundle\\Serializer\\UuidHandler');
$definition = new Definition('%kherge_uuid.serializer.uuid_handler.class%');
$definition->addTag('jms_serializer.subscribing_handler');
$container->setDefinition('kherge_uuid.serializer.uuid_handler', $definition);
}
private function createBusDefinition($id, $priority)
{
$definition = new Definition('stdClass');
$definition->addTag($this->middlewareTag, array('priority' => $priority));
$this->container->setDefinition($id, $definition);
return $definition;
}
