Removes a service definition.
| public removeDefinition ( string $id ) | ||
| $id | string | The service identifier |
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$processor = new Processor();
$config = $processor->processConfiguration($configuration, $configs);
$container->setParameter('deuzu_request_collector', $config);
$loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
// @moulox
$logger = false;
$mailer = false;
$persister = false;
foreach ($config['collectors'] as $collectorName => $collector) {
if ($collector['logger']['enabled']) {
$logger = true;
}
if ($collector['mailer']['enabled']) {
$mailer = true;
}
if ($collector['persister']['enabled']) {
$persister = true;
}
}
if (!$logger) {
$container->removeDefinition('deuzu.request_collector.collector.logger');
}
if (!$persister) {
$container->removeDefinition('deuzu.request_collector.collector.persister');
}
if (!$mailer) {
$container->removeDefinition('deuzu.request_collector.collector.mailer');
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$typeIdx = array();
foreach ($container->findTaggedServiceIds('form.type') as $id => $tags) {
$typeIdx[] = $id;
}
$typeExtensionIdx = array();
foreach ($container->findTaggedServiceIds('form.type_extension') as $id => $tag) {
$typeExtensionIdx[] = $id;
}
$container->setParameter('sonata.core.form.types', $typeIdx);
$container->setParameter('sonata.core.form.type_extensions', $typeExtensionIdx);
// nothing to do
if (!$container->hasDefinition('sonata.core.form.extension.dependency')) {
return;
}
// get factories
$original = $container->getDefinition('form.extension');
$factory = $container->getDefinition('sonata.core.form.extension.dependency');
$factory->replaceArgument(1, $original->getArgument(1));
$factory->replaceArgument(2, $original->getArgument(2));
$factory->replaceArgument(3, $original->getArgument(3));
$container->removeDefinition('form.extension');
$container->removeDefinition('sonata.core.form.extension.dependency');
$container->setDefinition('form.extension', $factory);
}
public function process(ContainerBuilder $container)
{
if ($container->has('fos_rest.serializer')) {
$class = $container->getParameterBag()->resolveValue($container->findDefinition('fos_rest.serializer')->getClass());
if (!is_subclass_of($class, 'FOS\\RestBundle\\Serializer\\Serializer')) {
throw new \InvalidArgumentException(sprintf('"fos_rest.serializer" must implement FOS\\RestBundle\\Serializer\\Serializer (instance of "%s" given).', $class));
}
return;
}
if (!$container->has('serializer') && !$container->has('jms_serializer.serializer')) {
throw new \InvalidArgumentException('Neither a service called "jms_serializer.serializer" nor "serializer" is available and no serializer is explicitly configured. You must either enable the JMSSerializerBundle, enable the FrameworkBundle serializer or configure a custom serializer.');
}
if ($container->has('serializer')) {
$class = $container->getParameterBag()->resolveValue($container->findDefinition('serializer')->getClass());
if (is_subclass_of($class, 'Symfony\\Component\\Serializer\\SerializerInterface')) {
$container->setAlias('fos_rest.serializer', 'fos_rest.serializer.symfony');
$container->removeDefinition('fos_rest.serializer.exception_wrapper_serialize_handler');
} elseif (is_subclass_of($class, 'JMS\\Serializer\\SerializerInterface')) {
$container->setAlias('fos_rest.serializer', 'fos_rest.serializer.jms');
} elseif (is_subclass_of($class, 'FOS\\RestBundle\\Serializer\\Serializer')) {
$container->setAlias('fos_rest.serializer', 'serializer');
} else {
throw new \InvalidArgumentException(sprintf('"fos_rest.serializer" must implement FOS\\RestBundle\\Serializer\\Serializer (instance of "%s" given).', $class));
}
return;
} else {
$container->removeDefinition('fos_rest.serializer.exception_wrapper_normalizer');
}
if ($container->has('jms_serializer.serializer')) {
$container->setAlias('fos_rest.serializer', 'fos_rest.serializer.jms');
} else {
$container->removeDefinition('fos_rest.serializer.exception_wrapper_serialize_handler');
}
}
/**
* You can modify the container here before it is dumped to PHP code.
*
* @param ContainerBuilder $container
*
* @api
*/
public function process(ContainerBuilder $container)
{
$config = $container->getParameter(ElastificationPhpClientExtension::PARAMETER_CONFIG_KEY);
if (true === $config['profiler_enabled']) {
$clientAlias = $container->getAlias(ElastificationPhpClientExtension::ALIAS_CLIENT);
$profilerDef = $container->getDefinition(ElastificationPhpClientExtension::SERVICE_CLIENT_PROFILER_KEY);
$profilerDef->replaceArgument(0, new Reference($clientAlias->__toString()));
$dataCollectorDef = $container->getDefinition('elastification_php_client.datacollector');
$dataCollectorDef->addMethodCall('setConfig', array($config));
$container->setAlias(ElastificationPhpClientExtension::ALIAS_CLIENT, ElastificationPhpClientExtension::SERVICE_CLIENT_PROFILER_KEY);
} else {
if ($container->hasDefinition('profiler')) {
$sfProfilerDef = $container->getDefinition('profiler');
$sfProfilerMethodCalls = $sfProfilerDef->getMethodCalls();
foreach ($sfProfilerMethodCalls as $sfProfilerMethodCallsIndex => $sfProfilerMethodCall) {
if (isset($sfProfilerMethodCall[1][0]) && 'elastification_php_client.datacollector' == (string) $sfProfilerMethodCall[1][0]) {
unset($sfProfilerMethodCalls[$sfProfilerMethodCallsIndex]);
}
}
$sfProfilerDef->setMethodCalls($sfProfilerMethodCalls);
}
$container->removeDefinition(ElastificationPhpClientExtension::SERVICE_CLIENT_PROFILER_KEY);
$container->removeDefinition('elastification_php_client.datacollector');
}
}
public function process(ContainerBuilder $container)
{
if ($container->hasDefinition('assetic.filter.closure.jar') && $container->hasParameter('assetic.filter.closure.jar') && $container->getParameterBag()->resolveValue($container->getParameter('assetic.filter.closure.jar'))) {
$container->removeDefinition('assetic.filter.closure.api');
} elseif ($container->hasDefinition('assetic.filter.closure.api')) {
$container->removeDefinition('assetic.filter.closure.jar');
}
}
public function process(ContainerBuilder $container)
{
if ($container->hasDefinition('session')) {
return;
}
$container->removeDefinition('lunetics_locale.session_guesser');
$container->removeDefinition('lunetics_locale.locale_session');
}
public function process(ContainerBuilder $container)
{
if (false === $container->hasDefinition('security.csrf.token_manager')) {
$container->removeDefinition('dunglas_angular_csrf.validation_listener');
$container->removeDefinition('dunglas_angular_csrf.form.extension.disable_csrf');
$container->removeDefinition('dunglas_angular_csrf.cookie_listener');
$container->removeDefinition('dunglas_angular_csrf.token_manager');
}
}
/**
* Removes cache restore definition if unnecessary.
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function removeCacheRestorer(array $config, ContainerBuilder $container)
{
if (!$config['cache_restore']) {
$container->removeDefinition('yahoo_japan_config_cache.cache_saver');
$container->removeDefinition('yahoo_japan_config_cache.cache_restorer');
$container->removeDefinition('yahoo_japan_config_cache.cache_cleanup');
}
return $this;
}
public function process(ContainerBuilder $container)
{
if ($container->has('fos_rest.exception_listener') && $container->has('twig.exception_listener')) {
$container->removeDefinition('twig.exception_listener');
}
if (!$container->has('templating.engine.twig')) {
$container->removeDefinition('fos_rest.exception.twig_controller');
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition('templating.engine.php')) {
$container->removeDefinition('ivory_ck_editor.templating.helper');
}
if (!$container->hasDefinition('twig')) {
$container->removeDefinition('ivory_ck_editor.twig_extension');
}
}
/**
* Loads the configuration.
*
* @param array $configs An array of configuration settings
* @param ContainerBuilder $container A ContainerBuilder instance
*/
public function load(array $configs, ContainerBuilder $container)
{
$parameterBag = $container->getParameterBag();
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('assetic.xml');
$loader->load('templating_twig.xml');
$loader->load('templating_php.xml');
$config = self::processConfigs($configs, $container->getParameter('kernel.debug'), array_keys($container->getParameter('kernel.bundles')));
$container->setParameter('assetic.debug', $config['debug']);
$container->setParameter('assetic.use_controller', $config['use_controller']);
$container->setParameter('assetic.read_from', $config['read_from']);
$container->setParameter('assetic.write_to', $config['write_to']);
$container->setParameter('assetic.java.bin', $config['java']);
$container->setParameter('assetic.node.bin', $config['node']);
$container->setParameter('assetic.sass.bin', $config['sass']);
// register filters
foreach ($config['filters'] as $name => $filter) {
if (isset($filter['resource'])) {
$loader->load($parameterBag->resolveValue($filter['resource']));
unset($filter['resource']);
} else {
$loader->load('filters/'.$name.'.xml');
}
if (isset($filter['file'])) {
$container->getDefinition('assetic.filter.'.$name)->setFile($filter['file']);
unset($filter['file']);
}
foreach ($filter as $key => $value) {
$container->setParameter('assetic.filter.'.$name.'.'.$key, $value);
}
}
// twig functions
$container->getDefinition('assetic.twig_extension')->replaceArgument(2, $config['twig']['functions']);
// choose dynamic or static
if ($parameterBag->resolveValue($parameterBag->get('assetic.use_controller'))) {
$loader->load('controller.xml');
$container->getDefinition('assetic.helper.dynamic')->addTag('templating.helper', array('alias' => 'assetic'));
$container->removeDefinition('assetic.helper.static');
} else {
$loader->load('asset_writer.xml');
$container->getDefinition('assetic.helper.static')->addTag('templating.helper', array('alias' => 'assetic'));
$container->removeDefinition('assetic.helper.dynamic');
}
// register config resources
self::registerFormulaResources($container, $parameterBag->resolveValue($config['bundles']));
}
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$configDir = __DIR__ . '/../Resources/config';
$loader = new Loader\YamlFileLoader($container, new FileLocator($configDir));
$loader->load('services.yml');
$bundles = $container->getParameter('kernel.bundles');
if (!isset($bundles['DoctrineBundle'])) {
$container->removeDefinition('rafrsr_datepicker_type_guesser');
$container->removeDefinition('rafrsr_switchery_type_guesser');
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$definition = $container->getDefinition('sonata.core.model.adapter.chain');
if ($container->has('doctrine')) {
$definition->addMethodCall('addAdapter', array(new Reference('sonata.core.model.adapter.doctrine_orm')));
} else {
$container->removeDefinition('sonata.core.model.adapter.doctrine_orm');
}
if ($container->has('doctrine_phpcr')) {
$definition->addMethodCall('addAdapter', array(new Reference('sonata.core.model.adapter.doctrine_phpcr')));
} else {
$container->removeDefinition('sonata.core.model.adapter.doctrine_phpcr');
}
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
if (!in_array('FOS\\UserBundle\\FOSUserBundle', $container->getParameter('kernel.bundles'))) {
$container->removeDefinition('hatimeria_admin.user.form.extensions_collector');
$container->removeDefinition('hatimeria_admin.user.form.handler');
} else {
$fos_class = $container->getParameterBag()->resolveValue($container->getParameterBag()->get('fos_user.model.user.class'));
$builder = $container->getDefinition('hatimeria_admin.user.form.handler');
$builder->replaceArgument(2, new Reference('fos_user.user_manager'));
$builder->replaceArgument(3, $fos_class);
}
}
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configDir = __DIR__ . '/../Resources/config';
$processor = new Processor();
$config = $processor->processConfiguration(new Configuration($this->getAlias()), $configs);
$container->setParameter($this->getAlias(), $config);
$loader = new YamlFileLoader($container, new FileLocator($configDir));
$loader->load('services.yml');
$container->setParameter($this->getAlias() . '.mailerloaded', $config['enabled']);
if (!$config['alphasms_key']) {
$container->removeDefinition('werkint_notification.handler.sms');
$container->removeDefinition('werkint_notification.bridge.alphasms');
}
}
public function process(ContainerBuilder $container)
{
if (false === $container->hasDefinition('twig')) {
return;
}
// register the exception controller only if Twig is enabled and required dependencies do exist
if (!class_exists('Symfony\\Component\\Debug\\Exception\\FlattenException') || !interface_exists('Symfony\\Component\\EventDispatcher\\EventSubscriberInterface')) {
$container->removeDefinition('twig.exception_listener');
} elseif ($container->hasParameter('templating.engines')) {
$engines = $container->getParameter('templating.engines');
if (!in_array('twig', $engines)) {
$container->removeDefinition('twig.exception_listener');
}
}
}
public function process(ContainerBuilder $container)
{
if ($container->has('fos_rest.serializer')) {
return;
}
if ($container->has('jms_serializer.serializer')) {
$container->setAlias('fos_rest.serializer', 'jms_serializer.serializer');
$container->removeDefinition('fos_rest.serializer.exception_wrapper_normalizer');
} elseif ($container->has('serializer')) {
$container->setAlias('fos_rest.serializer', 'serializer');
$container->removeDefinition('fos_rest.serializer.exception_wrapper_serialize_handler');
} else {
throw new \InvalidArgumentException('Neither a service called "jms_serializer.serializer" nor "serializer" is available and no serializer is explicitly configured. You must either enable the JMSSerializerBundle, enable the FrameworkBundle serializer or configure a custom serializer.');
}
}
/**
* {@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');
if (in_array('Sonata\\BlockBundle\\SonataBlockBundle', $container->getParameter('kernel.bundles'))) {
$loader->load('block.xml');
}
$container->setParameter('ekino.new_relic.request_listener.ignored_routes', $config['ignored_routes']);
$container->setParameter('ekino.new_relic.request_listener.ignored_paths', $config['ignored_paths']);
$container->setParameter('ekino.new_relic.request_listener.ignored_commands', $config['ignored_commands']);
$interactor = $config['enabled'] && extension_loaded('newrelic') ? 'ekino.new_relic.interactor.real' : 'ekino.new_relic.interactor.blackhole';
if ($config['logging']) {
$container->setAlias('ekino.new_relic.interactor', 'ekino.new_relic.interactor.logger');
$container->getDefinition('ekino.new_relic.interactor.logger')->replaceArgument(0, new Reference($interactor));
} else {
$container->setAlias('ekino.new_relic.interactor', $interactor);
}
$container->getDefinition('ekino.new_relic.response_listener')->replaceArgument(2, $config['instrument'])->replaceArgument(3, $config['using_symfony_cache']);
if (!$config['log_exceptions']) {
$container->removeDefinition('ekino.new_relic.exception_listener');
}
if (!$config['log_commands']) {
$container->removeDefinition('ekino.new_relic.command_listener');
}
if (!$config['deployment_names']) {
$config['deployment_names'] = array_values(array_filter(explode(';', $config['application_name'])));
}
$container->getDefinition('ekino.new_relic')->replaceArgument(0, $config['application_name'])->replaceArgument(1, $config['api_key'])->replaceArgument(2, $config['license_key'])->replaceArgument(3, $config['xmit'])->replaceArgument(4, $config['deployment_names']);
switch ($config['transaction_naming']) {
case 'controller':
$transaction_naming_service = new Reference('ekino.new_relic.transaction_naming_strategy.controller');
break;
case 'route':
$transaction_naming_service = new Reference('ekino.new_relic.transaction_naming_strategy.route');
break;
case 'service':
if (!isset($config['transaction_naming_service'])) {
throw new \LogicException('When using the "service", transaction naming scheme, the "transaction_naming_service" config parameter must be set.');
}
$transaction_naming_service = new Reference($config['transaction_naming_service']);
break;
default:
throw new \InvalidArgumentException(sprintf('Invalid transaction naming scheme "%s", must be "route", "controller" or "service".', $config['transaction_naming']));
}
$container->getDefinition('ekino.new_relic.request_listener')->replaceArgument(4, $transaction_naming_service)->replaceArgument(5, $config['using_symfony_cache']);
}
public function process(ContainerBuilder $container)
{
// Cache warmer does more harm than good with Drupal.
if ($container->hasDefinition('cache_warmer')) {
$container->removeDefinition('cache_warmer');
}
if ($container->hasAlias('cache_warmer')) {
$container->removeAlias('cache_warmer');
}
// When not working with symfony, we need to provide a file locator
// service of our own instead of the symfony's one
if (!$container->hasDefinition('file_locator') && !$container->hasAlias('file_locator')) {
$container->addDefinitions(['file_locator' => (new Definition())->setClass(CustomFileLocator::class)->addArgument(new Reference('kernel'))]);
} else {
// We are working with fullstack, and our users might have changed
// the global resource directory to somewhere safer than Drupal's
// sites/SITE folder, case in which we must honnor the user's
// configuration
$definition = $container->getDefinition('file_locator');
$definition->setArguments([new Reference('kernel'), $container->getParameter('kernel.root_dir') . '/Resources']);
}
// By registering the framework bundle, we also inherit from Symfony
// default URL generator, which will cause us great pain because of
// Drupal routes will not be known by the framework and throw a few
// exceptions.
if ($container->has('router.default')) {
$container->getDefinition('router.default')->setClass('MakinaCorpus\\Drupal\\Sf\\Routing\\Router');
}
// When NOT in fullstack mode, we need to provide a null implementation
// for the controller resolver service, else the container will be
// unable to spawn the http kernel service
if (!$container->has('controller_resolver')) {
$container->addDefinitions(['controller_resolver' => (new Definition())->setClass('controller_resolver')]);
}
}
/**
* @inheritDoc
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
if (!$config['enabled']) {
$container->removeDefinition('emarref.xdebug.response.debug_listener');
$container->removeDefinition('emarref.xdebug.response.profile_listener');
$container->removeDefinition('emarref.xdebug.response.trace_listener');
} else {
$this->configureListener($container->getDefinition('emarref.xdebug.response.debug_listener'), $config['debugger']);
$this->configureListener($container->getDefinition('emarref.xdebug.response.profile_listener'), $config['profiler']);
$this->configureListener($container->getDefinition('emarref.xdebug.response.trace_listener'), $config['tracer']);
}
}
/**
* @param ContainerBuilder $container
* @param string $serviceName
* @param string $newServiceName
*/
private function changeService(ContainerBuilder $container, $serviceName, $newServiceName)
{
$service = $container->getDefinition($serviceName);
$newService = $container->getDefinition($newServiceName);
$container->removeDefinition($serviceName);
$container->setDefinition($serviceName, $newService);
}
public function load(array $configs, ContainerBuilder $container)
{
$processor = new Processor();
$config = $processor->processConfiguration(new Configuration(), $configs);
$loader = new XmlFileLoader($container, new FileLocator(array(__DIR__ . '/../Resources/config')));
$loader->load('services.xml');
$container->setParameter('jms_i18n_routing.default_locale', $config['default_locale']);
$container->setParameter('jms_i18n_routing.locales', $config['locales']);
$container->setParameter('jms_i18n_routing.catalogue', $config['catalogue']);
$container->setParameter('jms_i18n_routing.strategy', $config['strategy']);
$this->addClassesToCompile(array($container->getDefinition('jms_i18n_routing.router')->getClass()));
if ('prefix' === $config['strategy']) {
$container->getDefinition('jms_i18n_routing.locale_choosing_listener')->setPublic(true)->addTag('kernel.event_listener', array('event' => 'kernel.exception', 'priority' => 128));
}
if ($config['hosts']) {
$container->getDefinition('jms_i18n_routing.router')->addMethodCall('setHostMap', array($config['hosts']));
$container->getDefinition('jms_i18n_routing.locale_changing_listener')->setPublic(true)->addTag('kernel.event_listener', array('event' => 'kernel.request', 'priority' => 120))->addArgument(array_flip($config['hosts']));
$this->addClassesToCompile(array($container->getDefinition('jms_i18n_routing.locale_changing_listener')->getClass()));
}
// remove route extractor if JMSTranslationBundle is not enabled to avoid any problems
$bundles = $container->getParameter('kernel.bundles');
if (!isset($bundles['JMSTranslationBundle'])) {
$container->removeDefinition('jms_i18n_routing.route_translation_extractor');
}
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$container->setParameter('api.title', $config['title']);
$container->setParameter('api.description', $config['description']);
$container->setParameter('api.collection.filter_name.order', $config['collection']['filter_name']['order']);
$container->setParameter('api.collection.order', $config['collection']['order']);
$container->setParameter('api.collection.pagination.page_parameter_name', $config['collection']['pagination']['page_parameter_name']);
$container->setParameter('api.collection.pagination.items_per_page.number', $config['collection']['pagination']['items_per_page']['number']);
$container->setParameter('api.collection.pagination.items_per_page.enable_client_request', $config['collection']['pagination']['items_per_page']['enable_client_request']);
$container->setParameter('api.collection.pagination.items_per_page.parameter_name', $config['collection']['pagination']['items_per_page']['parameter_name']);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('api.xml');
$loader->load('property_info.xml');
$loader->load('mapping.xml');
$loader->load('doctrine_orm.xml');
// JSON-LD and Hydra support
$loader->load('json_ld.xml');
$loader->load('hydra.xml');
// FOSUser support
if ($config['enable_fos_user']) {
$loader->load('fos_user.xml');
}
// Cache
if (isset($config['cache']) && $config['cache']) {
$container->setParameter('api.mapping.cache.prefix', 'api_' . hash('sha256', $container->getParameter('kernel.root_dir')));
$container->getDefinition('api.mapping.class_metadata_factory')->addArgument(new Reference($config['cache']));
} else {
$container->removeDefinition('api.cache_warmer.metadata');
}
}
/**
* {@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');
if (array_key_exists('incident', $config)) {
$container->setParameter('zimban.incident.lifetime', $config['incident']['lifetime']);
}
if (array_key_exists('banner', $config)) {
$container->setParameter('zimban.banner.incidents_to_ban', $config['banner']['incidents_to_ban']);
$container->setParameter('zimban.banner.ban_time_frame', $config['banner']['ban_time_frame']);
}
if (array_key_exists('enabled', $config)) {
if ($container->hasDefinition('zimban.listener.security_hook_listener')) {
$definition = $container->getDefinition('zimban.listener.security_hook_listener');
if (!$definition->hasTag('kernel.event_subscriber') && $config['enabled']) {
$definition->addTag('kernel.event_subscriber', array());
}
if (!$config['enabled']) {
$container->removeDefinition('zimban.listener.security_hook_listener');
}
}
}
}
/**
* @param ContainerBuilder $container
* @param array $config
*/
public function configureDelivery(ContainerBuilder $container, array $config)
{
$pool = $container->getDefinition('sonata.delivery.pool');
$internal = array('free_address_required' => 'sonata.delivery.method.free_address_required', 'free_address_not_required' => 'sonata.delivery.method.free_address_not_required');
$configured = array();
foreach ($config['services'] as $id => $settings) {
if (array_key_exists($id, $internal)) {
$id = $internal[$id];
$definition = $container->getDefinition($id);
$definition->addMethodCall('setName', array($settings['name']));
$definition->addMethodCall('setCode', array($settings['code']));
$definition->addMethodCall('setPriority', array($settings['priority']));
$configured[$settings['code']] = $id;
}
}
foreach ($config['methods'] as $code => $id) {
if (array_key_exists($code, $configured)) {
// Internal service
$id = $configured[$code];
}
if ($container->hasDefinition($id)) {
$definition = $container->getDefinition($id);
$definition->addMethodCall('setEnabled', array(true));
}
// add the delivery method in the method pool
$pool->addMethodCall('addMethod', array(new Reference($id)));
}
// Remove unconfigured services
foreach ($internal as $code => $id) {
if (false === array_search($id, $configured)) {
$container->removeDefinition($id);
}
}
}
public function load(array $configs, ContainerBuilder $container)
{
$config = $this->mergeConfigs($configs);
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$container->setParameter('jms_di_extra.all_bundles', $config['locations']['all_bundles']);
$container->setParameter('jms_di_extra.bundles', $config['locations']['bundles']);
$container->setParameter('jms_di_extra.directories', $config['locations']['directories']);
$container->setParameter('jms_di_extra.cache_dir', $config['cache_dir']);
$container->setParameter('jms_di_extra.disable_grep', $config['disable_grep']);
$container->setParameter('jms_di_extra.doctrine_integration', $config['doctrine_integration']);
if ($config['cache_warmer']['enabled']) {
foreach ($config['cache_warmer']['controller_file_blacklist'] as $filename) {
$this->blackListControllerFile($filename);
}
$container->setParameter('jms_di_extra.cache_warmer.controller_file_blacklist', $this->blackListedControllerFiles);
} else {
$container->removeDefinition('jms_di_extra.controller_injectors_warmer');
}
$this->configureMetadata($config['metadata'], $container, $config['cache_dir'] . '/metadata');
$this->configureAutomaticControllerInjections($config, $container);
if ($config['doctrine_integration']) {
$this->generateEntityManagerProxyClass($config, $container);
}
$this->addClassesToCompile(array('JMS\\DiExtraBundle\\HttpKernel\\ControllerResolver'));
}
/**
* @see Symfony\Component\DependencyInjection\Extension.ExtensionInterface::load()
*/
public function load(array $configs, ContainerBuilder $container)
{
$config = $this->processConfiguration(new Configuration(), $configs);
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('imagine.xml');
if ($config['cache_clearer']) {
$loader->load('cache_clearer.xml');
}
$container->setAlias('liip_imagine', new Alias('liip_imagine.' . $config['driver']));
$cachePrefix = $config['cache_prefix'] ? '/' . trim($config['cache_prefix'], '/') : '';
$container->setParameter('liip_imagine.cache_prefix', $cachePrefix);
$container->setParameter('liip_imagine.web_root', $config['web_root']);
$container->setParameter('liip_imagine.data_root', $config['data_root']);
$container->setParameter('liip_imagine.cache_mkdir_mode', $config['cache_mkdir_mode']);
$container->setParameter('liip_imagine.formats', $config['formats']);
$container->setParameter('liip_imagine.cache.resolver.default', $config['cache']);
foreach ($config['filter_sets'] as $filter => $options) {
if (isset($options['path'])) {
$config['filter_sets'][$filter]['path'] = '/' . trim($options['path'], '/');
}
}
$container->setParameter('liip_imagine.filter_sets', $config['filter_sets']);
$container->setParameter('liip_imagine.data.loader.default', $config['data_loader']);
$container->setParameter('liip_imagine.controller_action', $config['controller_action']);
if ('2' == Kernel::MAJOR_VERSION && '0' == Kernel::MINOR_VERSION) {
$container->removeDefinition('liip_imagine.cache.clearer');
}
$container->setParameter('liip_imagine.cache.resolver.base_path', $config['cache_base_path']);
$resources = $container->hasParameter('twig.form.resources') ? $container->getParameter('twig.form.resources') : array();
$resources[] = 'LiipImagineBundle:Form:form_div_layout.html.twig';
$container->setParameter('twig.form.resources', $resources);
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition('doctrine')) {
$container->removeDefinition('sonata.easy_extends.doctrine.mapper');
return;
}
$mapper = $container->getDefinition('sonata.easy_extends.doctrine.mapper');
foreach (DoctrineCollector::getInstance()->getAssociations() as $class => $associations) {
foreach ($associations as $field => $options) {
$mapper->addMethodCall('addAssociation', array($class, $field, $options));
}
}
foreach (DoctrineCollector::getInstance()->getDiscriminatorColumns() as $class => $columnDefinition) {
$mapper->addMethodCall('addDiscriminatorColumn', array($class, $columnDefinition));
}
foreach (DoctrineCollector::getInstance()->getDiscriminators() as $class => $discriminators) {
foreach ($discriminators as $key => $discriminatorClass) {
$mapper->addMethodCall('addDiscriminator', array($class, $key, $discriminatorClass));
}
}
foreach (DoctrineCollector::getInstance()->getInheritanceTypes() as $class => $type) {
$mapper->addMethodCall('addInheritanceType', array($class, $type));
}
foreach (DoctrineCollector::getInstance()->getIndexes() as $class => $indexes) {
foreach ($indexes as $field => $options) {
$mapper->addMethodCall('addIndex', array($class, $field, $options));
}
}
foreach (DoctrineCollector::getInstance()->getUniques() as $class => $uniques) {
foreach ($uniques as $field => $options) {
$mapper->addMethodCall('addUnique', array($class, $field, $options));
}
}
}
/**
* @param array $configs
* @param ContainerBuilder $container
*/
private function registerPagers(array $configs, ContainerBuilder $container)
{
$shouldDisableRedirector = true;
foreach ($configs as $name => $config) {
$serviceId = sprintf("%s.%s", self::PREFIX_PAGER, $name);
$definition = $container->register($serviceId, $container->getParameter('kg_pager.class'));
// Sets the default items per page for the given pager.
if (isset($config['per_page'])) {
$definition->addArgument($config['per_page']);
}
// Changes the strategy, if this pager should merge last two pages
// given the following threshold.
if (isset($config['merge']) && $config['merge'] > 0) {
$strategyDefinition = new Definition($container->getParameter('kg_pager.strategy.last_page_merged.class'));
$strategyDefinition->addArgument($config['merge']);
$definition->addArgument($strategyDefinition);
}
// Wraps the pager inside a request decorator to have it automatically
// infer the current page from the request.
if ($config['key']) {
$definition = $container->register($serviceId, $container->getParameter('kg_pager.request_decorator.class'))->setArguments(array($definition, new Reference('request_stack'), $config['key']));
}
if ($config['redirect']) {
$shouldDisableRedirector = false;
$definition = $container->register($serviceId, $container->getParameter('kg_pager.bounds_check_decorator.class'))->setArguments(array($definition));
if ($config['key']) {
$definition->addArgument($config['key']);
}
}
}
if ($shouldDisableRedirector) {
$container->removeDefinition('kg_pager.out_of_bounds_redirector');
}
}
public function load(array $configs, ContainerBuilder $container)
{
$this->container = $container;
$loader = new XmlFileLoader($this->container, new FileLocator(array(__DIR__ . '/../Resources/config')));
$loader->load('rabbitmq.xml');
$configuration = new Configuration();
$this->config = $this->processConfiguration($configuration, $configs);
$this->collectorEnabled = $this->config['enable_collector'];
$this->loadConnections();
$this->loadProducers();
$this->loadConsumers();
$this->loadAnonConsumers();
$this->loadRpcClients();
$this->loadRpcServers();
if ($this->collectorEnabled && $this->channelIds) {
$channels = array();
foreach (array_unique($this->channelIds) as $id) {
$channels[] = new Reference($id);
}
$definition = $container->getDefinition('old_sound_rabbit_mq.data_collector');
$definition->replaceArgument(0, $channels);
} else {
$this->container->removeDefinition('old_sound_rabbit_mq.data_collector');
}
}
