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