Adds the service definitions.
public addDefinitions ( array $definitions ) | ||
$definitions | array | An array of service definitions |
/** * @param \Symfony\Component\DependencyInjection\ContainerBuilder $container * @param \Doctrine\Common\Annotations\AnnotationReader $annotationReader * @param \FSi\Bundle\AdminBundle\Finder\AdminClassFinder $adminClassFinder */ function it_registers_annotated_admin_classes_as_services($container, $annotationReader, $adminClassFinder) { $container->getParameter('kernel.bundles')->willReturn(array('FSi\\Bundle\\AdminBundle\\spec\\fixtures\\MyBundle', 'FSi\\Bundle\\AdminBundle\\FSiAdminBundle', 'Symfony\\Bundle\\FrameworkBundle\\FrameworkBundle')); $baseDir = __DIR__ . '/../../../../../..'; $adminClassFinder->findClasses(array(realpath($baseDir . '/spec/fixtures/Admin'), realpath($baseDir . '/Admin')))->willReturn(array('FSi\\Bundle\\AdminBundle\\spec\\fixtures\\Admin\\SimpleAdminElement', 'FSi\\Bundle\\AdminBundle\\spec\\fixtures\\Admin\\CRUDElement')); $annotationReader->getClassAnnotation(Argument::allOf(Argument::type('ReflectionClass'), Argument::which('getName', 'FSi\\Bundle\\AdminBundle\\spec\\fixtures\\Admin\\CRUDElement')), 'FSi\\Bundle\\AdminBundle\\Annotation\\Element')->willReturn(null); $annotationReader->getClassAnnotation(Argument::allOf(Argument::type('ReflectionClass'), Argument::which('getName', 'FSi\\Bundle\\AdminBundle\\spec\\fixtures\\Admin\\SimpleAdminElement')), 'FSi\\Bundle\\AdminBundle\\Annotation\\Element')->willReturn(new Element(array())); $container->addResource(Argument::allOf(Argument::type('Symfony\\Component\\Config\\Resource\\DirectoryResource'), Argument::which('getResource', realpath($baseDir . '/spec/fixtures/Admin')), Argument::which('getPattern', '/\\.php$/')))->shouldBeCalled(); $container->addResource(Argument::allOf(Argument::type('Symfony\\Component\\Config\\Resource\\DirectoryResource'), Argument::which('getResource', realpath($baseDir . '/Admin')), Argument::which('getPattern', '/\\.php$/')))->shouldBeCalled(); $container->addDefinitions(Argument::that(function ($definitions) { if (count($definitions) !== 1) { return false; } /** @var \Symfony\Component\DependencyInjection\Definition $definition */ $definition = $definitions[0]; if ($definition->getClass() !== 'FSi\\Bundle\\AdminBundle\\spec\\fixtures\\Admin\\SimpleAdminElement') { return false; } if (!$definition->hasTag('admin.element')) { return false; } return true; }))->shouldBeCalled(); $this->process($container); }
public function process(ContainerBuilder $container) { // Cache warmer does more harm than good with Drupal. if ($container->hasDefinition('cache_warmer')) { $container->removeDefinition('cache_warmer'); } if ($container->hasAlias('cache_warmer')) { $container->removeAlias('cache_warmer'); } // When not working with symfony, we need to provide a file locator // service of our own instead of the symfony's one if (!$container->hasDefinition('file_locator') && !$container->hasAlias('file_locator')) { $container->addDefinitions(['file_locator' => (new Definition())->setClass(CustomFileLocator::class)->addArgument(new Reference('kernel'))]); } else { // We are working with fullstack, and our users might have changed // the global resource directory to somewhere safer than Drupal's // sites/SITE folder, case in which we must honnor the user's // configuration $definition = $container->getDefinition('file_locator'); $definition->setArguments([new Reference('kernel'), $container->getParameter('kernel.root_dir') . '/Resources']); } // By registering the framework bundle, we also inherit from Symfony // default URL generator, which will cause us great pain because of // Drupal routes will not be known by the framework and throw a few // exceptions. if ($container->has('router.default')) { $container->getDefinition('router.default')->setClass('MakinaCorpus\\Drupal\\Sf\\Routing\\Router'); } // When NOT in fullstack mode, we need to provide a null implementation // for the controller resolver service, else the container will be // unable to spawn the http kernel service if (!$container->has('controller_resolver')) { $container->addDefinitions(['controller_resolver' => (new Definition())->setClass('controller_resolver')]); } }
/** * @param array $configs * @param ContainerBuilder $container * @return void */ public function load(array $configs, ContainerBuilder $container) { $config = $this->processConfiguration(new Configuration(), $configs); $container->addDefinitions(array('rabbitmq.connection' => $this->getConnectionService($config), 'rabbitmq.channel' => $this->getChannelService(), 'rabbitmq.manager' => $this->getManagerService($config))); $container->addDefinitions($this->getExchangeServices($config['exchanges'])); $container->addDefinitions($this->getQueueServices($config['queues'])); $container->addDefinitions($this->getConsumerServices($config['consumers'])); $container->addDefinitions($this->getProducerServices($config['producers'])); }
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); } }
/** * @covers Symfony\Component\DependencyInjection\ContainerBuilder::setDefinitions * @covers Symfony\Component\DependencyInjection\ContainerBuilder::getDefinitions * @covers Symfony\Component\DependencyInjection\ContainerBuilder::setDefinition * @covers Symfony\Component\DependencyInjection\ContainerBuilder::getDefinition */ public function testDefinitions() { $builder = new ContainerBuilder(); $definitions = array( 'foo' => new Definition('FooClass'), 'bar' => new Definition('BarClass'), ); $builder->setDefinitions($definitions); $this->assertEquals($definitions, $builder->getDefinitions(), '->setDefinitions() sets the service definitions'); $this->assertTrue($builder->hasDefinition('foo'), '->hasDefinition() returns true if a service definition exists'); $this->assertFalse($builder->hasDefinition('foobar'), '->hasDefinition() returns false if a service definition does not exist'); $builder->setDefinition('foobar', $foo = new Definition('FooBarClass')); $this->assertEquals($foo, $builder->getDefinition('foobar'), '->getDefinition() returns a service definition if defined'); $this->assertTrue($builder->setDefinition('foobar', $foo = new Definition('FooBarClass')) === $foo, '->setDefinition() implements a fluid interface by returning the service reference'); $builder->addDefinitions($defs = array('foobar' => new Definition('FooBarClass'))); $this->assertEquals(array_merge($definitions, $defs), $builder->getDefinitions(), '->addDefinitions() adds the service definitions'); try { $builder->getDefinition('baz'); $this->fail('->getDefinition() throws an InvalidArgumentException if the service definition does not exist'); } catch (\InvalidArgumentException $e) { $this->assertEquals('The service definition "baz" does not exist.', $e->getMessage(), '->getDefinition() throws an InvalidArgumentException if the service definition does not exist'); } }
public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); foreach ($config as $key => $value) { $container->setParameter('migrations' . '.' . $key, $value); } $loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config')); $loader->load('services.yml'); $service = $container->getDefinition('migrations.migrator'); $migrationServices = []; foreach (new \DirectoryIterator($config['dir_name']) as $item) { if (!$item->isFile()) { continue; } $className = basename($item->getFilename(), '.php'); $migrationDefinition = new Definition($config['namespace'] . '\\' . $className); $migrationDefinition->setPublic(false); $migrationServices['migrations.migrations.' . strtolower($className)] = $migrationDefinition; } $container->addDefinitions($migrationServices); foreach (array_keys($migrationServices) as $id) { $service->addMethodCall('addMigration', [new Reference($id)]); } }
public function testProcess() { $container = new ContainerBuilder(); $simpleFactory = new Definition(); $simpleProcessor = new Definition('Test\\SimpleProcessor'); $simpleProcessor->addTag('processor'); $abstractProcessor = new Definition(); $abstractProcessor->setAbstract(true); $abstractProcessor->addTag('processor'); $lazyProcessor = new Definition('Test\\LazyProcessor'); $lazyProcessor->setLazy(true); $lazyProcessor->addTag('processor'); $withArgumentsProcessor = new Definition('Test\\WithArgumentsProcessor', ['test']); $withArgumentsProcessor->addTag('processor'); $container->addDefinitions(['simple_factory' => $simpleFactory, 'simple_processor' => $simpleProcessor, 'abstract_processor' => $abstractProcessor, 'lazy_processor' => $lazyProcessor, 'with_arguments_processor' => $withArgumentsProcessor]); $compilerPass = new CleanUpProcessorsCompilerPass('simple_factory', 'processor'); $compilerPass->process($container); $this->assertFalse($container->hasDefinition('simple_processor')); $this->assertTrue($container->hasDefinition('abstract_processor')); $this->assertTrue($container->hasDefinition('lazy_processor')); $this->assertTrue($container->hasDefinition('with_arguments_processor')); $methodCalls = $simpleFactory->getMethodCalls(); $this->assertCount(1, $methodCalls); $this->assertEquals(['addProcessor', ['simple_processor', 'Test\\SimpleProcessor']], $methodCalls[0]); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { $config = $container->getParameter(ModeraMjrIntegrationExtension::CONFIG_KEY); $def = new Definition(ConfigMenuItemsProvider::clazz(), array($config)); $def->addTag('modera_mjr_integration.menu.menu_items_provider'); $container->addDefinitions(array('modera_mjr_integration.contributions.menu_items_provider' => $def)); }
public function process(ContainerBuilder $container) { if (!$container->hasDefinition('fm_bbcode.decoda_manager')) { return; } $filters = $container->getParameter('fm_bbcode.config.filters'); $definitions = array(); foreach ($filters as $id => $class) { $definition = new Definition($class); $definition->addTag('fm_bbcode.decoda.filter', array('id' => $id)); $definitions['fm_bbcode.decoda.filter.from_config.' . $id] = $definition; } $container->addDefinitions($definitions); $definition = $container->getDefinition('fm_bbcode.decoda_manager'); $filters = array(); foreach ($container->findTaggedServiceIds('fm_bbcode.decoda.filter') as $id => $attributes) { // We must assume that the class value has been correctly filled, even if the service is created by a factory $class = $container->getDefinition($id)->getClass(); $refClass = new \ReflectionClass($class); $interface = 'Decoda\\Filter'; if (!$refClass->implementsInterface($interface)) { throw new \InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, $interface)); } $name = isset($attributes[0]['id']) ? $attributes[0]['id'] : $id; $name = strtolower($name); if (isset($filters[$name])) { throw new \InvalidArgumentException(sprintf('The hook identifier "%s" must be uniq, is already set on "%s" service.', $name, $filters[$name])); } $filters[$name] = $id; $definition->addMethodCall('setFilter', array($name, new Reference($id))); } }
/** * @inheritdoc */ public function process(ContainerBuilder $container) { $definitions = array(); $servicesIds = $container->findTaggedServiceIds('pmd_state_machine.token_configurable'); foreach ($servicesIds as $serviceId => $tag) { $group = isset($tag[0]['group']) ? $tag[0]['group'] : null; $type = isset($tag[0]['type']) ? $tag[0]['type'] : null; if (!isset($group) || !isset($type)) { throw new \InvalidArgumentException(sprintf('Services tagged %s must have group and type defined', 'pmd_state_machine.token_configurable')); } $serviceDefinition = $container->getDefinition($serviceId); $optionsId = sprintf('pmd_state_machine.behavior.%s_%s_options', $group, $type); $optionsReference = new Reference($optionsId, ContainerInterface::NULL_ON_INVALID_REFERENCE); // Configure options resolver $resolverId = sprintf('pmd_state_machine.behavior.%s_%s_resolver', $group, $type); $resolverReference = new Reference($resolverId); $resolverDefinition = new DefinitionDecorator('pmd_state_machine.behavior_resolver.token_options_resolver'); $resolverDefinition->replaceArgument(0, $optionsReference); // Configure configurable decorator $configId = sprintf('pmd_state_machine.behavior.%s_%s_configurator', $group, $type); $configDefinition = new DefinitionDecorator('pmd_state_machine.behavior.token_configurable_configurator'); $configDefinition->replaceArgument(0, $resolverReference); $serviceDefinition->setConfigurator(array(new Reference($configId, ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, false), 'configure')); $definitions[$resolverId] = $resolverDefinition; $definitions[$configId] = $configDefinition; } $container->addDefinitions($definitions); }
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.'); }
/** * You can modify the container here before it is dumped to PHP code. * * @param ContainerBuilder $container * * @api */ public function process(ContainerBuilder $container) { if ($container->has('thelia.parser')) { return; } $container->addDefinitions(['thelia.parser' => new Definition("Thelia\\Core\\Template\\Parser\\ParserFallback"), 'thelia.parser.helper' => new Definition("Thelia\\Core\\Template\\Parser\\ParserHelperFallback"), 'thelia.parser.asset.resolver' => new Definition("Thelia\\Core\\Template\\Parser\\ParserHelperFallback")]); }
private function createModelEvents(array $models, ContainerBuilder $container) { $definitions = []; foreach ($models as $modelName => $class) { $definitions[] = $this->createDefinition($modelName); } $container->addDefinitions($definitions); }
/** * {@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'); $container->addDefinitions(array('seven_onesky_client' => $this->getClientDefinition($config), 'seven_onesky_downloader' => $this->getDownloaderDefinition($config))); }
protected function configureContainer(ContainerBuilder $c, LoaderInterface $loader) { $parser = new \Symfony\Component\Yaml\Parser(); $parametersFile = file_get_contents($this->getRootDir() . DIRECTORY_SEPARATOR . 'config' . DIRECTORY_SEPARATOR . 'parameters.yml'); $parameters = $parser->parse($parametersFile); $c->loadFromExtension('framework', ['secret' => 'none']); $c->addDefinitions(['git_automation.jira_api' => $this->createJiraApiService($parameters['parameters'])]); }
/** * @expectedException \LogicException */ public function testProcessNoSignal() { $slotDef = new Definition(); $slotDef->addTag('ezpublish.api.slot', array()); $containerBuilder = new ContainerBuilder(); $containerBuilder->addDefinitions(array('acme.foo_slot' => $slotDef, 'ezpublish.signalslot.signal_dispatcher' => new Definition())); $pass = new SignalSlotPass(); $pass->process($containerBuilder); }
public function testRegisterCommandHandlers() { $definition = new Definition('stdClass', ['', []]); $container = new ContainerBuilder(); $container->addDefinitions(['seven_service_bus.self_binding' => $definition, 'foo' => $this->getTaggedService('service_binding', ['topic' => 'foo_topic', 'version' => '0', 'method' => 'foo_method']), 'bar' => $this->getTaggedService('service_binding', ['topic' => 'bar_topic']), 'baz' => $this->getTaggedService('service_binding', ['version' => '0', 'method' => 'baz_method'])]); $this->process($container); $calls = $definition->getMethodCalls(); $this->assertEquals([['on', ['foo_topic', '0', 'foo', 'foo_method']], ['on', ['bar_topic', null, 'bar', null]]], $calls); }
/** * @param ContainerBuilder $container * @param string $routingLoaderServiceId * @param string $annotationReaderArgumentId */ protected function replaceAnnotationReader(ContainerBuilder $container, $routingLoaderServiceId, $annotationReaderArgumentId) { $routingLoaderDef = $container->getDefinition($routingLoaderServiceId); $annotationReaderServiceId = $routingLoaderServiceId . self::ANNOTATION_READER_SERVICE_SUFFIX; $annotationReaderDef = new Definition(self::ANNOTATION_READER_CLASS, [$routingLoaderDef->getArgument($annotationReaderArgumentId)]); $annotationReaderDef->setPublic(false); $container->addDefinitions([$annotationReaderServiceId => $annotationReaderDef]); $routingLoaderDef->replaceArgument($annotationReaderArgumentId, new Reference($annotationReaderServiceId)); }
/** * @param array $definitions * @return array */ protected function processDefinitions(array $definitions) { $services = array(); foreach ($definitions as $name => $definition) { $builderName = sprintf('pmd_state_machine.%s_process_builder', $name); $processName = sprintf('pmd_state_machine.%s_process', $name); $coordinatorName = sprintf('pmd_state_machine.%s_coordinator', $name); $builder = $this->getBuilderDefinition($name); $process = $this->getProcessDefinition($builderName, $name); $coordinator = $this->getCoordinatorDefinition($processName, $name); $this->processStates($builder, $definition['states']); $this->processTransitions($builder, $definition['transitions']); $this->processBehaviors($name, $definition['behaviors']); $services[$builderName] = $builder; $services[$processName] = $process; $services[$coordinatorName] = $coordinator; } $this->container->addDefinitions($services); }
/** * @return ContainerBuilder */ private function prebuildContainer() { $container = new ContainerBuilder(); $dispatcher = new Definition('Symfony\\Component\\EventDispatcher\\EventDispatcher'); $container->addDefinitions(['event_dispatcher' => $dispatcher]); $extension = new KGzochaSearcherExtension(); $container->registerExtension($extension); $extension->load([], $container); return $container; }
public function testProcessWithInvalidConfigurationOfCommonProcessor() { $container = new ContainerBuilder(); $processorBag = new Definition('Test\\ProcessorBag'); $processor1 = new Definition('Test\\Processor2'); $processor1->addTag('processor', ['group' => 'group1']); $container->addDefinitions(['processor_bag' => $processorBag, 'processor1' => $processor1]); $compilerPass = new LoadProcessorsCompilerPass('processor_bag', 'processor', 'applicable_checker'); $compilerPass->process($container); }
/** * @inheritDoc() * * @codeCoverageIgnore */ public function process(ContainerBuilder $container) { $parameterKey = $this->getParameterKey(); if (!$container->hasParameter($parameterKey)) { return; } $configurations = $container->getParameterBag()->resolveValue($container->getParameter($parameterKey)); $definitions = $this->getDefinitions($configurations); $container->addDefinitions($definitions); }
public function process(ContainerBuilder $container) { if (!$container->hasDefinition('ezpublish.query_type.registry')) { return; } $queryTypes = []; $queryTypesClasses = []; // tagged query types $taggedServiceIds = $container->findTaggedServiceIds('ezpublish.query_type'); foreach ($taggedServiceIds as $taggedServiceId => $tags) { $queryTypeDefinition = $container->getDefinition($taggedServiceId); $queryTypeClass = $container->getParameterBag()->resolveValue($queryTypeDefinition->getClass()); $queryTypesClasses[$queryTypeClass] = []; for ($i = 0, $count = count($tags); $i < $count; ++$i) { $name = isset($tags[$i]['alias']) ? $tags[$i]['alias'] : $queryTypeClass::getName(); $queryTypes[$name] = new Reference($taggedServiceId); $queryTypesClasses[$queryTypeClass][$name] = true; } } // named by convention query types if ($container->hasParameter('kernel.bundles')) { foreach ($container->getParameter('kernel.bundles') as $bundleName => $bundleClass) { $bundleReflectionClass = new ReflectionClass($bundleClass); $bundleDir = dirname($bundleReflectionClass->getFileName()); $bundleQueryTypesDir = $bundleDir . DIRECTORY_SEPARATOR . 'QueryType'; if (!is_dir($bundleQueryTypesDir)) { continue; } $queryTypeServices = []; $bundleQueryTypeNamespace = substr($bundleClass, 0, strrpos($bundleClass, '\\') + 1) . 'QueryType'; foreach (glob($bundleQueryTypesDir . DIRECTORY_SEPARATOR . '*QueryType.php') as $queryTypeFilePath) { $queryTypeFileName = basename($queryTypeFilePath, '.php'); $queryTypeClassName = $bundleQueryTypeNamespace . '\\' . $queryTypeFileName; if (!class_exists($queryTypeClassName)) { throw new Exception("Expected {$queryTypeClassName} to be defined in {$queryTypeFilePath}"); } $queryTypeName = $queryTypeClassName::getName(); // skip if the class was already registered as a tagged service with the same name if (isset($queryTypesClasses[$queryTypeClassName][$queryTypeName])) { continue; } $queryTypeReflectionClass = new ReflectionClass($queryTypeClassName); if (!$queryTypeReflectionClass->implementsInterface('eZ\\Publish\\Core\\QueryType\\QueryType')) { throw new Exception("{$queryTypeClassName} needs to implement eZ\\Publish\\Core\\QueryType\\QueryType"); } $serviceId = 'ezpublish.query_type.convention.' . strtolower($bundleName) . '_' . strtolower($queryTypeFileName); $queryTypeServices[$serviceId] = new Definition($queryTypeClassName); $queryTypes[$queryTypeName] = new Reference($serviceId); } $container->addDefinitions($queryTypeServices); } } $aggregatorDefinition = $container->getDefinition('ezpublish.query_type.registry'); $aggregatorDefinition->addMethodCall('addQueryTypes', [$queryTypes]); }
/** * {@inheritdoc} */ public function load(array $configs, ContainerBuilder $container) { $configuration = new Configuration(); $config = $this->processConfiguration($configuration, $configs); // sources $sources = []; if (array_key_exists('sources', $config) && is_array($config['sources'])) { foreach ($config['sources'] as $sourceName => $sourceNamespace) { $sourceName = Standard::normalizeName($sourceName); if (!$sourceName) { throw new \Exception('Empty source name'); } $sourceNamespace = Standard::normalizeNamespace($sourceNamespace); if (!$sourceNamespace) { throw new \Exception(sprintf('Empty source "%s" namespace', $sourceName)); } $sources[$sourceName] = $sourceNamespace; } } // targets $targets = []; if (array_key_exists('targets', $config) && is_array($config['targets'])) { foreach ($config['targets'] as $targetName => $targetData) { $targetName = Standard::normalizeName($targetName); if (!array_key_exists('namespace', $targetData)) { throw new \Exception(sprintf('Namespace of target "%s" is not set', $targetName)); } $targetData['namespace'] = Standard::normalizeNamespace($targetData['namespace']); if (!$targetData['namespace']) { throw new \Exception(sprintf('Empty target "%s" namespace', $targetName)); } $targetData['name'] = $targetName; $targets[] = ['name' => $targetName, 'namespace' => $targetData['namespace'], 'withAnnotations' => array_key_exists('annotations', $targetData) && $targetData['annotations'], 'useClassNotations' => array_key_exists('class_notations', $targetData) && $targetData['class_notations'], 'withInitFunction' => array_key_exists('init_function', $targetData) && $targetData['init_function']]; } } // Addind to container $container->setParameter('leoza.entities_sources', $sources); $container->setParameter('leoza.entities_targets', $targets); // Adding definitions $definitions = []; $definition = new Definition('Leoza\\EntitiesBundle\\Twig\\EntityGeneratorTwigExtension'); $definition->setPublic(false)->addTag('twig.extension'); $definitions[] = $definition; $srcDir = realpath($container->getParameter('kernel.root_dir') . '/../src'); foreach ($sources as $sourceName => $sourceNamespace) { /* @var $source array */ $definition = new Definition('Leoza\\EntitiesBundle\\EntityGenerator', [new Reference('logger'), $srcDir, new Reference('templating'), new Reference('annotation_reader'), $sourceNamespace, "%leoza.entities_targets%"]); $definition->addTag('monolog.logger', ['channel' => 'leoza']); $definitions['leoza.entity_generator.' . $sourceName] = $definition; $definition = new Definition('Leoza\\EntitiesBundle\\EntityManager', [new Reference('logger'), $sourceNamespace, "%leoza.entities_targets%"]); $definitions['leoza.entity_manager.' . $sourceName] = $definition; $definition->addTag('monolog.logger', ['channel' => 'leoza']); } $container->addDefinitions($definitions); }
/** * @expectedException \RuntimeException */ public function testProcessWhereFactoryThereAndBadTag() { $container = new ContainerBuilder(); $recognizer1 = new Definition(); $recognizer1->addTag('giftcards.fixed_width.record_spec_recognizer', array('spec_name' => 'spec1')); $recognizer2 = new Definition(); $recognizer2->addTag('giftcards.fixed_width.record_spec_recognizer'); $service = new Definition(); $container->addDefinitions(array('giftcards.fixed_width.file_factory' => new Definition(), 'rec1' => $recognizer1, 'rec2' => $recognizer2, 'serv' => $service)); $this->pass->process($container); }
/** * @return ContainerBuilder */ private function createBuilder() { $definition1 = $this->getMock(Definition::class); $definition2 = clone $definition1; $builder = new ContainerBuilder(); $builder->addDefinitions([$definition1, $definition2]); $definition1->expects($this->any())->method('getClass')->willReturn(__CLASS__); $definition2->expects($this->any())->method('getClass')->willReturn(ContainerAwareClass::class); $definition1->expects($this->never())->method('addMethodCall'); $definition2->expects($this->once())->method('addMethodCall'); return $builder; }
/** * @param ContainerBuilder $container */ public function process(ContainerBuilder $container) { if ($container->getParameterBag()->has('mock_janus_client_entity_manager')) { $emServiceName = $container->getParameter('doctrine.orm.default_entity_manager'); } else { $emServiceName = 'doctrine.orm.default_entity_manager'; } $container->addDefinitions(['ice.janus_client.doctrine_mock_of_guzzle_client' => new Definition('Ice\\DoctrineMockOfJanusClientBundle\\MockClient\\MockGuzzleClient', [new Reference($emServiceName)])]); $definition = $container->getDefinition('janus.client'); $constructorArguments = $definition->getArguments(); $constructorArguments[0] = new Reference('ice.janus_client.doctrine_mock_of_guzzle_client'); $definition->setArguments($constructorArguments); }
public function testProcess() { $visitorDefinition = new Definition(); $visitorDefinition->addTag('ezpublish_rest.input.parser', array('mediaType' => 'application/vnd.ez.api.UnitTest')); $containerBuilder = new ContainerBuilder(); $containerBuilder->addDefinitions(array('ezpublish_rest.input.parsing_dispatcher' => new Definition(), 'ezpublish_rest.input.parser.UnitTest' => $visitorDefinition)); $compilerPass = new InputParserPass(); $compilerPass->process($containerBuilder); $dispatcherMethodCalls = $containerBuilder->getDefinition('ezpublish_rest.input.parsing_dispatcher')->getMethodCalls(); self::assertTrue(isset($dispatcherMethodCalls[0][0]), "Failed asserting that dispatcher has a method call"); self::assertEquals('addParser', $dispatcherMethodCalls[0][0], "Failed asserting that called method is 'addParser'"); self::assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $dispatcherMethodCalls[0][1][1], "Failed asserting that method call is to a Reference object"); self::assertEquals('ezpublish_rest.input.parser.unittest', $dispatcherMethodCalls[0][1][1]->__toString(), "Failed asserting that Referenced service is 'ezpublish_rest.input.parser.UnitTest'"); }
public function testProcess() { $visitorDefinition = new Definition(); $visitorDefinition->addTag('ezpublish_rest.output.value_object_visitor', array('type' => 'test')); $containerBuilder = new ContainerBuilder(); $containerBuilder->addDefinitions(array('ezpublish_rest.output.value_object_visitor.dispatcher' => new Definition(), 'ezpublish_rest.output.value_object_visitor.test' => $visitorDefinition)); $compilerPass = new ValueObjectVisitorPass(); $compilerPass->process($containerBuilder); $dispatcherMethodCalls = $containerBuilder->getDefinition('ezpublish_rest.output.value_object_visitor.dispatcher')->getMethodCalls(); self::assertTrue(isset($dispatcherMethodCalls[0][0]), 'Failed asserting that dispatcher has a method call'); self::assertEquals('addVisitor', $dispatcherMethodCalls[0][0], "Failed asserting that called method is 'addVisitor'"); self::assertInstanceOf('Symfony\\Component\\DependencyInjection\\Reference', $dispatcherMethodCalls[0][1][1], 'Failed asserting that method call is to a Reference object'); self::assertEquals('ezpublish_rest.output.value_object_visitor.test', $dispatcherMethodCalls[0][1][1]->__toString(), "Failed asserting that Referenced service is 'ezpublish_rest.output.value_object_visitor.test'"); }
public function testProcess() { $container = new ContainerBuilder(); $nonInterfaceListener = new NonInterfaceListener(); $nonInterfaceListenerDefinition = new Definition(get_class($nonInterfaceListener)); $nonInterfaceListenerDefinition->addTag('doctrine.event_listener'); $nonInterfaceSubscriber = new NonInterfaceListener(); $nonInterfaceSubscriberDefinition = new Definition(get_class($nonInterfaceSubscriber)); $nonInterfaceSubscriberDefinition->addTag('doctrine.event_subscriber'); $testListener = new TestListener(); $testListenerDefinition = new Definition(get_class($testListener)); $testListenerDefinition->addTag('doctrine.event_listener'); $testSubscriber = new TestListener(); $testSubscriberDefinition = new Definition(get_class($testSubscriber)); $testSubscriberDefinition->addTag('doctrine.event_subscriber'); $container->addDefinitions(['test.non_interface_listener' => $nonInterfaceListenerDefinition, 'test.non_interface_subscriber' => $nonInterfaceSubscriberDefinition, 'test.listener' => $testListenerDefinition, 'test.subscriber' => $testSubscriberDefinition]); $managerDefinition = new Definition(); $managerDefinition->addArgument([]); $container->addDefinitions([OptionalListenersCompilerPass::OPTIONAL_LISTENER_MANAGER => $managerDefinition]); $compiler = new OptionalListenersCompilerPass(); $compiler->process($container); $this->assertEquals(['test.listener', 'test.subscriber'], $managerDefinition->getArgument(0)); }