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);
}
