public function process(ContainerBuilder $container) { if (!($container->hasDefinition('fragment.listener') && $container->hasDefinition('ezpublish.decorated_fragment_renderer'))) { return null; } $fragmentListenerDef = $container->findDefinition('fragment.listener'); $fragmentListenerDef->setFactoryService('ezpublish.fragment_listener.factory')->setFactoryMethod('buildFragmentListener')->addArgument('%fragment.listener.class%'); // Looping over all fragment renderers to decorate them // This is to make sure they are siteaccess aware (siteaccess is serialized in rendered path). foreach ($container->findTaggedServiceIds('kernel.fragment_renderer') as $id => $attributes) { $renamedId = "{$id}.inner"; $definition = $container->getDefinition($id); $public = $definition->isPublic(); $tags = $definition->getTags(); $definition->setPublic(false); $container->setDefinition($renamedId, $definition); $decoratedDef = new DefinitionDecorator('ezpublish.decorated_fragment_renderer'); $decoratedDef->setArguments(array(new Reference($renamedId))); $decoratedDef->setPublic($public); $decoratedDef->setTags($tags); // Special treatment for inline fragment renderer, to fit ESI renderer constructor type hinting (forced to InlineFragmentRenderer) if ($id === 'fragment.renderer.inline') { $decoratedDef->setClass($container->getParameter('ezpublish.decorated_fragment_renderer.inline.class')); } $container->setDefinition($id, $decoratedDef); } }
private function createConverter($name, array $config, ContainerBuilder $container) { $environment = new DefinitionDecorator($config['environment']); $environment->setPublic(false); $environment->setClass($container->getDefinition($config['environment'])->getClass()); $environment->addMethodCall('mergeConfig', [$config['config']]); $environment->addTag('webuni_commonmark.environment.extensions', $config['extensions']); // $environment->addTag('webuni_commonmark.environment', ['parent' => $config['environment'], 'extensions' => [$config['extensions']]); $environmentName = 'webuni_commonmark.' . $name . '_environment' . $config['environment']; $container->setDefinition($environmentName, $environment); $parser = new DefinitionDecorator($config['parser']); $parser->setPublic(false); $parser->setClass($container->getDefinition($config['parser'])->getClass()); $parser->replaceArgument(0, new Reference($environmentName)); $renderer = new DefinitionDecorator($config['renderer']); $renderer->setPublic(false); $renderer->setClass($container->getDefinition($config['renderer'])->getClass()); $renderer->replaceArgument(0, new Reference($environmentName)); $converter = new DefinitionDecorator($config['converter']); $converter->setPublic(true); $converter->setClass($container->getDefinition($config['converter'])->getClass()); $converter->replaceArgument(0, $parser); $converter->replaceArgument(1, $renderer); $converterName = 'webuni_commonmark.' . $name . '_converter'; $container->setDefinition($converterName, $converter); return $converterName; }
/** * @inheritdoc */ public function process(ContainerBuilder $container) { if (!$container->hasDefinition('qimnet.crud.configuration.repository')) { return; } $repository = $container->getDefinition('qimnet.crud.configuration.repository'); $defaults = $container->getParameter('qimnet.crud.defaults'); foreach ($container->getParameter('qimnet.crud.services') as $name => $configuration) { $options = $configuration['options'] + array('name' => $name) + $defaults['options']; $configuration = $configuration + $defaults; $serviceId = 'qimnet.crud.configuration.' . strtolower($name); $definition = new DefinitionDecorator('qimnet.crud.configuration'); foreach (array('object_manager_factory', 'security_context_factory', 'path_generator_factory') as $index => $key) { if ($configuration[$key]) { $definition->replaceArgument($index, new Reference($configuration[$key])); } } $definition->addArgument($options); if ($configuration['class']) { $definition->setClass($configuration['class']); } $definition->addTag('qimnet.crud.configuration', array('alias' => $name, 'object_class' => $options['object_class'], 'worker' => $configuration['worker'], 'redirection_manager' => $configuration['redirection_manager'])); $container->setDefinition($serviceId, $definition); } $taggedServices = $container->findTaggedServiceIds('qimnet.crud.configuration'); foreach ($taggedServices as $id => $attributes) { $repository->addMethodCall('add', array($attributes[0]['alias'], $attributes[0]['object_class'], $id, $attributes[0]['worker'], $attributes[0]['redirection_manager'])); } }
public function testMenu() { $definition = new DefinitionDecorator('lug.ui.menu.builder'); $definition->setClass($class = $this->createMenuBuilderClassMock()); $this->container->setDefinition($menuName = 'lug.ui.menu.test', $definition); $this->compileContainer(); $this->assertInstanceOf($class, $this->container->get($menuName)); }
private function registerPayloadResolver(ContainerBuilder $container) { $definition = new Definition(PayloadResolver::class); $definition->setAbstract(true); $container->setDefinition('request_object.payload_resolver', $definition); $implDefinition = new DefinitionDecorator('request_object.payload_resolver'); $implDefinition->setClass(HttpPayloadResolver::class); $container->setDefinition('request_object.payload_resolver.http', $implDefinition); }
/** * @param ContainerBuilder $container * @param string $name * @param string $options */ private function setupProviderService(ContainerBuilder $container, $name, $options) { $type = $options['type']; unset($options['type']); $container->setParameter("vss_oauth_extension.providers.{$name}.client_id", $options['client_id']); $definition = new DefinitionDecorator('vss_oauth_extension.providers.generic.oauth2'); $definition->setClass("%vss_oauth_extension.providers.{$type}.class%"); $container->setDefinition('vss_oauth_extension.providers.' . $name, $definition); $definition->replaceArgument(1, $options)->replaceArgument(2, $name); }
/** * Converts class hierarchy metadata to definition instances. * * @param ClassHierarchyMetadata $metadata * @return array an array of Definition instances */ public function convert(ClassHierarchyMetadata $metadata) { static $count = 0; $definitions = array(); $previous = null; foreach ($metadata->classMetadata as $classMetadata) { if (null === $previous && null === $classMetadata->parent) { $definition = new Definition(); } else { $definition = new DefinitionDecorator($classMetadata->parent ?: $previous->id); } $definition->setClass($classMetadata->name); if (null !== $classMetadata->scope) { $definition->setScope($classMetadata->scope); } if (null !== $classMetadata->public) { $definition->setPublic($classMetadata->public); } if (null !== $classMetadata->abstract) { $definition->setAbstract($classMetadata->abstract); } if (null !== $classMetadata->lazy) { $definition->setLazy($classMetadata->lazy); } if (null !== $classMetadata->arguments) { $definition->setArguments($classMetadata->arguments); } $definition->setMethodCalls($classMetadata->methodCalls); $definition->setTags($classMetadata->tags); $definition->setProperties($classMetadata->properties); if (null !== $classMetadata->decorates) { if (!method_exists($definition, 'setDecoratedService')) { throw new InvalidAnnotationException(sprintf("decorations require symfony >=2.8 on class %s", $classMetadata->name)); } $definition->setDecoratedService($classMetadata->decorates, $classMetadata->decoration_inner_name); } if (null !== $classMetadata->deprecated && method_exists($definition, 'setDeprecated')) { $definition->setDeprecated(true, $classMetadata->deprecated); } if (null === $classMetadata->id) { $classMetadata->id = '_jms_di_extra.unnamed.service_' . $count++; } if (0 !== count($classMetadata->initMethods)) { foreach ($classMetadata->initMethods as $initMethod) { $definition->addMethodCall($initMethod); } } elseif (null !== $classMetadata->initMethod) { @trigger_error('ClassMetadata::$initMethod is deprecated since version 1.7 and will be removed in 2.0. Use ClassMetadata::$initMethods instead.', E_USER_DEPRECATED); $definition->addMethodCall($classMetadata->initMethod); } $definitions[$classMetadata->id] = $definition; $previous = $classMetadata; } return $definitions; }
public function testConstructorWithInheritance() { $container = $this->getContainer(array(), array(__DIR__ . '/../../Functional/Bundle/TestBundle/Inheritance')); $container->set('foo', $foo = new \stdClass()); $container->set('bar', $bar = new \stdClass()); $this->process($container); $this->assertTrue($container->hasDefinition('concrete_class')); $this->assertTrue($container->hasDefinition('abstract_class')); $def = new DefinitionDecorator('abstract_class'); $def->setClass('JMS\\DiExtraBundle\\Tests\\Functional\\Bundle\\TestBundle\\Inheritance\\ConcreteClass'); $def->addArgument(new Reference('foo')); $def->addArgument(new Reference('bar')); $this->assertEquals($def, $container->getDefinition('concrete_class')); }
public function registerContainerConfiguration(LoaderInterface $loader) { parent::registerContainerConfiguration($loader); $loader->load(function (ContainerBuilder $container) { $container->setParameter('database_user', 'test'); $container->setParameter('database_password', 'test'); $container->setParameter('database_host', 'test'); $container->setParameter('broadway.saga.mongodb.storage_suffix', 'test'); $lockingRepositoryDefinition = new DefinitionDecorator('simgroep_event_sourcing.locking_repository'); $lockingRepositoryDefinition->setClass('Simgroep\\EventSourcing\\Repository\\TestAssets\\Aggregate'); $lockingRepositoryDefinition->addArgument('Simgroep\\EventSourcing\\Repository\\TestAssets\\Aggregate'); $container->setDefinition('locking_repository', $lockingRepositoryDefinition); }); }
/** * {@inheritdoc} */ public function process(ContainerBuilder $container) { if (!$this->hasMigrationsBundle($container)) { return; } if ($this->hasOrm($container)) { // Use Doctrine mapping (enhanced by our listeners) for schema if ORM is installed $provider = new Definition('Doctrine\\DBAL\\Migrations\\Provider\\OrmSchemaProvider', [$container->findDefinition('doctrine.orm.entity_manager')]); } else { // Migrations schema provider must implement interface (only available if bundle is installed) $provider = new DefinitionDecorator('contao.doctrine.dca_schema_provider'); $provider->setClass('Contao\\CoreBundle\\Doctrine\\Schema\\MigrationsSchemaProvider'); $this->registerDiffCommand($container, $provider); } $container->setDefinition('contao.doctrine.schema_provider', $provider); }
/** * Creates a resource owner service. * * @example code * $extension = $container->getExtension('glory_oauth'); * $extension->createOwnerService($container,$name,[]); * * @param ContainerBuilder $container The container builder * @param string $name The name of the service * @param array $options Additional options of the service */ public function createOwnerService(ContainerBuilder $container, $name, array $options) { $ownerId = 'glory_oauth.owner.' . $name; // alias services if (isset($options['service'])) { // set the appropriate name for aliased services, compiler pass depends on it $container->setAlias($ownerId, $options['service']); } else { $type = $options['type']; unset($options['type']); $definition = new DefinitionDecorator('glory_oauth.owner.abstract_' . GloryOAuthSupport::getOwnerType($type)); $definition->setClass("%glory_oauth.owner.{$type}.class%"); $container->setDefinition($ownerId, $definition); $definition->replaceArgument(2, $options)->replaceArgument(3, $name); } $container->getDefinition('glory_oauth.ownermap')->addMethodCall('addOwner', array($name, new Reference($ownerId))); }
/** {@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('error-handler-services.xml'); $container->setParameter('error_handler.stage', $config['stage']); $container->setParameter('error_handler.root_dir', $config['root_dir']); $shutdownSeverity = strtoupper($config['shutdown_severity']); $container->setParameter('error_handler.shutdown_severity', $shutdownSeverity); $baseErrorHandler = $container->getDefinition('base_error_handler'); $baseErrorHandler->replaceArgument(0, Severity::$SEVERITIES[$shutdownSeverity]); $errorHandler = $container->getDefinition('error_handler'); foreach ($config['categories'] as $categoryName => $categoryConfiguration) { if (empty($categoryConfiguration['handlers'])) { continue; } foreach ($categoryConfiguration['handlers'] as $handlerName => $handlerConfiguration) { $handlerClass = $container->getParameter(sprintf('error_handler.handler_%s.class', $handlerName)); $handlerId = sprintf('error_handler.handler.%s.%s', $categoryName, $handlerName); $handlerDefinition = new DefinitionDecorator('error_handler.abstract.handler'); $handlerDefinition->setClass($handlerClass); $handlerDefinition->setPublic(false); $handlerDefinition->setLazy(true); switch ($handlerName) { case 'bugsnag': $handlerDefinition->addArgument($handlerConfiguration['apiKey']); if (isset($handlerConfiguration['endpoint'])) { $handlerDefinition->addMethodCall('setEndpoint', array($handlerConfiguration['endpoint'])); } if (isset($handlerConfiguration['useSSL'])) { $handlerDefinition->addMethodCall('setUseSSL', array($handlerConfiguration['useSSL'])); } break; case 'raven': $handlerDefinition->addArgument($handlerConfiguration['endpoint']); break; } $container->setDefinition($handlerId, $handlerDefinition); $errorHandler->addMethodCall('addHandler', array(new Reference($handlerId), array($categoryName))); } } }
/** * Converts class hierarchy metadata to definition instances. * * @param ClassHierarchyMetadata $metadata * @return array an array of Definition instances */ public function convert(ClassHierarchyMetadata $metadata) { static $count = 0; $definitions = array(); $previous = null; foreach ($metadata->classMetadata as $classMetadata) { if (null === $previous && null === $classMetadata->parent) { $definition = new Definition(); } else { $definition = new DefinitionDecorator($classMetadata->parent ?: $previous->id); } $definition->setClass($classMetadata->name); if (null !== $classMetadata->scope) { $definition->setScope($classMetadata->scope); } if (null !== $classMetadata->public) { $definition->setPublic($classMetadata->public); } if (null !== $classMetadata->abstract) { $definition->setAbstract($classMetadata->abstract); } if (null !== $classMetadata->arguments) { $definition->setArguments($classMetadata->arguments); } $definition->setMethodCalls($classMetadata->methodCalls); $definition->setTags($classMetadata->tags); $definition->setProperties($classMetadata->properties); if (null === $classMetadata->id) { $classMetadata->id = '_jms_di_extra.unnamed.service_' . $count++; } if ($classMetadata->initMethod) { if (!method_exists($definition, 'setInitMethod')) { throw new \RuntimeException(sprintf('@AfterSetup is not available on your Symfony version.')); } $definition->setInitMethod($classMetadata->initMethod); } $definitions[$classMetadata->id] = $definition; $previous = $classMetadata; } return $definitions; }
/** * Creates a resource owner service. * * @param ContainerBuilder $container The container builder * @param string $name The name of the service * @param array $options Additional options of the service */ public function createResourceOwnerService(ContainerBuilder $container, $name, array $options) { // alias services if (isset($options['service'])) { // set the appropriate name for aliased services, compiler pass depends on it $container->setAlias('hwi_oauth.resource_owner.' . $name, $options['service']); } else { $type = $options['type']; unset($options['type']); $definition = new DefinitionDecorator('hwi_oauth.abstract_resource_owner.' . Configuration::getResourceOwnerType($type)); $definition->setClass("%hwi_oauth.resource_owner.{$type}.class%"); $container->setDefinition('hwi_oauth.resource_owner.' . $name, $definition); $definition->replaceArgument(2, $options)->replaceArgument(3, $name); } }
private function configureResultCache(array $config, ContainerBuilder $container, Definition $configurationDef) { $cacheClass = null; $cacheId = null; if (isset($config['class'])) { $cacheClass = $config['class']; } elseif (isset($config['id'])) { $cacheId = $config['id']; } else { $cacheClass = "Doctrine\\Common\\Cache\\ArrayCache"; } if (null !== $cacheClass) { $cacheId = 'kassko_data_mapper.result_cache'; $cacheDef = new DefinitionDecorator('kassko_data_mapper.result_cache.prototype'); $cacheDef->setClass($cacheClass)->setPublic(false); $container->setDefinition($cacheId, $cacheDef); } $cacheAdapterId = $cacheId . '_adapter'; $cacheAdapterDef = new Definition($config['adapter_class'], [new Reference($cacheId)]); $container->setDefinition($cacheAdapterId, $cacheAdapterDef); $cacheConfigId = 'kassko_data_mapper.result_cache_configuration'; $cacheConfigDef = new DefinitionDecorator('kassko_data_mapper.configuration.cache.prototype'); $cacheConfigDef->addMethodCall('setCache', [new Reference($cacheAdapterId)]); $cacheConfigDef->addMethodCall('setLifeTime', [$config['life_time']]); $cacheConfigDef->addMethodCall('setShared', [$config['is_shared']]); $container->setDefinition($cacheConfigId, $cacheConfigDef); $configurationDef->addMethodCall('setResultCacheConfig', [new Reference($cacheConfigId)]); }
/** * @param string $userType * @param string $userModel * @param ContainerBuilder $container */ private function createProviders($userType, $userModel, ContainerBuilder $container) { $repositoryServiceId = sprintf('sylius.repository.%s_user', $userType); $abstractProviderServiceId = sprintf('sylius.%s_user.provider', $userType); $providerEmailBasedServiceId = sprintf('sylius.%s_user.provider.email_based', $userType); $providerNameBasedServiceId = sprintf('sylius.%s_user.provider.name_based', $userType); $providerEmailOrNameBasedServiceId = sprintf('sylius.%s_user.provider.email_or_name_based', $userType); $abstractProviderDefinition = new Definition(AbstractUserProvider::class); $abstractProviderDefinition->setAbstract(true); $abstractProviderDefinition->setLazy(true); $abstractProviderDefinition->addArgument($userModel); $abstractProviderDefinition->addArgument(new Reference($repositoryServiceId)); $abstractProviderDefinition->addArgument(new Reference('sylius.user.canonicalizer')); $container->setDefinition($abstractProviderServiceId, $abstractProviderDefinition); $providerEmailBasedDefinition = new DefinitionDecorator($abstractProviderServiceId); $providerEmailBasedDefinition->setClass(EmailProvider::class); $container->setDefinition($providerEmailBasedServiceId, $providerEmailBasedDefinition); $providerNameBasedDefinition = new DefinitionDecorator($abstractProviderServiceId); $providerNameBasedDefinition->setClass(UsernameProvider::class); $container->setDefinition($providerNameBasedServiceId, $providerNameBasedDefinition); $providerEmailOrNameBasedDefinition = new DefinitionDecorator($abstractProviderServiceId); $providerEmailOrNameBasedDefinition->setClass(UsernameOrEmailProvider::class); $container->setDefinition($providerEmailOrNameBasedServiceId, $providerEmailOrNameBasedDefinition); }
/** * Loads the workflow configuration. * * @param array $workflows A workflow configuration array * @param ContainerBuilder $container A ContainerBuilder instance * @param XmlFileLoader $loader An XmlFileLoader instance */ private function registerWorkflowConfiguration(array $workflows, ContainerBuilder $container, XmlFileLoader $loader) { if (!$workflows) { return; } $loader->load('workflow.xml'); $registryDefinition = $container->getDefinition('workflow.registry'); foreach ($workflows as $name => $workflow) { $type = $workflow['type']; $transitions = array(); foreach ($workflow['transitions'] as $transitionName => $transition) { if ($type === 'workflow') { $transitions[] = new Definition(Workflow\Transition::class, array($transitionName, $transition['from'], $transition['to'])); } elseif ($type === 'state_machine') { foreach ($transition['from'] as $from) { foreach ($transition['to'] as $to) { $transitions[] = new Definition(Workflow\Transition::class, array($transitionName, $from, $to)); } } } } // Create a Definition $definitionDefinition = new Definition(Workflow\Definition::class); $definitionDefinition->setPublic(false); $definitionDefinition->addArgument($workflow['places']); $definitionDefinition->addArgument($transitions); $definitionDefinition->addTag('workflow.definition', array('name' => $name, 'type' => $type, 'marking_store' => isset($workflow['marking_store']['type']) ? $workflow['marking_store']['type'] : null)); if (isset($workflow['initial_place'])) { $definitionDefinition->addArgument($workflow['initial_place']); } // Create MarkingStore if (isset($workflow['marking_store']['type'])) { $parentDefinitionId = 'workflow.marking_store.' . $workflow['marking_store']['type']; $markingStoreDefinition = new DefinitionDecorator($parentDefinitionId); foreach ($workflow['marking_store']['arguments'] as $argument) { $markingStoreDefinition->addArgument($argument); } // explicitly set parent class to decorated definition in order to fix inconsistent behavior for <=2.7 // see https://github.com/symfony/symfony/issues/17353 and https://github.com/symfony/symfony/pull/15096 $markingStoreDefinition->setClass($container->getDefinition($parentDefinitionId)->getClass()); } elseif (isset($workflow['marking_store']['service'])) { $markingStoreDefinition = new Reference($workflow['marking_store']['service']); } // Create Workflow $workflowDefinition = new DefinitionDecorator(sprintf('%s.abstract', $type)); $workflowDefinition->replaceArgument(0, $definitionDefinition); if (isset($markingStoreDefinition)) { $workflowDefinition->replaceArgument(1, $markingStoreDefinition); } $workflowDefinition->replaceArgument(3, $name); // Store to container $workflowId = sprintf('%s.%s', $type, $name); $container->setDefinition($workflowId, $workflowDefinition); $container->setDefinition(sprintf('%s.definition', $workflowId), $definitionDefinition); // Add workflow to Registry foreach ($workflow['supports'] as $supportedClass) { $registryDefinition->addMethodCall('add', array(new Reference($workflowId), $supportedClass)); } } }
/** * Creates a subscriber definition. * * @param string $adapterName The adatper name. * @param string $subscriberName The subscriber name. * @param array|string $configuration The configuration. * * @return \Symfony\Component\DependencyInjection\DefinitionDecorator The subscriber definition. */ private function createSubscriberDefinition($adapterName, $subscriberName, $configuration, ContainerBuilder $container) { $parent = self::createServiceName('subscriber.' . $subscriberName); $subscriber = new DefinitionDecorator($parent); $subscriber->setClass($container->getDefinition($parent)->getClass()); $subscriber->addTag(RegisterListenerCompilerPass::SUBSCRIBER_TAG, array('adapter' => $adapterName)); switch ($subscriberName) { case 'basic_auth': $this->configureBasicAuthSubscriberDefinition($subscriber, $configuration, $adapterName, $container); break; case 'cookie': $this->configureCookieSubscriberDefinition($subscriber, $configuration); break; case 'history': $this->configureHistorySubscriberDefinition($subscriber, $configuration); break; case 'logger': $this->configureLoggerSubscriberDefinition($subscriber, $configuration); break; case 'redirect': $this->configureRedirectSubscriberDefinition($subscriber, $configuration, $adapterName, $container); break; case 'retry': $this->configureRetrySubscriberDefinition($subscriber, $adapterName, $container); break; case 'stopwatch': $this->configureStopwatchSubscriberDefinition($subscriber, $configuration); break; } return $subscriber; }