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); }
protected function addFormType(array $config, ContainerBuilder $container, $method) { $fullMethod = 'multisafepay_' . $method; $definition = new Definition(); $definition->setClass('%ruudk_payment_multisafepay.form.default_type.class%'); $definition->addArgument($fullMethod); if ($method === 'ideal') { $definition->setClass('%ruudk_payment_multisafepay.form.ideal_type.class%'); $definition->addArgument(sprintf('%%ruudk_payment_multisafepay.ideal.issuers.%s%%', $config['test'] ? 'test' : 'live')); } $definition->addTag('payment.method_form_type'); $definition->addTag('form.type', array('alias' => $fullMethod)); $container->setDefinition(sprintf('ruudk_payment_multisafepay.form.%s_type', $method), $definition); }
protected function addFormType(array $config, ContainerBuilder $container, $method) { $mollieMethod = 'mollie_' . $method; $definition = new Definition(); $definition->setClass('%ruudk_payment_mollie.form.mollie_type.class%'); $definition->addArgument($mollieMethod); if ($method === 'ideal') { $definition->setClass('%ruudk_payment_mollie.form.ideal_type.class%'); $definition->addArgument(sprintf('%%ruudk_payment_mollie.ideal.issuers.%s%%', substr($config['api_key'], 0, 4) == 'live' ? 'live' : 'test')); } $definition->addTag('payment.method_form_type'); $definition->addTag('form.type', array('alias' => $mollieMethod)); $container->setDefinition(sprintf('ruudk_payment_mollie.form.%s_type', $method), $definition); }
protected function addFormType(ContainerBuilder $container, $method) { $mollieMethod = 'mollie_' . $method; $definition = new Definition(); $definition->setClass('%ruudk_payment_mollie.form.mollie_type.class%'); $definition->addArgument($mollieMethod); if ($method === 'ideal') { $definition->setClass('%ruudk_payment_mollie.form.ideal_type.class%'); $definition->addArgument('%kernel.cache_dir%'); } $definition->addTag('payment.method_form_type'); $definition->addTag('form.type', array('alias' => $mollieMethod)); $container->setDefinition(sprintf('ruudk_payment_mollie.form.%s_type', $method), $definition); }
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)); } }
/** * creates a transport definitions based on config * * @param ContainerBuilder $container * @param array $config * @param Definition $typeDef * @return Definition * @author Daniel Wendlandt */ private function createTransportDefinition(ContainerBuilder $container, array $config, Definition $typeDef) { $transportDef = new Definition(); $transportDef->setPublic(false); switch ($config['protocol']) { case 'thrift': $transportDef->setClass($container->getParameter('elastification_php_client.transport.thrift.class')); break; default: $transportDef->setClass($container->getParameter('elastification_php_client.transport.http.class')); break; } $transportDef->setArguments(array($typeDef)); $container->setDefinition(ElastificationPhpClientExtension::SERVICE_TRANSPORT_KEY, $transportDef); return $transportDef; }
/** * {@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['connections'] as $name => $values) { $def = new Definition(); $def->setClass($container->getParameter('agentsib_sphinx.connection.class')); $params = array('host' => $values['host'], 'port' => $values['port']); if ($values['socket']) { $params['socket'] = $values['socket']; } $def->setArguments(array($name, $values['driver'], $params)); $def->addMethodCall('addLogger', array(new Reference('agentsib_sphinx.logger'))); $container->setDefinition(sprintf('agentsib_sphinx.%s.connection', $name), $def); $helperDef = new DefinitionDecorator('agentsib_sphinx.factory.helper'); $helperDef->setFactoryClass($container->getParameter('agentsib_sphinx.helper.class')); $helperDef->setFactoryMethod('create'); $helperDef->addArgument(new Reference(sprintf('agentsib_sphinx.%s.connection', $name))); $helperDef->setPublic(true); $container->setDefinition(sprintf('agentsib_sphinx.%s.helper', $name), $helperDef); if ($name == $config['default_connection']) { $container->setAlias('agentsib_sphinx.connection', sprintf('agentsib_sphinx.%s.connection', $name)); $container->setAlias('agentsib_sphinx.helper', sprintf('agentsib_sphinx.%s.helper', $name)); } } }
public function it_should_not_override_default_theme_factory(ContainerBuilder $container, Definition $definition) { $container->hasDefinition('sylius.factory.theme')->willReturn(false); $container->getDefinition('sylius.factory.theme')->shouldNotBeCalled(); $definition->setClass(ThemeFactory::class)->shouldNotBeCalled(); $this->process($container)->shouldReturn(null); }
public function notify(\Exception $exception) { if (!$exception instanceof ServiceNotFoundException) { return; } $serviceId = $exception->getId(); $guessedFqcn = $this->guessFqcn($serviceId); $definition = new Definition(); $definition->setClass($guessedFqcn); $containerBuilder = new ContainerBuilder(); $containerBuilder->addDefinitions([$serviceId => $definition]); $dumper = new YamlDumper($containerBuilder); $result = $dumper->dump(); $message = sprintf('Service `%s` missing. Define it in your services.yml:', $serviceId); $this->output->writeln('--- ' . $message . PHP_EOL); $this->output->write($result, true); $errorMessages = ['Service ' . $serviceId . ' was not found.']; $formatter = new FormatterHelper(); $formattedBlock = $formatter->formatBlock($errorMessages, 'error', true); $this->output->writeln(''); $this->output->writeln($formattedBlock); $this->output->writeln(''); $question = sprintf('<question>Do you want to create a specification for %s? (Y/n)</question>', $guessedFqcn); $dialog = new DialogHelper(); if ($dialog->askConfirmation($this->output, $question, true)) { $this->specRunner->runDescCommand($guessedFqcn); } }
public function testDumpOptimizationString() { $definition = new Definition(); $definition->setClass('stdClass'); $definition->addArgument(array( 'only dot' => '.', 'concatenation as value' => '.\'\'.', 'concatenation from the start value' => '\'\'.', '.' => 'dot as a key', '.\'\'.' => 'concatenation as a key', '\'\'.' =>'concatenation from the start key', 'optimize concatenation' => "string1%some_string%string2", 'optimize concatenation with empty string' => "string1%empty_value%string2", 'optimize concatenation from the start' => '%empty_value%start', 'optimize concatenation at the end' => 'end%empty_value%', )); $container = new ContainerBuilder(); $container->setDefinition('test', $definition); $container->setParameter('empty_value', ''); $container->setParameter('some_string', '-'); $container->compile(); $dumper = new PhpDumper($container); $this->assertStringEqualsFile(self::$fixturesPath.'/php/services10.php', $dumper->dump(), '->dump() dumps an empty container as an empty PHP 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); }
public function testProviderIsAdded() { $targetService = new Definition(); $targetService->setClass('Faker\\Generator'); $provider = $this->getMock('Acme\\Faker\\Provider\\CustomFakeDataProvider'); $providerService = new Definition(); $providerService->setClass(get_class($provider)); $providerService->addTag('bazinga_faker.provider'); $builder = new ContainerBuilder(); $builder->addDefinitions(array('faker.generator' => $targetService, 'acme.faker.provider.custom' => $providerService)); $builder->addCompilerPass(new AddProvidersPass()); $builder->compile(); $this->assertNotEmpty($builder->getServiceIds(), 'The services have been injected.'); $this->assertNotEmpty($builder->get('faker.generator'), 'The faker.generator service has been injected.'); $this->assertNotEmpty($builder->get('acme.faker.provider.custom'), 'The provider service has been injected.'); /* * Schema: * * [0] The list of methods. * [0] The name of the method to call. * [1] The arguments to pass into the method call. * [0] First argument to pass into the method call. * ... */ $targetMethodCalls = $builder->getDefinition('faker.generator')->getMethodCalls(); $this->assertNotEmpty($targetMethodCalls, 'The faker.generator service got method calls added.'); $this->assertEquals('addProvider', $targetMethodCalls[0][0], 'The faker.generator service got a provider added.'); $this->assertEquals('acme.faker.provider.custom', $targetMethodCalls[0][1][0], 'The faker.generator service got the correct provider added.'); }
/** * Compiles the $id service's $definition with all the aspects provided. * * @param string $id * @param \Symfony\Component\DependencyInjection\Definition $definition */ protected function compileDefinition($id, Definition $definition) { $refClass = new ReflectionClass($definition->getClass()); $aspectGenerator = new AspectGenerator($this->annotationReader, $this->annotationClassName); if ($aspectGenerator->hasAnnotation($refClass)) { $pg = new ProxyGenerator($refClass, array($aspectGenerator)); $filename = $this->proxyDirectory . '/' . str_replace('\\', '-', $refClass->name) . '.php'; $pg->writeClass($filename); $definition->setClass($pg->getClassName($refClass)); $definition->setFile($filename); $definition->setClass($pg->getClassName($refClass)); foreach ($this->serviceNames as $serviceName) { $definition->addArgument(new Reference($serviceName)); } } }
public function it_should_not_override_default_theme_assets_installer(ContainerBuilder $container, Definition $definition) { $container->hasDefinition('sylius.theme.asset.assets_installer')->willReturn(false); $container->getDefinition('sylius.theme.asset.assets_installer')->shouldNotBeCalled(); $definition->setClass(AssetsInstaller::class)->shouldNotBeCalled(); $this->process($container)->shouldReturn(null); }
protected function registerResponseListener(ContainerBuilder $container) { $definition = new Definition(); $definition->setClass($container->getParameter('xsolve.cookie_acknowledgement_bar.event_listener.class')); $definition->addArgument(new Reference('xsolve.cookie_acknowledgement_bar.service')); $definition->addTag('kernel.event_listener', array('event' => 'kernel.response', 'method' => 'onKernelResponse')); $container->setDefinition('xsolve.cookie_acknowledgement_bar.event_listener', $definition); }
/** * Build the listener that published messages to the queue. * * @param ContainerBuilder $container * @param string $id * * @return void */ protected function addToEventBus(ContainerBuilder $container, $id) { $target = $container->getDefinition('broadway.event_handling.event_bus'); $definition = new Definition(); $definition->setClass('Simgroep\\EventSourcing\\EventHandling\\PublishMessageToQueue'); $definition->setArguments(array(new Reference($id))); $target->addMethodCall('subscribe', array($definition)); }
/** * @expectedException \LogicException */ public function testInvalidProcessorNotConnected() { $def = new Definition('error_handler.test.processor'); $def->setClass(get_class(new InvalidProcessor())); $def->addTag('error_handler.processor'); $this->container->setDefinition('error_handler.test.processor', $def); $this->container->compile(); }
private function buildReader() { if (!$this->container->hasDefinition('annotation_reader')) { $readerDefinition = new Definition(); $readerDefinition->setClass(get_class(new AnnotationReader())); $this->container->setDefinition('annotation_reader', $readerDefinition); } }
/** * {@inheritdoc} */ protected function processReferences($connectionServiceId, array $referencesConfig, ContainerBuilder $container) { foreach ($referencesConfig as $key => $value) { $referenceDefinition = new Definition(); $referenceDefinition->setClass('Kreait\\Firebase\\Reference'); $referenceDefinition->setArguments(array(new Reference($connectionServiceId), $value)); $container->setDefinition('kreait_firebase.reference.' . $key, $referenceDefinition); } }
/** * {@inheritdoc} * * Rewrites previous service definitions in order to force the dumped container to use * dynamic configuration parameters. Technique may vary depending on the target service * (see for example https://github.com/opensky/OpenSkyRuntimeConfigBundle). * * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { //pdf $pdf = new Definition(); $pdf->setFactory(array(new Reference('claroline.pdf_generator_factory'), 'getPdfCreator')); $pdf->setClass('Knp\\Snappy\\Pdf'); $container->removeDefinition('knp_snappy.pdf.internal_generator'); $container->setDefinition('knp_snappy.pdf.internal_generator', $pdf); }
public function testAddService() { $service = new Definition(); $service->setClass('Acme\\DemoBundle\\Controller\\CommentController'); $service->addTag('radrest.controller', array('resource' => 'comment')); $this->manipulator->addService('acme.demo.comment.controller', $service); $this->manipulator->write(); $this->assertXmlFileEqualsXmlFile(vfsStream::url('root/results/testAddService.xml'), vfsStream::url('root/services.xml')); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if ($container->hasDefinition('doctrine.dbal.default_connection')) { $definition = new Definition(); $definition->setClass(DoctrineDbalExecutor::class)->setArguments(array(new Reference('doctrine.dbal.default_connection')))->setPublic(false); $definition->addTag('run_open_code.query_resources_loader.executor', array('name' => 'doctrine_dbal_default_connection_executor')); $container->setDefinition('run_open_code.query_resources_loader.executor.doctrine_dbal_default_connection_executor', $definition); } }
/** * creates and registeres a classmap service definition * * @param ContainerBuilder $container * @param array $config * @return Definition * @author Daniel Wendlandt */ private function createClassMapDefinition(ContainerBuilder $container, array $config) { $classMapDef = new Definition(); $classMapDef->setPublic(false); $classMapDef->setClass($container->getParameter('elastification_php_client.repository.classmap.class')); $classMapDef->setArguments(array($config['elasticsearch_version'])); $container->setDefinition(ElastificationPhpClientExtension::SERVICE_REPOSITORY_CLASSMAP, $classMapDef); return $classMapDef; }
/** * @param ContainerBuilder $container * @param $config */ private function setMappings(ContainerBuilder $container, $config) { $definition = new Definition(); $definition->setClass('NilPortugues\\Api\\Mapping\\Mapper'); $args = $this->resolveMappings($container, $config['mappings']); $definition->setArguments($args); $definition->setLazy(true); $container->setDefinition('nil_portugues.api.mapping.mapper', $definition); }
protected function createContainer() { $container = new ContainerBuilder(); $container->set('array_iterator', new \ArrayIterator(range(1, 5))); $definition = new Definition(); $definition->setClass(__NAMESPACE__ . '\\Fixture\\SymfonyRecursiveObject'); $definition->addArgument(new Reference('error')); $container->setDefinition('error', $definition); return new SymfonyContainerAdapter($container); }
public function testRegisterTaggedQueryType() { $def = new Definition(); $def->addTag('ezpublish.query_type'); $def->setClass('eZ\\Bundle\\EzPublishCoreBundle\\Tests\\DependencyInjection\\Stub\\QueryTypeBundle\\QueryType\\TestQueryType'); $serviceId = 'test.query_type'; $this->setDefinition($serviceId, $def); $this->compile(); $this->assertContainerBuilderHasServiceDefinitionWithMethodCall('ezpublish.query_type.registry', 'addQueryTypes', [['Test:Test' => new Reference($serviceId)]]); }
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; }
private function getNestedServices() { $service = new Definition(); $service->setClass('stdClass'); $service1 = new Definition(); $service1->setClass('stdClass'); $service1->setArguments(array(new Reference('arg.one'), new Reference('arg.two', ContainerInterface::IGNORE_ON_INVALID_REFERENCE), new Reference('arg.three', ContainerInterface::NULL_ON_INVALID_REFERENCE), 'arg.four')); $service->addArgument($service1); return new ServiceElement('service.one', $service); }
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; }
/** * You can modify the container here before it is dumped to PHP code. * * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { $definition = new Definition(); $db = $container->getParameter('api_images.config.platform'); switch ($db) { case 'orm': $definition->setClass(ORMProvider::class); $definition->addArgument(new Reference('doctrine.orm.entity_manager')); break; case 'odm': $definition->setClass(ODMProvider::class); $definition->addArgument(new Reference('doctrine_mongodb.odm.document_manager')); break; } $definition->addArgument(new Reference('validator')); $definition->addArgument(new Reference('api_images.loader')); $definition->addArgument(new Reference('request_stack')); $container->setDefinition('api_images.provider', $definition); }