Adds an argument to pass to the service constructor/factory method.
public addArgument ( mixed $argument ) : |
||
$argument | mixed | An argument |
return | The current instance |
/** * {@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) { $extensions = $container->findTaggedServiceIds('neoclient.extension_class'); $commandManager = $container->getDefinition('neoclient.command_manager'); $httpClient = $container->getDefinition('neoclient.http_client'); $requestBuilder = $container->getDefinition('neoclient.request_builder'); $extManager = $container->getDefinition('neoclient.extension_manager'); foreach ($extensions as $id => $params) { $definition = $container->getDefinition($id); $class = $definition->getClass(); $commands = $class::getAvailableCommands(); $extManager->addMethodCall('addExtension', array($class)); foreach ($commands as $alias => $props) { if (array_key_exists($alias, $this->registeredCommands)) { throw new \InvalidArgumentException(sprintf('The command with alias "%s" already exist', $alias)); } $def = new Definition(); $def->setClass($props['class']); $def->addArgument($httpClient); $def->addArgument($requestBuilder); $container->setDefinition(sprintf('neoclient.command.%s', $alias), $def); $commandManager->addMethodCall('registerCommand', array($alias, $def)); $this->registeredCommands[$alias] = true; } } $customCommands = $container->findTaggedServiceIds('neoclient.custom_command'); foreach ($customCommands as $id => $params) { $def = $container->getDefinition($id); $def->addArgument($httpClient); $class = $def->getClass(); $commandManager->addMethodCall('registerCommand', array($params[0][0], $def)); } }
/** * @param string $name * @param array $config * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container * * @return \Symfony\Component\DependencyInjection\Reference */ private function getConnectionReference($name, array $config, ContainerBuilder $container) { if (isset($config['client_id'])) { return new Reference($config['client_id']); } $parameters = array('scheme' => $config['scheme'], 'host' => $config['host'], 'port' => $config['port']); if ($config['password']) { $parameters['password'] = $config['password']; } if ($config['timeout']) { $parameters['timeout'] = $config['timeout']; } if ($config['database']) { $parameters['database'] = $config['database']; } $options = null; if (isset($config['options'])) { $options = $config['options']; } $clientClass = '%doctrine_cache.predis.client.class%'; $clientId = sprintf('doctrine_cache.services.%s_predis.client', $name); $clientDef = new Definition($clientClass); $clientDef->addArgument($parameters); $clientDef->addArgument($options); $clientDef->setPublic(false); $container->setDefinition($clientId, $clientDef); return new Reference($clientId); }
/** * Loads the workflow configuration. * * @param array $workflows A workflow configuration array * @param ContainerBuilder $container A ContainerBuilder instance * @param XmlFileLoader $loader An XmlFileLoader instance */ private function registerWorkflowConfiguration(array $workflows, ContainerBuilder $container, XmlFileLoader $loader) { if (!$workflows) { return; } $loader->load('workflow.xml'); $registryDefinition = $container->getDefinition('workflow.registry'); foreach ($workflows as $name => $workflow) { $type = $workflow['type']; $transitions = array(); foreach ($workflow['transitions'] as $transitionName => $transition) { if ($type === 'workflow') { $transitions[] = new Definition(Workflow\Transition::class, array($transitionName, $transition['from'], $transition['to'])); } elseif ($type === 'state_machine') { foreach ($transition['from'] as $from) { foreach ($transition['to'] as $to) { $transitions[] = new Definition(Workflow\Transition::class, array($transitionName, $from, $to)); } } } } // Create a Definition $definitionDefinition = new Definition(Workflow\Definition::class); $definitionDefinition->setPublic(false); $definitionDefinition->addArgument($workflow['places']); $definitionDefinition->addArgument($transitions); $definitionDefinition->addTag('workflow.definition', array('name' => $name, 'type' => $type, 'marking_store' => isset($workflow['marking_store']['type']) ? $workflow['marking_store']['type'] : null)); if (isset($workflow['initial_place'])) { $definitionDefinition->addArgument($workflow['initial_place']); } // Create MarkingStore if (isset($workflow['marking_store']['type'])) { $parentDefinitionId = 'workflow.marking_store.' . $workflow['marking_store']['type']; $markingStoreDefinition = new DefinitionDecorator($parentDefinitionId); foreach ($workflow['marking_store']['arguments'] as $argument) { $markingStoreDefinition->addArgument($argument); } // explicitly set parent class to decorated definition in order to fix inconsistent behavior for <=2.7 // see https://github.com/symfony/symfony/issues/17353 and https://github.com/symfony/symfony/pull/15096 $markingStoreDefinition->setClass($container->getDefinition($parentDefinitionId)->getClass()); } elseif (isset($workflow['marking_store']['service'])) { $markingStoreDefinition = new Reference($workflow['marking_store']['service']); } // Create Workflow $workflowDefinition = new DefinitionDecorator(sprintf('%s.abstract', $type)); $workflowDefinition->replaceArgument(0, $definitionDefinition); if (isset($markingStoreDefinition)) { $workflowDefinition->replaceArgument(1, $markingStoreDefinition); } $workflowDefinition->replaceArgument(3, $name); // Store to container $workflowId = sprintf('%s.%s', $type, $name); $container->setDefinition($workflowId, $workflowDefinition); $container->setDefinition(sprintf('%s.definition', $workflowId), $definitionDefinition); // Add workflow to Registry foreach ($workflow['supports'] as $supportedClass) { $registryDefinition->addMethodCall('add', array(new Reference($workflowId), $supportedClass)); } } }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $translatableEntityLocaleAssignerDefinition = new Definition(TranslatableEntityLocaleAssigner::class); $translatableEntityLocaleAssignerDefinition->addArgument(new Reference('sylius.context.locale')); $translatableEntityLocaleAssignerDefinition->addArgument(new Reference('sylius.translation_locale_provider')); $container->setDefinition('sylius.translatable_entity_locale_assigner', $translatableEntityLocaleAssignerDefinition); }
/** * Create client service * @param string $name * @param array $client * @param ContainerBuilder $container * @param boolean $testMode */ protected function loadClient($name, array $client, ContainerBuilder $container, $testMode = false) { $clientDef = new Definition($container->getParameter($testMode ? 'thrift.client.test.class' : 'thrift.client.class')); $clientDef->addArgument(new Reference('thrift.factory')); $clientDef->addArgument($client); $container->setDefinition(sprintf('thrift.client.%s', $name), $clientDef); }
private function loadRegistrationSubscriber(ContainerBuilder $container, array $config) { $definition = new Definition(); if (array_key_exists('class', $config)) { $definition->setClass($config['class']); } else { $definition->setClass('Tahoe\\Bundle\\MultiTenancyBundle\\EventSubscriber\\RegistrationSubscriber'); } $definition->addTag('kernel.event_subscriber'); if (array_key_exists('manager', $config)) { $definition->addArgument(new Reference($config['manager'])); } else { $definition->addArgument(new Reference('tahoe.multi_tenancy.registration_manager')); } if (array_key_exists('router', $config)) { $definition->addMethodCall('setRouter', array(new Reference($config['router']))); } else { $definition->addMethodCall('setRouter', array(new Reference('tahoe.multi_tenancy.tenant_aware_router'))); } if (array_key_exists('redirect_route', $config)) { $container->setParameter(sprintf("%s.registration_subscriber.redirect_route", $this->getAlias()), $config['redirect_route']); } else { // default parameter $container->setParameter(sprintf("%s.registration_subscriber.redirect_route", $this->getAlias()), 'dashboard'); } // we add the definition to the container $container->setDefinition('tahoe.multi_tenancy.registration_subscriber', $definition); }
/** * @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; }
/** * @param ContainerBuilder $container * @param array $config */ public function load(ContainerBuilder $container, array $config) { $definition = new Definition('Vanare\\BehatCucumberJsonFormatter\\Formatter\\Formatter'); $definition->addArgument($config['filename']); $definition->addArgument($config['outputDir']); $container->setDefinition('json.formatter', $definition)->addTag('output.formatter'); }
public function load(array $configs, ContainerBuilder $container) { $loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); $config = array(); foreach ($configs as $subConfig) { $config = array_merge($config, $subConfig); } foreach ($config['email'] as $alias => $options) { $optionId = sprintf('rage_notification.email.%s.message', $alias); $optionDef = new Definition($container->getParameter('rage_notification.email_message.class')); $optionDef->setShared(false); $optionDef->addArgument(new Reference('mailer')); $optionDef->addArgument(new Reference('templating')); if (!empty($options['from'])) { $optionDef->addMethodCall('setFrom', [$options['from']]); } if (!empty($options['reply_to'])) { $optionDef->addMethodCall('setReplyTo', [$options['reply_to']]); } if (!empty($options['embed_images'])) { $optionDef->addMethodCall('setEmbedImages', [$options['embed_images']['url'], $options['embed_images']['path']]); } if (!empty($options['template_path'])) { $optionDef->addMethodCall('setTemplatePath', [$options['template_path']]); } if (!empty($options['css_file'])) { $optionDef->addMethodCall('setCssFile', [$options['css_file']]); } $container->setDefinition($optionId, $optionDef); if ($alias === 'default') { $container->setAlias('rage_notification.email.message', $optionId); } } }
/** * {@inheritdoc} */ public function load(ContainerBuilder $container, array $config) { $definition = new Definition("FileLineFormatter\\FileLineFormatter"); $definition->addArgument($config['name']); $definition->addArgument('%paths.base%'); $container->setDefinition("console.formatter", $definition)->addTag("output.formatter"); }
public function create(string $class, Reference $factory = null, Reference $repository = null) : Definition { $definition = new Definition($class); $definition->addArgument($factory); $definition->addArgument($repository); $definition->addMethodCall('setContainer', [new Reference('service_container')]); return $definition; }
/** * @param $contextId * @param array $cellConfig * @param ContainerBuilder $container * @param Definition $definition * * @return Definition */ private function configureDefinition($contextId, array &$cellConfig, ContainerBuilder $container, Definition $definition) { // Add searcher as first argument $definition->addArgument($container->getDefinition($this->buildServiceName($cellConfig[self::SEARCHER_PARAMETER], self::SEARCHER_PARAMETER))); // Add transformer as second argument $definition->addArgument($this->getTransformerDefinition($container, $contextId, $cellConfig)); return $definition; }
protected function registerResponseListener(ContainerBuilder $container, $cookieExpiryTime) { $definition = new Definition(); $definition->setClass($container->getParameter('xsolve.cookie_acknowledgement_bar.event_listener.class')); $definition->addArgument(new Reference('xsolve.cookie_acknowledgement_bar.service')); $definition->addArgument($cookieExpiryTime); $definition->addTag('kernel.event_listener', array('event' => 'kernel.response', 'method' => 'onKernelResponse')); $container->setDefinition('xsolve.cookie_acknowledgement_bar.event_listener', $definition); }
/** * Loads extension services into temporary container. * * @param ContainerBuilder $container * @param array $config */ public function load(ContainerBuilder $container, array $config) { $definition = new Definition("emuse\\BehatHTMLFormatter\\Formatter\\BehatHTMLFormatter"); $definition->addArgument($config['name']); $definition->addArgument($config['renderer']); $definition->addArgument($config['file_name']); $definition->addArgument('%paths.base%'); $container->setDefinition("html.formatter", $definition)->addTag("output.formatter"); }
public function create(string $class) : Definition { $definition = new Definition($class); $definition->addArgument(new Reference('form.resolver.factory')); $definition->addArgument(new Reference('form.handler')); $definition->addArgument(new Reference('event_dispatcher')); $definition->addMethodCall('setContainer', [new Reference('service_container')]); return $definition; }
/** * @api * @param array $config * @param string $serviceId * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container * @return void */ public function createFacebookAdapterService(array $config, $serviceId, ContainerBuilder $container) { $definition = new Definition('Laelaps\\Bundle\\Facebook\\FacebookAdapter'); $definition->addArgument(['appId' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_APPLICATION_ID], 'secret' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_SECRET], 'fileUpload' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_FILE_UPLOAD], 'trustForwarded' => $config[FacebookApplicationConfiguration::CONFIG_NODE_NAME_TRUST_PROXY_HEADERS]]); $definition->addArgument(new Reference('session')); $definition->addArgument($config[FacebookAdapterConfiguration::CONFIG_NODE_NAME_ADAPTER_SESSION_NAMESPACE]); $definition->addMethodCall('setContainer', [new Reference('service_container')]); $definition->addMethodCall('staticSetContainer', [new Reference('service_container')]); $container->setDefinition($serviceId, $definition); }
protected function processExtensionConfiguration(array $configuration, ContainerBuilder $container) { parent::processExtensionConfiguration($configuration, $container); $copier = $configuration['copier']; $entities = $copier['entities']; $definition = new Definition($copier['class']); $definition->addArgument($entities); $definition->addArgument(new Reference('doctrine.helper')); $container->setDefinition('locale.copier', $definition); }
public function create(string $class, Reference $manager = null, Reference $formBuilder = null, Reference $dataGrid = null) : Definition { $definition = new Definition(); $definition->setClass($class); $definition->addArgument($manager); $definition->addArgument($formBuilder); $definition->addArgument($dataGrid); $definition->addMethodCall('setContainer', [new Reference('service_container')]); return $definition; }
public function create(string $dataSetServiceId, string $identifier, string $class) : Definition { $definition = new Definition(); $definition->setClass($class); $definition->addArgument(new Reference($dataSetServiceId)); $definition->addArgument($identifier); $definition->addArgument(new Reference('event_dispatcher')); $definition->addMethodCall('setContainer', [new Reference('service_container')]); return $definition; }
/** * @param ContainerBuilder $container */ public function buildCacheCleanListenerDefinition(ContainerBuilder $container) { $listener = new Definition(); $listener->setClass('%lexik_translation.listener.clean_translation_cache.class%'); $listener->addArgument(new Reference('lexik_translation.translation_storage')); $listener->addArgument(new Reference('translator')); $listener->addArgument(new Parameter('kernel.cache_dir')); $listener->addArgument(new Parameter('lexik_translation.managed_locales')); $listener->addTag('kernel.event_listener', array('event' => 'kernel.request', 'method' => 'onKernelRequest')); $container->setDefinition('lexik_translation.listener.clean_translation_cache', $listener); }
public function create(string $repositoryServiceId, string $class) : Definition { $definition = new Definition(); $definition->setClass($class); $definition->addArgument(new Reference($repositoryServiceId)); $definition->addArgument(new Reference('dataset.manager')); $definition->addArgument(new Reference('event_dispatcher')); $definition->setConfigurator([new Reference('dataset.configurator'), 'configure']); $definition->addMethodCall('setContainer', [new Reference('service_container')]); return $definition; }
private function registerRequestHandler(string $name, array $options, ContainerBuilder $container) { if (true === $options['enabled']) { $definition = new Definition($options['class']); $definition->addArgument($name); $definition->addArgument(new Reference($options['manager'])); $definition->addArgument(new Reference('serializer')); $definition->addTag('api.request_handler'); $container->setDefinition($name . '.api.request_handler', $definition); } }
/** * @param Definition $gridService * @param array $config */ private function setGridDefinition(Definition $gridService, array $config) { foreach ($config as $gridName => $gridConfig) { $gridDefinition = new Definition('CSBill\\DataGridBundle\\Grid'); $gridConfig['name'] = $gridName; $gridDefinition->addArgument($this->getGridSource($gridConfig['source'])); $gridDefinition->addArgument($this->getFilterService($gridConfig)); $gridDefinition->addArgument($gridConfig); $gridService->addMethodCall('addGrid', [$gridName, $gridDefinition]); } }
/** * Registers the whitelist subscriber. * * @param ContainerBuilder $container The container builder. * @param array $whitelist The whitelist rules. */ private function registerWhitelist(ContainerBuilder $container, array $whitelist) { $parameter = 'box.builder.whitelist.class'; if (!$container->hasParameter($parameter)) { $container->setParameter($parameter, 'Box\\Component\\Builder\\Event\\Listener\\RegexWhitelistSubscriber'); } $definition = new Definition("%{$parameter}%"); $definition->addArgument($whitelist['file']); $definition->addArgument($whitelist['directory']); $definition->addTag('box.event.subscriber'); $container->setDefinition('box.builder.whitelist', $definition); }
private function createDoctrinePhpcrRepository(array $options, $alias) { if (!isset($options['basepath'])) { $options['basepath'] = null; } $definition = new Definition('Symfony\\Cmf\\Component\\Resource\\Repository\\PhpcrRepository'); $definition->addArgument(new Reference('doctrine_phpcr.session')); $definition->addArgument($options['basepath']); unset($options['basepath']); $this->validateRemainingOptions($options, array('basepath'), $alias); return $definition; }
/** * Load the cache action configuration * * @param ContainerBuilder $container The container * @param string $cacheService The cache service to use * @param boolean $debug Is debug mode activated ? * @param string $env Kernel env */ protected function loadActionCacheConfiguration(ContainerBuilder $container, $cacheService, $debug, $env) { if (!$container->hasParameter('m6.listener.cache_action.excludekeys')) { $container->setParameter('m6.listener.cache_action.excludekeys', array('_template', '_cache', '_method')); } $definition = new Definition('%m6.action_cache.listener.class%'); $definition->addArgument($debug); $definition->addArgument($env); $definition->addMethodCall('setCacheService', array(new Reference($cacheService))); $definition->addMethodCall('setCacheKeyExclude', array($container->getParameter('m6.listener.cache_action.excludekeys'))); $definition->addTag('kernel.event_subscriber'); $container->setDefinition('m6.action_cache.listener', $definition); }
/** * load * * @param ContainerBuilder $container * @param array $config */ public function load(ContainerBuilder $container, array $config) { $definition = new Definition('jarnaiz\\JUnitFormatter\\Formatter\\JUnitFormatter'); if (!($filename = \getenv(self::ENV_FILENAME))) { $filename = $config['filename']; } if (!($outputDir = \getenv(self::ENV_OUTPUTDIR))) { $outputDir = $config['outputDir']; } $definition->addArgument($filename); $definition->addArgument($outputDir); $container->setDefinition('junit.formatter', $definition)->addTag('output.formatter'); }
/** * Creates a complex setting factory. * * The factory has a variable number of arguments. * Dynamic settings are added as tupples: first the argument without the leading and trailing $, so that it is not * transformed by the config resolver pass, then the argument as a string, so that it does get transformed. * * @param string $argumentValue The original argument ($var$/$another_var$) * @param array $dynamicSettings Array of dynamic settings in $argumentValue * * @return Definition */ private function createFactoryDefinition($argumentValue, $dynamicSettings) { $definition = new Definition('stdClass', array($argumentValue)); $definition->setFactoryClass('eZ\\Bundle\\EzPublishCoreBundle\\DependencyInjection\\Configuration\\ComplexSettings\\ComplexSettingValueFactory'); $definition->setFactoryMethod('getArgumentValue'); foreach ($dynamicSettings as $dynamicSetting) { // Trim the '$' so that the dynamic setting doesn't get transformed $definition->addArgument(trim($dynamicSetting, '$')); // This one will be transformed $definition->addArgument($dynamicSetting); } return $definition; }
protected function defineLoggerService(ContainerBuilder $container, $config, $subconfig, $serviceName) { // Configure transport $transportClass = $container->getParameter(sprintf('kuborgh_logentries.transport.%s.class', $subconfig['transport'])); // Build Service $handlerClass = $container->getParameter('kuborgh_logentries.logger.class'); $serviceDef = new Definition($handlerClass); $containerRef = new Reference('service_container'); $serviceDef->addArgument($containerRef); $serviceDef->addArgument($transportClass); $serviceDef->addArgument($subconfig); $serviceDef->addArgument($config['enabled']); $container->setDefinition($serviceName, $serviceDef); }