/**
* {@inheritdoc}
*/
public function load(array $config, ContainerBuilder $container)
{
// checker
$container->register('bravesheep_active_link.checker', 'Bravesheep\\ActiveLinkBundle\\ActiveChecker')->addArgument(new Reference('kernel'))->addArgument(new Reference('request_stack'));
// twig extension
$container->register('bravesheep_active_link.twig', 'Bravesheep\\ActiveLinkBundle\\Twig\\BravesheepActiveLinkExtension')->addArgument(new Reference('bravesheep_active_link.checker'))->addTag('twig.extension');
}
/**
* {@inheritdoc}
*/
public function setUp()
{
$this->container_builder = new ContainerBuilder();
$this->container_builder->register('foo', 'My/Class');
$this->container_builder->setAlias('bar', 'foo');
$this->dumper = new PhpArrayDumper($this->container_builder);
}
/**
* @param array $configs
* @param ContainerBuilder $container
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.yml');
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$container->setParameter('chebur_sphinx_config', $config);
//Filling in Registry with managers
$names = array();
$nameDefault = null;
$loggerRef = new Reference('chebur.sphinx.profiler.logger');
foreach ($config['connections'] as $connectionName => $val) {
$container->register('chebur.sphinx.connection.' . $connectionName, $container->getParameter('chebur.sphinx.connection.class'))->addArgument($connectionName)->addArgument($loggerRef)->addArgument($val['driver'])->addArgument($val['host'])->addArgument($val['port'])->addArgument($val['port_api']);
$container->register('chebur.sphinx.manager.' . $connectionName, $container->getParameter('chebur.sphinx.manager.class'))->addArgument(new Reference('chebur.sphinx.connection.' . $connectionName));
$names[] = $connectionName;
if ($val['default']) {
$nameDefault = $connectionName;
}
}
if (!$nameDefault) {
$nameDefault = $names[array_keys($names)[0]];
}
$container->setAlias('chebur.sphinx.manager', 'chebur.sphinx.manager.' . $nameDefault);
$container->register('chebur.sphinx', $container->getParameter('chebur.sphinx.registry.class'))->addArgument(new Reference('service_container'))->addArgument($names)->addArgument($nameDefault);
}
public function testExceptionWhenNameAttributeIsMissing()
{
$this->setExpectedException('RuntimeException');
$this->container->register('test_receiver', 'stdClass')->addTag('bernard.receiver', []);
$pass = new ReceiverPass();
$pass->process($this->container);
}
public function configureApiServices(ContainerBuilder $container, array $apiServices, array $cache)
{
$serviceFactoryRef = new Reference('api_service.factory');
// Register decoder
$definition = $container->register('api_service.decoder.symfony', ChainDecoder::class);
$definition->setArguments([[new Reference('serializer.encoder.json'), new Reference('serializer.encoder.xml')]]);
$definition = $container->register('api_service.decoder', SymfonyDecoderAdapter::class);
$definition->setArguments([new Reference('api_service.decoder.symfony')]);
// Register validator
$validator = $container->register('api_service.json_schema_validator', Validator::class);
$validator->setPublic(false);
// Configure schema factory
$schemaFactoryId = 'api_service.schema_factory.swagger';
if ($cache['enabled']) {
$schemaFactory = $container->getDefinition('api_service.schema_factory.cached_factory');
$schemaFactory->replaceArgument(0, new Reference($cache['service']));
$schemaFactory->replaceArgument(1, new Reference($schemaFactoryId));
$schemaFactoryId = 'api_service.schema_factory.cached_factory';
}
$container->setAlias('api_service.schema_factory', $schemaFactoryId);
// Configure each api services
foreach ($apiServices as $name => $arguments) {
$container->register('api_service.api.' . $name, ApiService::class)->setFactory([$serviceFactoryRef, 'getService'])->addArgument(new Reference($arguments['client']))->addArgument(new Reference($schemaFactoryId))->addArgument($arguments['schema'])->addArgument($arguments['config']);
}
}
public function testProcessIgnoresMethodCalls()
{
$container = new ContainerBuilder();
$container->register('a')->addArgument(new Reference('b'));
$container->register('b')->addMethodCall('setA', array(new Reference('a')));
$this->process($container);
}
/**
* @param null $configPath
* @param array $configFilenames
*/
function __construct($configPath = null, $configFilenames = array())
{
$configPath = $configPath == null ? __DIR__ . '/../../../../../../app/config' : $configPath;
$this->container = new ContainerBuilder();
// Load app parameters and config files into container
$loader = new YamlFileLoader($this->container, new FileLocator($configPath));
$loader->load('parameters.yml');
foreach ($configFilenames as $filename) {
$loader->load($filename);
}
$appName = $this->container->getParameter('application_name');
$appVersion = $this->container->getParameter('application_version');
parent::__construct($appName, $appVersion);
// Set dispatcher definition, register listeners and subscribers
$dispatcherDef = $this->container->register('event_dispatcher', 'Symfony\\Component\\EventDispatcher\\ContainerAwareEventDispatcher');
$dispatcherDef->addArgument($this->container);
$this->registerEventListeners();
$this->container->compile();
// Once container is compiled we can get the event_dispatcher from dic
$this->dispatcher = $this->container->get('event_dispatcher');
// Add console commands (services console.command tagged)
foreach ($this->getTaggedCommands() as $id) {
$command = $this->container->get($id);
$this->add($command);
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$botCommands = [];
/** @var BundleInterface[] $modules */
$modules = $container->getParameter('kernel.modules');
foreach ($modules as $name => $module) {
$ref = new \ReflectionClass($module);
$dir = dirname($ref->getFileName());
$finder = new Finder();
$finder->files()->name('*BotCommand.php')->in($dir);
$moduleCommands = [];
$prefix = $ref->getNamespaceName();
/** @var SplFileInfo $file */
foreach ($finder as $file) {
$ns = $prefix;
if ($relativePath = $file->getRelativePath()) {
$ns .= '\\' . str_replace('/', '\\', $relativePath);
}
$class = $ns . '\\' . $file->getBasename('.php');
$reflection = new \ReflectionClass($class);
if ($this->isValidBotCommand($reflection)) {
$id = 'bot.command.' . strtolower(str_replace('\\', '_', $class));
$container->register($id, $class)->addArgument(new Reference('service_container'))->addTag('bot_command');
$botCommands[] = new Reference($id);
$moduleCommands[] = $id;
}
}
$container->setParameter('bot.' . $ref->getShortName() . '.commands', $moduleCommands);
}
$container->register('repository.command', BotCommandRepository::class)->setArguments([$botCommands]);
}
public function test_accessing_service_by_alias()
{
$this->containerBuilder->register('service', new SymfonyDefinition(\stdClass::class));
$this->containerBuilder->setAlias('service_alias', 'service');
$this->assertTrue($this->serviceContainer->definitionExists('service_alias'));
$this->assertSame(\stdClass::class, $this->serviceContainer->definitionClass('service_alias'));
}
/**
* Load balancer service
*
* @param array $config
* @param ContainerBuilder $container
*/
protected function loadBalancer(array $config, ContainerBuilder $container)
{
$container->register('meup_geo_location.balancer.random_strategy', 'Meup\\Bundle\\GeoLocationBundle\\Domain\\BalancingStrategy\\RandomStrategy');
$container->setAlias('meup_geo_location.balancer.strategy', $config['balancer']['strategy']);
$container->register('meup_geo_location.balancer_factory.default', 'Meup\\Bundle\\GeoLocationBundle\\Domain\\BalancerFactory')->addArgument('Meup\\Bundle\\GeoLocationBundle\\Domain\\Balancer')->addArgument(new Reference('meup_geo_location.balancer.strategy'));
$container->setAlias('meup_geo_location.balancer_factory', $config['balancer']['factory']);
}
/**
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::createService
*/
public function testCreateServiceFactoryService()
{
$builder = new ContainerBuilder();
$builder->register('baz_service')->setFactoryService('baz_factory')->setFactoryMethod('getInstance');
$builder->register('baz_factory', 'BazClass');
$this->assertInstanceOf('BazClass', $builder->get('baz_service'));
}
public function testProcess()
{
$container = new ContainerBuilder();
$container->register('a')->addArgument(new Reference('b'));
$container->register('b');
$this->process($container);
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
if (!$container->hasDefinition('cache.data_collector')) {
return;
}
// Create a factory service
$factoryId = 'cache.recorder_factory';
$factory = $container->register($factoryId, Factory::class);
// Check if logging support is enabled
if ($container->hasParameter('cache.logging')) {
$config = $container->getParameter('cache.logging');
$factory->addArgument(new Reference($config['logger']));
$factory->addArgument($config['level']);
}
$collectorDefinition = $container->getDefinition('cache.data_collector');
$serviceIds = $container->findTaggedServiceIds('cache.provider');
foreach (array_keys($serviceIds) as $id) {
// Get the pool definition and rename it.
$poolDefinition = $container->getDefinition($id);
$poolDefinition->setPublic(false);
$container->setDefinition($id . '.inner', $poolDefinition);
// Create a recording pool with a factory
$recorderDefinition = $container->register($id, DummyAdapter::class);
$recorderDefinition->setFactory([new Reference($factoryId), 'create']);
$recorderDefinition->addArgument($id);
$recorderDefinition->addArgument(new Reference($id . '.inner'));
$recorderDefinition->setTags($poolDefinition->getTags());
// Tell the collector to add the new instance
$collectorDefinition->addMethodCall('addInstance', [$id, new Reference($id)]);
}
}
public function process(ContainerBuilder $container)
{
$container->setParameter('json_api.controller_listener.class', ControllerListener::class);
$container->setParameter('json_api.symfony_integration.class', SymfonyIntegration::class);
$container->register('json_api.symfony_integration', '%json_api.symfony_integration.class%')->addMethodCall('setContainer', array(new Reference('service_container')));
$container->register('json_api.controller_listener', '%json_api.controller_listener.class%')->addMethodCall('setContainer', array(new Reference('service_container')))->addTag('kernel.event_listener', ['event' => 'kernel.controller', 'method' => 'onKernelController']);
}
/**
* @param array $configs
* @param ContainerBuilder $container
*/
private function registerPagers(array $configs, ContainerBuilder $container)
{
$shouldDisableRedirector = true;
foreach ($configs as $name => $config) {
$serviceId = sprintf("%s.%s", self::PREFIX_PAGER, $name);
$definition = $container->register($serviceId, $container->getParameter('kg_pager.class'));
// Sets the default items per page for the given pager.
if (isset($config['per_page'])) {
$definition->addArgument($config['per_page']);
}
// Changes the strategy, if this pager should merge last two pages
// given the following threshold.
if (isset($config['merge']) && $config['merge'] > 0) {
$strategyDefinition = new Definition($container->getParameter('kg_pager.strategy.last_page_merged.class'));
$strategyDefinition->addArgument($config['merge']);
$definition->addArgument($strategyDefinition);
}
// Wraps the pager inside a request decorator to have it automatically
// infer the current page from the request.
if ($config['key']) {
$definition = $container->register($serviceId, $container->getParameter('kg_pager.request_decorator.class'))->setArguments(array($definition, new Reference('request_stack'), $config['key']));
}
if ($config['redirect']) {
$shouldDisableRedirector = false;
$definition = $container->register($serviceId, $container->getParameter('kg_pager.bounds_check_decorator.class'))->setArguments(array($definition));
if ($config['key']) {
$definition->addArgument($config['key']);
}
}
}
if ($shouldDisableRedirector) {
$container->removeDefinition('kg_pager.out_of_bounds_redirector');
}
}
/**
*
* @return \Symfony\Component\DependencyInjection\ContainerBuilder
*/
private function getContainer()
{
$container = new ContainerBuilder();
$container->register('lunetics_locale.session_guesser');
$container->register('lunetics_locale.locale_session');
return $container;
}
/**
* Configure the given ContainerBuilder
*
* This method allows a plugin to register additional services with the
* service container.
*
* @param ContainerBuilder $container
*
* @return void
*/
public function configure(ContainerBuilder $container)
{
$container->register('packages.plugin.satis.subscriber', 'Terramar\\Packages\\Plugin\\Satis\\EventSubscriber')->addArgument(new Reference('packages.helper.resque'))->addArgument(new Reference('doctrine.orm.entity_manager'))->addTag('kernel.event_subscriber');
$container->register('packages.plugin.satis.config_helper', 'Terramar\\Packages\\Plugin\\Satis\\ConfigurationHelper')->addArgument(new Reference('doctrine.orm.entity_manager'))->addArgument('%app.root_dir%')->addArgument('%app.cache_dir%');
$container->getDefinition('packages.controller_manager')->addMethodCall('registerController', array(Actions::PACKAGE_EDIT, 'Terramar\\Packages\\Plugin\\Satis\\Controller::editAction'))->addMethodCall('registerController', array(Actions::PACKAGE_UPDATE, 'Terramar\\Packages\\Plugin\\Satis\\Controller::updateAction'));
$container->getDefinition('packages.command_registry')->addMethodCall('addCommand', array('Terramar\\Packages\\Plugin\\Satis\\Command\\BuildCommand'))->addMethodCall('addCommand', array('Terramar\\Packages\\Plugin\\Satis\\Command\\UpdateCommand'));
}
/**
*
*/
protected function initContainer()
{
$this->extension = new BaseM6WebRedisExtension();
$this->container = new ContainerBuilder();
$this->container->register('event_dispatcher', new EventDispatcher());
$this->container->registerExtension($this->extension);
$this->container->setParameter('kernel.debug', true);
}
public static function getContainer()
{
$builder = new ContainerBuilder();
$protoDefinition = $builder->register('bicycle_factory', 'PhpBench\\Benchmarks\\Container\\Acme\\BicycleFactory');
$protoDefinition->setScope(ContainerInterface::SCOPE_PROTOTYPE);
$definition = $builder->register('bicycle_factory_shared', 'PhpBench\\Benchmarks\\Container\\Acme\\BicycleFactory');
return $builder;
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage The service "foo" must be public as event subscribers are lazy-loaded.
*/
public function testPrivateEventSubscriber()
{
$container = new ContainerBuilder();
$container->register('foo', 'stdClass')->setPublic(false)->addTag('kernel.event_subscriber', array());
$container->register('event_dispatcher', 'stdClass');
$registerListenersPass = new RegisterListenersPass();
$registerListenersPass->process($container);
}
private function createContainer($tagConfig)
{
$container = new ContainerBuilder();
$container->register('mock_service');
$container->register('non_relevant_service');
$container->register('mock_extension_Service')->addTag('foo', $tagConfig);
return $container;
}
/**
* @group legacy
*/
public function testStrictFlagIsPreserved()
{
$container = new ContainerBuilder();
$container->register('bar');
$def = $container->register('foo')->addArgument(new Reference('bar', ContainerInterface::NULL_ON_INVALID_REFERENCE, false));
$this->process($container);
$this->assertFalse($def->getArgument(0)->isStrict());
}
/**
* Configure the given ContainerBuilder
*
* This method allows a plugin to register additional services with the
* service container.
*
* @param ContainerBuilder $container
*
* @return void
*/
public function configure(ContainerBuilder $container)
{
$container->register('packages.plugin.github.adapter', 'Terramar\\Packages\\Plugin\\GitHub\\SyncAdapter')->addArgument(new Reference('doctrine.orm.entity_manager'))->addArgument(new Reference('router.url_generator'));
$container->getDefinition('packages.helper.sync')->addMethodCall('registerAdapter', array(new Reference('packages.plugin.github.adapter')));
$container->register('packages.plugin.github.package_subscriber', 'Terramar\\Packages\\Plugin\\GitHub\\PackageSubscriber')->addArgument(new Reference('packages.plugin.github.adapter'))->addArgument(new Reference('doctrine.orm.entity_manager'))->addTag('kernel.event_subscriber');
$container->register('packages.plugin.github.remote_subscriber', 'Terramar\\Packages\\Plugin\\GitHub\\RemoteSubscriber')->addArgument(new Reference('packages.plugin.github.adapter'))->addArgument(new Reference('doctrine.orm.entity_manager'))->addTag('kernel.event_subscriber');
$container->getDefinition('packages.controller_manager')->addMethodCall('registerController', array(Actions::REMOTE_NEW, 'Terramar\\Packages\\Plugin\\GitHub\\Controller::newAction'))->addMethodCall('registerController', array(Actions::REMOTE_CREATE, 'Terramar\\Packages\\Plugin\\GitHub\\Controller::createAction'))->addMethodCall('registerController', array(Actions::REMOTE_EDIT, 'Terramar\\Packages\\Plugin\\GitHub\\Controller::editAction'))->addMethodCall('registerController', array(Actions::REMOTE_UPDATE, 'Terramar\\Packages\\Plugin\\GitHub\\Controller::updateAction'));
}
public function testProcessDoesNotSaveDuplicateReferences()
{
$container = new ContainerBuilder();
$container->register('a');
$container->register('b')->addArgument(new Definition(null, array($ref1 = new Reference('a'))))->addArgument(new Definition(null, array($ref2 = new Reference('a'))));
$graph = $this->process($container);
$this->assertEquals(2, count($graph->getNode('a')->getInEdges()));
}
private function createBuilder()
{
$container = new ContainerBuilder();
$container->register('doctrine.dbal.default_connection.event_manager', 'stdClass');
$container->register('doctrine.dbal.default_connection', 'stdClass');
$container->setParameter('doctrine.connections', array('default' => 'doctrine.dbal.default_connection'));
return $container;
}
/**
* {@inheritdoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$authenticator = $container->register('prayno.cas_authenticator', 'PRayno\\CasAuthBundle\\Security\\CasAuthenticator');
$authenticator->setArguments(array($config));
$container->register('prayno.cas_user_provider', 'PRayno\\CasAuthBundle\\Security\\User\\CasUserProvider');
}
/**
* @expectedException \InvalidArgumentException
* @expectedExceptionMessage The service "foo" must not be abstract as event listeners are lazy-loaded.
*/
public function testAbstractEventListener()
{
$container = new ContainerBuilder();
$container->register('foo', 'stdClass')->setAbstract(true)->addTag('kernel.event_listener', array());
$container->register('event_dispatcher', 'stdClass');
$registerListenersPass = new RegisterListenersPass();
$registerListenersPass->process($container);
}
public function testSerializerServiceCanBeJmsSerializer()
{
$this->container->register('jms_serializer.serializer', 'JMS\\Serializer\\Serializer');
$this->container->register('serializer', 'JMS\\Serializer\\Serializer');
$compiler = new SerializerConfigurationPass();
$compiler->process($this->container);
$this->assertSame('fos_rest.serializer.jms', (string) $this->container->getAlias('fos_rest.serializer'));
}
public function testProcess()
{
$container = new ContainerBuilder();
$container->register('a', 'class');
$container->register('b', 'class')->setSynthetic(true)->setPublic(true);
$container->register('c', 'class')->setAbstract(true);
$container->register('d', 'class')->setSynthetic(true);
$this->process($container);
}
public function testProcessWorksWithInlinedDefinitions()
{
$container = new ContainerBuilder();
$container->register('foo')->setPublic(false);
$container->register('bar')->setArguments(array(new Definition(null, array(new Reference('foo')))));
$this->process($container);
$this->assertTrue($container->hasDefinition('foo'));
$this->assertTrue($container->hasDefinition('bar'));
}
