/**
* @param ContainerBuilder $container
* @param string $code
* @param Definition $formatter
* @param array $extensions
*
* @return string
*/
public function createEnvironment(ContainerBuilder $container, $code, Definition $formatter, array $extensions)
{
$loader = new Definition('Twig_Loader_String');
$loader->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.loader.%s', $code), $loader);
$loaderSelector = new Definition('Sonata\\FormatterBundle\\Twig\\Loader\\LoaderSelector', array(new Reference(sprintf('sonata.formatter.twig.loader.%s', $code)), new Reference('twig.loader')));
$loaderSelector->setPublic(false);
$env = new Definition('Twig_Environment', array($loaderSelector, array('debug' => false, 'strict_variables' => false, 'charset' => 'UTF-8')));
$env->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.env.%s', $code), $env);
$sandboxPolicy = new Definition('Sonata\\FormatterBundle\\Twig\\SecurityPolicyContainerAware', array(new Reference('service_container'), $extensions));
$sandboxPolicy->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.sandbox.%s.policy', $code), $sandboxPolicy);
$sandbox = new Definition('Twig_Extension_Sandbox', array($sandboxPolicy, true));
$sandbox->setPublic(false);
$container->setDefinition(sprintf('sonata.formatter.twig.sandbox.%s', $code), $sandbox);
$env->addMethodCall('addExtension', array(new Reference(sprintf('sonata.formatter.twig.sandbox.%s', $code))));
foreach ($extensions as $extension) {
$env->addMethodCall('addExtension', array(new Reference($extension)));
}
$lexer = new Definition('Twig_Lexer', array(new Reference(sprintf('sonata.formatter.twig.env.%s', $code)), array('tag_comment' => array('<#', '#>'), 'tag_block' => array('<%', '%>'), 'tag_variable' => array('<%=', '%>'))));
$lexer->setPublic(false);
$container->setDefinition(new Reference(sprintf('sonata.formatter.twig.lexer.%s', $code)), $lexer);
$env->addMethodCall('setLexer', array(new Reference(sprintf('sonata.formatter.twig.lexer.%s', $code))));
return sprintf('sonata.formatter.twig.env.%s', $code);
}
/**
* @param string $name
* @param array $config
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
*
* @return \Symfony\Component\DependencyInjection\Reference
*/
private function getConnectionReference($name, array $config, ContainerBuilder $container)
{
if (isset($config['connection_id'])) {
return new Reference($config['connection_id']);
}
$host = $config['host'];
$port = $config['port'];
$connClass = '%doctrine_cache.redis.connection.class%';
$connId = sprintf('doctrine_cache.services.%s_redis.connection', $name);
$connDef = new Definition($connClass);
$connParams = array($host, $port);
if (isset($config['timeout'])) {
$connParams[] = $config['timeout'];
}
$connDef->setPublic(false);
$connDef->addMethodCall('connect', $connParams);
if (isset($config['password'])) {
$password = $config['password'];
$connDef->addMethodCall('auth', array($password));
}
if (isset($config['database'])) {
$database = (int) $config['database'];
$connDef->addMethodCall('select', array($database));
}
$container->setDefinition($connId, $connDef);
return new Reference($connId);
}
public function configureTemplate(ContainerBuilder $container, $configs)
{
$pageManager = $container->getDefinition('sonata.page.manager.page');
$snapshotManager = $container->getDefinition('sonata.page.manager.snapshot');
$defaults = array('name' => 'n-a', 'path' => 'SonataPageBundle::layout.html.twig');
if (!isset($configs['default_template'])) {
$configs['default_template'] = 'default';
}
if (!isset($configs['templates'])) {
$configs['templates'] = array('default' => array_merge($defaults, array('name' => 'default')));
}
$definitions = array();
foreach ($configs['templates'] as $code => $info) {
$info = array_merge($defaults, $info);
$definition = new Definition('Sonata\\PageBundle\\Model\\Template');
foreach ($defaults as $key => $value) {
$method = 'set' . ucfirst($key);
$definition->addMethodCall($method, array($info[$key]));
}
$definition->setPublic(false);
$definitions[$code] = $definition;
}
$pageManager->addMethodCall('setTemplates', array($definitions));
$snapshotManager->addMethodCall('setTemplates', array($definitions));
$pageManager->addMethodCall('setDefaultTemplateCode', array($configs['default_template']));
}
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)]);
}
}
/**
* @param Definition $definition
*/
protected function processDefinition(Definition $definition)
{
if ($definition->isSynthetic()) {
return;
}
if ($definition->getFactoryService() || $definition->getFactoryClass()) {
return;
}
if ($file = $definition->getFile()) {
require_once $file;
}
if (!class_exists($definition->getClass())) {
return;
}
$class = new \ReflectionClass($definition->getClass());
if (!$class->implementsInterface(static::INTERFACE_CLASS)) {
return;
}
$metadata = $this->getMetadataFactory()->getMetadataForClass($definition->getClass());
if (!$metadata instanceof ClassMetadata) {
return;
}
$namespace = $metadata->getNamespace() ?: static::ROOT_NAMESPACE;
$serviceName = static::PROVIDER_PREFIX . substr(sha1($namespace), 0, 10);
if (!$this->container->hasDefinition($serviceName)) {
$cacher = new Definition('Werkint\\Bundle\\CacheBundle\\Service\\CacheProvider', [$this->container->getParameter('kernel.cache_dir') . '/werkint_cache']);
$cacher->setPublic(true);
$cacher->addMethodCall('setNamespace', [$namespace]);
$this->container->setDefinition($serviceName, $cacher);
}
$definition->addMethodCall('setCacheProvider', [new Reference($serviceName)]);
}
private function getDataCollectorDefinition()
{
$definition = new Definition(ApiClientDataCollector::class, [new Reference('leoza_api_client.profiler')]);
$definition->setPublic(false);
$definition->addTag('data_collector', ['template' => 'LeozaApiClientBundle:DataCollector:ApiClientProfile.html.twig', 'id' => 'leoza_api_client.data_collector']);
return $definition;
}
private function registerRequestBinder(ContainerBuilder $container)
{
$definition = new Definition(RequestObjectBinder::class, []);
$definition->setAutowired(true);
$definition->setPublic(false);
$container->setDefinition('request_object.request_binder', $definition);
}
/**
* Registers publisher services in container
*/
protected function loadConnections()
{
foreach ($this->config['connections'] as $key => $connection) {
$protocol = $connection['protocol'];
$host = $connection['host'];
$port = $connection['port'];
$path = $connection['path'];
$auth_key = $connection['auth_key'];
$auth_secret = $connection['auth_secret'];
$hostname = $connection['hostname'];
$ignoreSsl = $connection['ssl_ignore'];
if ($path[0] != '/') {
$path = '/' . $path;
}
$definition = new Definition("Facile\\CrossbarHTTPPublisherBundle\\Publisher\\Factory", array($protocol, $host, $port, $path, $auth_key, $auth_secret, $hostname, $ignoreSsl));
$definition->setPublic(false);
$factoryName = sprintf('facile.crossbar.publisher.factory.%s', $key);
$this->container->setDefinition($factoryName, $definition);
$definition = new Definition("Facile\\CrossbarHTTPPublisherBundle\\Publisher\\Publisher");
if (method_exists($definition, 'setFactory')) {
$definition->setFactory(array(new Reference($factoryName), 'createPublisher'));
} else {
$definition->setFactoryService($factoryName);
$definition->setFactoryMethod('createPublisher');
}
$this->container->setDefinition(sprintf('facile.crossbar.publisher.%s', $key), $definition);
}
}
protected function addProvider($name, array $arguments = array())
{
$provider = new Definition('%morbicer_converter.provider.' . $name . '.class%', $arguments);
$provider->setPublic(false)->addTag('morbicer_converter.provider');
$this->container->setDefinition('morbicer_converter.provider.' . $name, $provider);
return $provider;
}
/**
* Loads the Twig global variable.
*
* @param ContainerBuilder $container
*/
private function loadTwigExtension(ContainerBuilder $container)
{
$service = new Definition('EmanueleMinotto\\FakerBundle\\Twig\\FakerGeneratorExtension', array(new Reference('faker')));
$service->addTag('twig.extension');
$service->setPublic(false);
$container->setDefinition('emanuele.minotto.faker.twig.extension', $service);
}
private function processAdapterConfiguration(array $configuration, ContainerBuilder $container)
{
$definition = new Definition($configuration['class']);
$definition->addArgument($configuration['options']);
$definition->setPublic(false);
$container->setDefinition('search.adapter', $definition);
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$pool = $container->getDefinition('sonata.product.pool');
$calls = $pool->getMethodCalls();
$pool->setMethodCalls(array());
$map = array();
foreach ($calls as $method => $arguments) {
if ($arguments[0] !== '__hack') {
$pool->addMethodCall($arguments[0], $arguments[1]);
continue;
}
foreach ($arguments[1] as $code => $options) {
// define a new ProductDefinition
$definition = new Definition('Sonata\\Component\\Product\\ProductDefinition', array(new Reference($options['provider']), new Reference($options['manager'])));
$definition->setPublic(false);
$container->setDefinition($code, $definition);
$container->getDefinition($options['provider'])->addMethodCall('setCode', array($code));
$pool->addMethodCall('addProduct', array($code, new Reference($code)));
$map[$code] = $container->getDefinition($options['manager'])->getArgument(0);
$container->getDefinition($options['provider'])->addMethodCall('setBasketElementManager', array(new Reference('sonata.basket_element.manager')));
$container->getDefinition($options['provider'])->addMethodCall('setCurrencyPriceCalculator', array(new Reference('sonata.price.currency.calculator')));
$container->getDefinition($options['provider'])->addMethodCall('setProductCategoryManager', array(new Reference('sonata.product_category.product')));
$container->getDefinition($options['provider'])->addMethodCall('setProductCollectionManager', array(new Reference('sonata.product_collection.product')));
$container->getDefinition($options['provider'])->addMethodCall('setOrderElementClassName', array($container->getParameter('sonata.order.order_element.class')));
$container->getDefinition($options['provider'])->addMethodCall('setEventDispatcher', array(new Reference('event_dispatcher')));
if (array_key_exists('variations', $options)) {
$container->getDefinition($options['provider'])->addMethodCall('setVariationFields', array($options['variations']['fields']));
}
}
}
$container->getDefinition('sonata.product.subscriber.orm')->replaceArgument(0, $map);
}
/**
* Process the adaptor config configuration.
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function loadConfigs(array $config, ContainerBuilder $container)
{
foreach ($config['configs'] as $name => $arguments) {
if (!$arguments['enabled']) {
continue;
}
$id = 'integrated_channel.config.memory.' . $name;
if ($container->hasDefinition($id)) {
continue;
}
// first create the options and for that we need a unique service id
do {
$id_options = $id . '.options.' . uniqid();
} while ($container->hasDefinition($id_options));
$definition = new Definition('%integrated_channel.config.options.class%');
$definition->setPublic(false);
$definition->setArguments([$arguments['options']]);
$container->setDefinition($id_options, $definition);
// create the config it self
$definition = new Definition('%integrated_channel.config.class%');
$definition->setArguments([$name, $arguments['adaptor'], new Reference($id_options)]);
if ($arguments['channel']) {
foreach ($arguments['channel'] as $channel) {
$definition->addTag('integrated_channel.config', ['channel' => $channel]);
}
} else {
$definition->addTag('integrated_channel.config');
}
$container->setDefinition($id, $definition);
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
foreach ($container->findTaggedServiceIds('snc_redis.connection_parameters') as $id => $attr) {
$clientAlias = $attr[0]['clientAlias'];
$parameterDefinition = $container->getDefinition($id);
$parameters = $parameterDefinition->getArgument(0);
if ($parameters['logging']) {
$optionId = sprintf('snc_redis.client.%s_options', $clientAlias);
$option = $container->getDefinition($optionId);
if (1 < count($option->getArguments())) {
throw new \RuntimeException('Please check the predis option arguments.');
}
$arguments = $option->getArgument(0);
$connectionFactoryId = sprintf('snc_redis.%s_connectionfactory', $clientAlias);
$connectionFactoryDef = new Definition($container->getParameter('snc_redis.connection_factory.class'));
$connectionFactoryDef->setPublic(false);
$connectionFactoryDef->addArgument(new Reference(sprintf('snc_redis.client.%s_profile', $clientAlias)));
$connectionFactoryDef->addMethodCall('setConnectionWrapperClass', array($container->getParameter('snc_redis.connection_wrapper.class')));
$connectionFactoryDef->addMethodCall('setLogger', array(new Reference('snc_redis.logger')));
$container->setDefinition($connectionFactoryId, $connectionFactoryDef);
$arguments['connections'] = new Reference($connectionFactoryId);
$option->replaceArgument(0, $arguments);
}
}
}
/**
* Configure the sitemap source manager.
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function configureSitemap(array $config, ContainerBuilder $container)
{
$source = $container->getDefinition('sonata.seo.sitemap.manager');
if (method_exists($source, 'setShared')) {
// Symfony 2.8+
$source->setShared(false);
} else {
// For Symfony <2.8 compatibility
$source->setScope(ContainerInterface::SCOPE_PROTOTYPE);
}
foreach ($config['doctrine_orm'] as $pos => $sitemap) {
// define the connectionIterator
$connectionIteratorId = 'sonata.seo.source.doctrine_connection_iterator_' . $pos;
$connectionIterator = new Definition('%sonata.seo.exporter.database_source_iterator.class%', array(new Reference($sitemap['connection']), $sitemap['query']));
$connectionIterator->setPublic(false);
$container->setDefinition($connectionIteratorId, $connectionIterator);
// define the sitemap proxy iterator
$sitemapIteratorId = 'sonata.seo.source.doctrine_sitemap_iterator_' . $pos;
$sitemapIterator = new Definition('%sonata.seo.exporter.sitemap_source_iterator.class%', array(new Reference($connectionIteratorId), new Reference('router'), $sitemap['route'], $sitemap['parameters']));
$sitemapIterator->setPublic(false);
$container->setDefinition($sitemapIteratorId, $sitemapIterator);
$source->addMethodCall('addSource', array($sitemap['group'], new Reference($sitemapIteratorId), $sitemap['types']));
}
foreach ($config['services'] as $service) {
$source->addMethodCall('addSource', array($service['group'], new Reference($service['id']), $service['types']));
}
}
/**
* 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));
}
}
}
/**
* @param string $name
* @param array $config
* @param \Symfony\Component\DependencyInjection\ContainerBuilder $container
*
* @return \Symfony\Component\DependencyInjection\Reference
*/
private function getConnectionReference($name, array $config, ContainerBuilder $container)
{
if (isset($config['client_id'])) {
return new Reference($config['client_id']);
}
$parameters = array('scheme' => $config['scheme'], 'host' => $config['host'], 'port' => $config['port']);
if ($config['password']) {
$parameters['password'] = $config['password'];
}
if ($config['timeout']) {
$parameters['timeout'] = $config['timeout'];
}
if ($config['database']) {
$parameters['database'] = $config['database'];
}
$options = null;
if (isset($config['options'])) {
$options = $config['options'];
}
$clientClass = '%doctrine_cache.predis.client.class%';
$clientId = sprintf('doctrine_cache.services.%s_predis.client', $name);
$clientDef = new Definition($clientClass);
$clientDef->addArgument($parameters);
$clientDef->addArgument($options);
$clientDef->setPublic(false);
$container->setDefinition($clientId, $clientDef);
return new Reference($clientId);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$config = $this->getConfiguration($configs, $container);
$config = $this->processConfiguration($config, $configs);
foreach ($config['services'] as $name => $settings) {
// until we can use file attachments in Guzzle in php 5.5 we block use of the upload type
if ('upload' === $settings['type']) {
throw new \ConfigurationException('The "upload" type is currently disabled due to PHP 5.5 cURL issues.');
}
$def = new Definition($container->getParameter('pompdelux.kraken.service.class'));
$def->setPublic(true);
$def->setScope(ContainerInterface::SCOPE_CONTAINER);
$def->addArgument(new Reference('pompdelux.kraken.guzzle.' . $settings['type'] . '.service'));
$def->addArgument(new Reference('logger'));
$def->addArgument(new Reference('router'));
$def->addArgument($settings['api_key']);
$def->addArgument($settings['api_secret']);
$def->addArgument($settings['type']);
$def->addArgument($settings['use_lossy']);
$callback = $settings['callback'] ? $settings['callback_route'] : null;
$def->addArgument($callback);
$container->setDefinition(sprintf('pompdelux.kraken.%s', $name), $def);
}
}
public function testPoolRefsAreWeak()
{
$container = new ContainerBuilder();
$container->setParameter('kernel.debug', false);
$container->setParameter('kernel.name', 'app');
$container->setParameter('kernel.environment', 'prod');
$container->setParameter('kernel.root_dir', 'foo');
$globalClearer = new Definition(Psr6CacheClearer::class);
$container->setDefinition('cache.global_clearer', $globalClearer);
$publicPool = new Definition();
$publicPool->addArgument('namespace');
$publicPool->addTag('cache.pool', array('clearer' => 'clearer_alias'));
$container->setDefinition('public.pool', $publicPool);
$privatePool = new Definition();
$privatePool->setPublic(false);
$privatePool->addArgument('namespace');
$privatePool->addTag('cache.pool', array('clearer' => 'clearer_alias'));
$container->setDefinition('private.pool', $privatePool);
$clearer = new Definition();
$container->setDefinition('clearer', $clearer);
$container->setAlias('clearer_alias', 'clearer');
$pass = new RemoveUnusedDefinitionsPass();
$pass->setRepeatedPass(new RepeatedPass(array($pass)));
foreach (array(new CachePoolPass(), $pass, new CachePoolClearerPass()) as $pass) {
$pass->process($container);
}
$this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $clearer->getArguments());
$this->assertEquals(array(array('public.pool' => new Reference('public.pool'))), $globalClearer->getArguments());
}
/**
* creates and registeres a classmap service definition
*
* @param ContainerBuilder $container
* @param array $config
* @return Definition
* @author Daniel Wendlandt
*/
private function createClassMapDefinition(ContainerBuilder $container, array $config)
{
$classMapDef = new Definition();
$classMapDef->setPublic(false);
$classMapDef->setClass($container->getParameter('elastification_php_client.repository.classmap.class'));
$classMapDef->setArguments(array($config['elasticsearch_version']));
$container->setDefinition(ElastificationPhpClientExtension::SERVICE_REPOSITORY_CLASSMAP, $classMapDef);
return $classMapDef;
}
/**
* {@inheritdoc}
*/
public function createService($name, array $config, ContainerBuilder $container)
{
$service_id = sprintf('jose.verifier.%s', $name);
$definition = new Definition('Jose\\Verifier');
$definition->setFactory([new Reference('jose.factory.service'), 'createVerifier']);
$definition->setArguments([$config['algorithms']]);
$definition->setPublic($config['is_public']);
$container->setDefinition($service_id, $definition);
}
/**
* You can modify the container here before it is dumped to PHP code.
*
* @param ContainerBuilder $container
*
* @api
*/
public function process(ContainerBuilder $container)
{
$requestManagerDef = $container->getDefinition(ElastificationPhpClientExtension::SERVICE_REQUESTMANAGER_KEY);
$transportDef = $container->getDefinition(ElastificationPhpClientExtension::SERVICE_TRANSPORT_KEY);
$clientDef = new Definition($container->getParameter('elastification_php_client.client.class'), array($transportDef, $requestManagerDef));
$clientDef->setPublic(false);
$container->setDefinition(ElastificationPhpClientExtension::SERVICE_CLIENT_KEY, $clientDef);
$container->setAlias(ElastificationPhpClientExtension::ALIAS_CLIENT, ElastificationPhpClientExtension::SERVICE_CLIENT_KEY);
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition('jms_translation.extractor.file_extractor')) {
return;
}
$extractor = new Definition('APY\\DataGridBundle\\Translation\\ColumnTitleAnnotationTranslationExtractor');
$extractor->setPublic(false)->addTag('jms_translation.file_visitor');
$container->setDefinition('grid.translation_extractor', $extractor);
}
private function createWizards(ContainerBuilder $container, array $wizards)
{
foreach ($wizards as $wizardName => $properties) {
$wizardConfigurationDefinition = new Definition(WizardConfiguration::class, [$properties['steps'], new Reference('form.factory')]);
$wizardConfigurationDefinition->setPublic(false);
$wizardDefinition = new Definition(Wizard::class, [$wizardName, $wizardConfigurationDefinition, new Reference('event_dispatcher'), new Reference(str_replace('@', '', $properties['entity_manager']))]);
$container->setDefinition('cms.form_wizard.' . $wizardName, $wizardDefinition);
}
}
/**
* Configures the profiler data collector.
*
* @param ContainerBuilder $container Container
* @param array $config Configuration
*/
public function configureProfiler(ContainerBuilder $container, array $config)
{
// Setup the data collector service for Symfony profiler
$dataCollectorDef = new Definition(PheanstalkDataCollector::class);
$dataCollectorDef->setPublic(false);
$dataCollectorDef->addTag('data_collector', ['id' => 'pheanstalk', 'template' => $config['profiler']['template']]);
$dataCollectorDef->addArgument(new Reference('leezy.pheanstalk.pheanstalk_locator'));
$container->setDefinition('leezy.pheanstalk.data_collector', $dataCollectorDef);
}
/**
* {@inheritdoc}
*/
public function createService($name, array $config, ContainerBuilder $container)
{
$service_id = sprintf('jose.jwt_creator.%s', $name);
$definition = new Definition('Jose\\JWTCreator');
$definition->setFactory([new Reference('jose.factory.service'), 'createJWTCreator']);
$definition->setArguments([new Reference($config['signer']), null === $config['encrypter'] ? null : new Reference($config['encrypter'])]);
$definition->setPublic($config['is_public']);
$container->setDefinition($service_id, $definition);
}
/**
* {@inheritdoc}
*/
public function createService($name, array $config, ContainerBuilder $container)
{
$service_id = sprintf('jose.decrypter.%s', $name);
$definition = new Definition('Jose\\Decrypter');
$definition->setFactory([new Reference('jose.factory.service'), 'createDecrypter']);
$definition->setArguments([$config['key_encryption_algorithms'], $config['content_encryption_algorithms'], $config['compression_methods']]);
$definition->setPublic($config['is_public']);
$container->setDefinition($service_id, $definition);
}
/**
* Set the configuration for a section.
*
* @param string $name Name of the section, must be unique within the service-prefix
* @param array $config Configuration of the section, must contain a 'prefix' key
*
* @return SectioningFactory Fluent interface
*/
public function set(string $name, array $config) : SectioningFactory
{
$sectionDef = new Definition(SectionConfiguration::class);
$sectionDef->setPublic(false);
$sectionDef->addArgument($config);
$sectionDef->addTag(self::TAG_NAME, ['service_prefix' => $this->servicePrefix, 'section_name' => $name]);
$this->container->setDefinition(sprintf('rollerworks.app_section.%s.%s', $this->servicePrefix, $name), $sectionDef);
return $this;
}
/**
* Loads the Monolog configuration.
*
* @param array $config A configuration array
* @param ContainerBuilder $container A ContainerBuilder instance
*/
protected function loadMonologHandler(array $config, ContainerBuilder $container)
{
$def2 = new Definition($config['monolog']['formatter']['class'], array($config['monolog']['formatter']['format'], $config['monolog']['formatter']['context_logging'], $config['monolog']['formatter']['extra_logging'], $config['monolog']['formatter']['words']));
$container->setDefinition('monolog.formatter.statsd', $def2);
$def = new Definition($container->getParameter('liuggio_stats_d_client.monolog_handler.class'), array(new Reference('liuggio_stats_d_client.service'), new Reference('liuggio_stats_d_client.factory'), $config['monolog']['prefix'], $this->convertLevelToConstant($config['monolog']['level'])));
$def->setPublic(false);
$def->addMethodCall('setFormatter', array(new Reference('monolog.formatter.statsd')));
$container->setDefinition('monolog.handler.statsd', $def);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$config = $this->processConfiguration(new Configuration(), $configs);
$factoryDefinition = new Definition('Rabus\\Bundle\\Twitter\\SignInBundle\\Service\\ConnectionFactory', array($config['consumer_key'], $config['consumer_secret']));
$factoryDefinition->setPublic(false)->addMethodCall('setLogger', array(new Reference('logger', ContainerInterface::NULL_ON_INVALID_REFERENCE)));
$container->setDefinition('rabus.twitter.connection_factory', $factoryDefinition);
$loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
}
