Author: Fabien Potencier (fabien@symfony.com)
 /**
  * @param ContainerBuilder $container
  * @param string           $code
  * @param Definition       $formatter
  * @param array            $extensions
  *
  * @return string
  */
 public function createEnvironment(ContainerBuilder $container, $code, Definition $formatter, array $extensions)
 {
     $loader = new Definition('Twig_Loader_String');
     $loader->setPublic(false);
     $container->setDefinition(sprintf('sonata.formatter.twig.loader.%s', $code), $loader);
     $loaderSelector = new Definition('Sonata\\FormatterBundle\\Twig\\Loader\\LoaderSelector', array(new Reference(sprintf('sonata.formatter.twig.loader.%s', $code)), new Reference('twig.loader')));
     $loaderSelector->setPublic(false);
     $env = new Definition('Twig_Environment', array($loaderSelector, array('debug' => false, 'strict_variables' => false, 'charset' => 'UTF-8')));
     $env->setPublic(false);
     $container->setDefinition(sprintf('sonata.formatter.twig.env.%s', $code), $env);
     $sandboxPolicy = new Definition('Sonata\\FormatterBundle\\Twig\\SecurityPolicyContainerAware', array(new Reference('service_container'), $extensions));
     $sandboxPolicy->setPublic(false);
     $container->setDefinition(sprintf('sonata.formatter.twig.sandbox.%s.policy', $code), $sandboxPolicy);
     $sandbox = new Definition('Twig_Extension_Sandbox', array($sandboxPolicy, true));
     $sandbox->setPublic(false);
     $container->setDefinition(sprintf('sonata.formatter.twig.sandbox.%s', $code), $sandbox);
     $env->addMethodCall('addExtension', array(new Reference(sprintf('sonata.formatter.twig.sandbox.%s', $code))));
     foreach ($extensions as $extension) {
         $env->addMethodCall('addExtension', array(new Reference($extension)));
     }
     $lexer = new Definition('Twig_Lexer', array(new Reference(sprintf('sonata.formatter.twig.env.%s', $code)), array('tag_comment' => array('<#', '#>'), 'tag_block' => array('<%', '%>'), 'tag_variable' => array('<%=', '%>'))));
     $lexer->setPublic(false);
     $container->setDefinition(new Reference(sprintf('sonata.formatter.twig.lexer.%s', $code)), $lexer);
     $env->addMethodCall('setLexer', array(new Reference(sprintf('sonata.formatter.twig.lexer.%s', $code))));
     return sprintf('sonata.formatter.twig.env.%s', $code);
 }
 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}
  */
 public function process(ContainerBuilder $container)
 {
     $analysis = $container->getParameter('es.analysis');
     $connections = $container->getParameter('es.connections');
     $managers = $container->getParameter('es.managers');
     $collector = $container->get('es.metadata_collector');
     foreach ($managers as $managerName => $manager) {
         if (!isset($connections[$manager['connection']])) {
             throw new InvalidConfigurationException('There is no ES connection with the name: ' . $manager['connection']);
         }
         $managerName = strtolower($managerName);
         $connection = $connections[$manager['connection']];
         $managerDefinition = new Definition($container->getParameter('es.manager.class'), [$managerName, $connection, $analysis, $manager]);
         $managerDefinition->setFactory([new Reference('es.manager_factory'), 'createManager']);
         $container->setDefinition(sprintf('es.manager.%s', $managerName), $managerDefinition);
         // Make es.manager.default as es.manager service.
         if ($managerName === 'default') {
             $container->setAlias('es.manager', 'es.manager.default');
         }
         $mappings = $collector->getMappings($manager['mappings']);
         // Building repository services.
         foreach ($mappings as $repositoryType => $repositoryDetails) {
             $repositoryDefinition = new Definition($container->getParameter('es.repository.class'), [$repositoryDetails['bundle'] . ':' . $repositoryDetails['class']]);
             $repositoryDefinition->setFactory([new Reference(sprintf('es.manager.%s', $managerName)), 'getRepository']);
             $repositoryId = sprintf('es.manager.%s.%s', $managerName, $repositoryType);
             if (strtolower(substr($repositoryType, -8)) === 'document') {
                 $container->setAlias(sprintf('es.manager.%s.%s', $managerName, substr($repositoryType, 0, strlen($repositoryType) - 8)), $repositoryId);
             }
             $container->setDefinition($repositoryId, $repositoryDefinition);
         }
     }
 }
示例#4
0
 /**
  * {@inheritdoc}
  */
 public function createDefinition(ContainerBuilder $container, array $config)
 {
     $definition = new Definition('Jose\\Object\\JWK');
     $definition->setFactory([new Reference('jose.factory.jwk'), 'createFromKeyFile']);
     $definition->setArguments([$config['path'], $config['password'], $config['additional_values']]);
     return $definition;
 }
 /**
  * {@inheritdoc}
  */
 public function process(ContainerBuilder $container)
 {
     $pool = $container->getDefinition('sonata.product.pool');
     $calls = $pool->getMethodCalls();
     $pool->setMethodCalls(array());
     $map = array();
     foreach ($calls as $method => $arguments) {
         if ($arguments[0] !== '__hack') {
             $pool->addMethodCall($arguments[0], $arguments[1]);
             continue;
         }
         foreach ($arguments[1] as $code => $options) {
             // define a new ProductDefinition
             $definition = new Definition('Sonata\\Component\\Product\\ProductDefinition', array(new Reference($options['provider']), new Reference($options['manager'])));
             $definition->setPublic(false);
             $container->setDefinition($code, $definition);
             $container->getDefinition($options['provider'])->addMethodCall('setCode', array($code));
             $pool->addMethodCall('addProduct', array($code, new Reference($code)));
             $map[$code] = $container->getDefinition($options['manager'])->getArgument(0);
             $container->getDefinition($options['provider'])->addMethodCall('setBasketElementManager', array(new Reference('sonata.basket_element.manager')));
             $container->getDefinition($options['provider'])->addMethodCall('setCurrencyPriceCalculator', array(new Reference('sonata.price.currency.calculator')));
             $container->getDefinition($options['provider'])->addMethodCall('setProductCategoryManager', array(new Reference('sonata.product_category.product')));
             $container->getDefinition($options['provider'])->addMethodCall('setProductCollectionManager', array(new Reference('sonata.product_collection.product')));
             $container->getDefinition($options['provider'])->addMethodCall('setOrderElementClassName', array($container->getParameter('sonata.order.order_element.class')));
             $container->getDefinition($options['provider'])->addMethodCall('setEventDispatcher', array(new Reference('event_dispatcher')));
             if (array_key_exists('variations', $options)) {
                 $container->getDefinition($options['provider'])->addMethodCall('setVariationFields', array($options['variations']['fields']));
             }
         }
     }
     $container->getDefinition('sonata.product.subscriber.orm')->replaceArgument(0, $map);
 }
 /**
  * {@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;
 }
 /**
  * Ensures that the creator returns null if a synthetic service is requested.
  */
 public function testCreatorReturnsNullIfSyntheticServiceIsRequested()
 {
     $definition = new Definition();
     $definition->setSynthetic(true);
     $this->container->setDefinition('my.service', $definition);
     $this->assertNull($this->creator->create('my.service'));
 }
示例#9
0
 /**
  * {@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);
 }
 protected function isInlinableDefinition(ContainerBuilder $container, $id, Definition $definition)
 {
     if (!$definition->isShared()) {
         return true;
     }
     if ($definition->isPublic()) {
         return false;
     }
     $references = count(array_keys($container->getAliases(), $id, true));
     foreach ($container->getDefinitions() as $cDefinition) {
         if ($references > 1) {
             break;
         }
         if ($this->isReferencedByArgument($id, $cDefinition->getArguments())) {
             $references += 1;
             continue;
         }
         foreach ($cDefinition->getMethodCalls() as $call) {
             if ($this->isReferencedByArgument($id, $call[1])) {
                 $references += 1;
                 continue 2;
             }
         }
     }
     return $references <= 1;
 }
示例#11
0
 /**
  * {@inheritdoc}
  */
 public function createDefinition(ContainerBuilder $container, array $config)
 {
     $definition = new Definition('Jose\\Object\\X5UJWKSet');
     $definition->setFactory([new Reference('jose.factory.jwk'), 'createFromX5U']);
     $definition->setArguments([$config['url'], $config['is_secured'], $config['cache'], $config['cache_ttl'], $config['is_https']]);
     return $definition;
 }
示例#12
0
 /**
  * @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');
     }
 }
 /**
  * @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));
         }
     }
 }
 /**
  * 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);
 }
 /**
  * @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);
 }
 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);
         }
     }
 }
 function it_processes_the_configuration_and_registers_services_per_variable(ContainerBuilder $container)
 {
     $variantFormType = new Definition('Some\\App\\Product\\Form\\ProductVariantType');
     $variantFormType->setArguments(array('Some\\App\\Product\\Entity\\ProductVariant', '%sylius.validation_group.product_variant%', 'product'))->addTag('form.type', array('alias' => 'sylius_product_variant'));
     $container->setDefinition('sylius.form.type.product_variant', $variantFormType)->shouldBeCalled();
     $variantChoiceFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\VariantChoiceType');
     $variantChoiceFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_variant_choice'));
     $container->setDefinition('sylius.form.type.product_variant_choice', $variantChoiceFormType)->shouldBeCalled();
     $variantMatchFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\VariantMatchType');
     $variantMatchFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_variant_match'));
     $container->setDefinition('sylius.form.type.product_variant_match', $variantMatchFormType)->shouldBeCalled();
     $optionFormType = new Definition('Some\\App\\Product\\Form\\OptionType');
     $optionFormType->setArguments(array('Some\\App\\Product\\Entity\\Option', '%sylius.validation_group.product_option%', 'product'))->addTag('form.type', array('alias' => 'sylius_product_option'));
     $container->setDefinition('sylius.form.type.product_option', $optionFormType)->shouldBeCalled();
     $optionChoiceFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\OptionEntityChoiceType');
     $optionChoiceFormType->setArguments(array('product', 'Some\\App\\Product\\Entity\\Option'))->addTag('form.type', array('alias' => 'sylius_product_option_choice'));
     $container->setDefinition('sylius.form.type.product_option_choice', $optionChoiceFormType)->shouldBeCalled();
     $optionValueFormType = new Definition('Some\\App\\Product\\Form\\OptionValueType');
     $optionValueFormType->setArguments(array('Some\\App\\Product\\Entity\\OptionValue', '%sylius.validation_group.product_option_value%', 'product'))->addTag('form.type', array('alias' => 'sylius_product_option_value'));
     $container->setDefinition('sylius.form.type.product_option_value', $optionValueFormType)->shouldBeCalled();
     $optionValueChoiceFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\OptionValueChoiceType');
     $optionValueChoiceFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_option_value_choice'));
     $container->setDefinition('sylius.form.type.product_option_value_choice', $optionValueChoiceFormType)->shouldBeCalled();
     $optionValueCollectionFormType = new Definition('Sylius\\Bundle\\VariationBundle\\Form\\Type\\OptionValueCollectionType');
     $optionValueCollectionFormType->setArguments(array('product'))->addTag('form.type', array('alias' => 'sylius_product_option_value_collection'));
     $container->setDefinition('sylius.form.type.product_option_value_collection', $optionValueCollectionFormType)->shouldBeCalled();
     $variables = array('product' => array('variable' => 'Some\\App\\Product\\Entity\\Product', 'option' => array('model' => 'Some\\App\\Product\\Entity\\Option', 'form' => 'Some\\App\\Product\\Form\\OptionType'), 'option_value' => array('model' => 'Some\\App\\Product\\Entity\\OptionValue', 'form' => 'Some\\App\\Product\\Form\\OptionValueType'), 'variant' => array('model' => 'Some\\App\\Product\\Entity\\ProductVariant', 'form' => 'Some\\App\\Product\\Form\\ProductVariantType')));
     $container->setParameter('sylius.variation.variables', $variables)->shouldBeCalled();
     $userConfig = array('driver' => SyliusResourceBundle::DRIVER_DOCTRINE_ORM, 'classes' => array('product' => array('variable' => 'Some\\App\\Product\\Entity\\Product', 'option' => array('model' => 'Some\\App\\Product\\Entity\\Option', 'form' => 'Some\\App\\Product\\Form\\OptionType'), 'option_value' => array('model' => 'Some\\App\\Product\\Entity\\OptionValue', 'form' => 'Some\\App\\Product\\Form\\OptionValueType'), 'variant' => array('model' => 'Some\\App\\Product\\Entity\\ProductVariant', 'form' => 'Some\\App\\Product\\Form\\ProductVariantType'))));
     $processedConfig = array('driver' => SyliusResourceBundle::DRIVER_DOCTRINE_ORM, 'classes' => array('product_option' => array('model' => 'Some\\App\\Product\\Entity\\Option', 'form' => 'Some\\App\\Product\\Form\\OptionType'), 'product_option_value' => array('model' => 'Some\\App\\Product\\Entity\\OptionValue', 'form' => 'Some\\App\\Product\\Form\\OptionValueType'), 'product_variant' => array('model' => 'Some\\App\\Product\\Entity\\ProductVariant', 'form' => 'Some\\App\\Product\\Form\\ProductVariantType')), 'validation_groups' => array('product_variant' => array('sylius'), 'product_option' => array('sylius'), 'product_option_value' => array('sylius')));
     $this->process($userConfig, $container)->shouldReturn($processedConfig);
 }
 /**
  * {@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);
 }
 /**
  * {@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']);
 }
 /**
  * Responds to the "white_october_admin" configuration parameter.
  *
  * @param array            $configs
  * @param ContainerBuilder $container
  */
 public function load(array $configs, ContainerBuilder $container)
 {
     $loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
     $loader->load('admin.xml');
     $processor = new Processor();
     $configuration = new Configuration();
     $config = $processor->process($configuration->getConfigTree(), $configs);
     // data managers
     if (!empty($config['data_managers']['mandango'])) {
         $loader->load('data_manager_mandango.xml');
     }
     if (!empty($config['data_managers']['doctrine']['orm'])) {
         $loader->load('data_manager_doctrine_orm.xml');
     }
     if (!empty($config['data_managers']['doctrine']['odm'])) {
         $loader->load('data_manager_doctrine_odm.xml');
     }
     // admins
     $adminIds = array();
     foreach ($config['admins'] as $admin) {
         $definition = new Definition($admin['class']);
         $definition->addMethodCall('setContainer', array(new Reference('service_container')));
         $classId = str_replace('\\', '_', $admin['class']);
         $adminId = 'white_october_admin.admin.' . $classId;
         $container->setDefinition($adminId, $definition);
         $adminIds[] = $adminId;
     }
     $container->getDefinition('white_october_admin.admin_factory')->replaceArgument(0, $adminIds);
 }
 /**
  * @param ContainerBuilder $container
  * @param Definition $mailerDefinition
  */
 protected function registerOutboundMessageTransformers(ContainerBuilder $container, Definition $mailerDefinition)
 {
     $transformerTag = 'everlution.email.outbound.message_transformer';
     foreach ($container->findTaggedServiceIds($transformerTag) as $id => $attributes) {
         $mailerDefinition->addMethodCall('addMessageTransformer', array(new Reference($id)));
     }
 }
示例#22
0
 /**
  * @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;
 }
 /**
  * {@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);
     }
 }
示例#24
0
 /**
  * {@inheritdoc}
  */
 protected function addRepository(ContainerBuilder $container, MetadataInterface $metadata)
 {
     $reflection = new \ReflectionClass($metadata->getClass('model'));
     $translatableInterface = 'Sylius\\Component\\Translation\\Model\\TranslatableInterface';
     $translatable = interface_exists($translatableInterface) && $reflection->implementsInterface($translatableInterface);
     $repositoryClassParameterName = sprintf('%s.repository.%s.class', $metadata->getApplicationName(), $metadata->getName());
     $repositoryClass = $translatable ? 'Sylius\\Bundle\\TranslationBundle\\Doctrine\\ORM\\TranslatableResourceRepository' : 'Sylius\\Bundle\\ResourceBundle\\Doctrine\\ORM\\EntityRepository';
     if ($container->hasParameter($repositoryClassParameterName)) {
         $repositoryClass = $container->getParameter($repositoryClassParameterName);
     }
     if ($metadata->hasClass('repository')) {
         $repositoryClass = $metadata->getClass('repository');
     }
     $definition = new Definition($repositoryClass);
     $definition->setArguments(array(new Reference($metadata->getServiceId('manager')), $this->getClassMetadataDefinition($metadata)));
     if ($metadata->hasParameter('translation')) {
         $repositoryReflection = new \ReflectionClass($repositoryClass);
         $translatableRepositoryInterface = 'Sylius\\Component\\Translation\\Repository\\TranslatableResourceRepositoryInterface';
         $translationConfig = $metadata->getParameter('translation');
         if (interface_exists($translatableRepositoryInterface) && $repositoryReflection->implementsInterface($translatableRepositoryInterface)) {
             if (isset($translationConfig['fields'])) {
                 $definition->addMethodCall('setTranslatableFields', array($translationConfig['fields']));
             }
         }
     }
     $container->setDefinition($metadata->getServiceId('repository'), $definition);
 }
 /**
  * @param Definition $definition
  * @param string     $class
  * @param string     $repository
  */
 private function assertDefinition(Definition $definition, $class, $repository)
 {
     $this->assertSame($definition->getClass(), $repository);
     $factory = $definition->getFactory();
     $this->assertSame($factory[1], "getRepository");
     $this->assertSame($definition->getArgument(0), $class);
 }
 /**
  * Build the 'lexik_translation.translation_storage' service definition.
  *
  * @param ContainerBuilder $container
  * @param string           $storage
  * @param string           $objectManager
  */
 protected function buildTranslationStorageDefinition(ContainerBuilder $container, $storage, $objectManager)
 {
     $container->setParameter('lexik_translation.storage.type', $storage);
     if ('orm' == $storage) {
         if (isset($objectManager)) {
             $objectManagerReference = new Reference(sprintf('doctrine.orm.%s_entity_manager', $objectManager));
         } else {
             $objectManagerReference = new Reference('doctrine.orm.entity_manager');
         }
     } else {
         if ('mongodb' == $storage) {
             if (isset($objectManager)) {
                 $objectManagerReference = new Reference(sprintf('doctrine_mongodb.odm.%s_document_manager', $objectManager));
             } else {
                 $objectManagerReference = new Reference('doctrine.odm.mongodb.document_manager');
             }
         } else {
             if ('propel' == $storage) {
                 // In the Propel case the object_manager setting is used for the connection name
                 if (isset($objectManager)) {
                     $objectManagerReference = $objectManager;
                 } else {
                     $objectManagerReference = null;
                 }
             } else {
                 throw new \RuntimeException(sprintf('Unsupported storage "%s".', $storage));
             }
         }
     }
     $storageDefinition = new Definition();
     $storageDefinition->setClass(new Parameter(sprintf('lexik_translation.%s.translation_storage.class', $storage)));
     $storageDefinition->setArguments(array($objectManagerReference, array('trans_unit' => new Parameter(sprintf('lexik_translation.%s.trans_unit.class', $storage)), 'translation' => new Parameter(sprintf('lexik_translation.%s.translation.class', $storage)), 'file' => new Parameter(sprintf('lexik_translation.%s.file.class', $storage)))));
     $container->setDefinition('lexik_translation.translation_storage', $storageDefinition);
 }
 /**
  * @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);
 }
示例#28
0
 public function testGetProxyFactoryCode()
 {
     $definition = new Definition(__CLASS__);
     $definition->setLazy(true);
     $code = $this->dumper->getProxyFactoryCode($definition, 'foo');
     $this->assertStringMatchesFormat('%wif ($lazyLoad) {%wreturn $this->services[\'foo\'] = new ' . 'SymfonyBridgeProxyManagerTestsLazyProxyPhpDumperProxyDumperTest_%s(%wfunction ' . '(&$wrappedInstance, \\ProxyManager\\Proxy\\LazyLoadingInterface $proxy) {' . '%w$wrappedInstance = $this->getFooService(false);%w$proxy->setProxyInitializer(null);' . '%wreturn true;%w}%w);%w}%w', $code);
 }
 /**
  * Configure the sitemap source manager.
  *
  * @param array            $config
  * @param ContainerBuilder $container
  */
 protected function configureSitemap(array $config, ContainerBuilder $container)
 {
     $source = $container->getDefinition('sonata.seo.sitemap.manager');
     if (method_exists($source, 'setShared')) {
         // Symfony 2.8+
         $source->setShared(false);
     } else {
         // For Symfony <2.8 compatibility
         $source->setScope(ContainerInterface::SCOPE_PROTOTYPE);
     }
     foreach ($config['doctrine_orm'] as $pos => $sitemap) {
         // define the connectionIterator
         $connectionIteratorId = 'sonata.seo.source.doctrine_connection_iterator_' . $pos;
         $connectionIterator = new Definition('%sonata.seo.exporter.database_source_iterator.class%', array(new Reference($sitemap['connection']), $sitemap['query']));
         $connectionIterator->setPublic(false);
         $container->setDefinition($connectionIteratorId, $connectionIterator);
         // define the sitemap proxy iterator
         $sitemapIteratorId = 'sonata.seo.source.doctrine_sitemap_iterator_' . $pos;
         $sitemapIterator = new Definition('%sonata.seo.exporter.sitemap_source_iterator.class%', array(new Reference($connectionIteratorId), new Reference('router'), $sitemap['route'], $sitemap['parameters']));
         $sitemapIterator->setPublic(false);
         $container->setDefinition($sitemapIteratorId, $sitemapIterator);
         $source->addMethodCall('addSource', array($sitemap['group'], new Reference($sitemapIteratorId), $sitemap['types']));
     }
     foreach ($config['services'] as $service) {
         $source->addMethodCall('addSource', array($service['group'], new Reference($service['id']), $service['types']));
     }
 }
示例#30
0
 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);
 }