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