public function process(ContainerBuilder $container)
{
$this->parameterBag = $container->getParameterBag();
foreach ($container->getDefinitions() as $definition) {
$definition->setClass($this->resolveValue($definition->getClass()));
$definition->setFile($this->resolveValue($definition->getFile()));
$definition->setArguments($this->resolveValue($definition->getArguments()));
$calls = array();
foreach ($definition->getMethodCalls() as $name => $arguments) {
$calls[$this->resolveValue($name)] = $this->resolveValue($arguments);
}
$definition->setMethodCalls($calls);
}
$aliases = array();
foreach ($container->getAliases() as $name => $target) {
$aliases[$this->resolveValue($name)] = $this->resolveValue($target);
}
$container->setAliases($aliases);
$injectors = array();
foreach ($container->getInterfaceInjectors() as $class => $injector) {
$injector->setClass($this->resolveValue($injector->getClass()));
$injectors[$this->resolveValue($class)] = $injector;
}
$container->setInterfaceInjectors($injectors);
$parameterBag = $container->getParameterBag();
foreach ($parameterBag->all() as $key => $value) {
$parameterBag->set($key, $this->resolveValue($value));
}
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
foreach ($container->getDefinitions() as $definition) {
foreach ($container->getInterfaceInjectors() as $injector) {
if (null !== $definition->getFactoryService()) {
continue;
}
$defClass = $container->getParameterBag()->resolveValue($definition->getClass());
$definition->setClass($defClass);
if ($injector->supports($defClass)) {
$injector->processDefinition($definition);
}
}
}
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
foreach ($container->getDefinitions() as $definition) {
$loaded = false;
foreach ($container->getInterfaceInjectors() as $injector) {
if (null !== $definition->getFactoryService()) {
continue;
}
if (false === $loaded && null !== $definition->getFile()) {
$loaded = true;
require_once $definition->getFile();
}
if ($injector->supports($definition->getClass())) {
$injector->processDefinition($definition);
}
}
}
}
public function testLoadInterfaceInjectors()
{
$container = new ContainerBuilder();
$loader = new ProjectLoader3($container, self::$fixturesPath . '/yaml');
$loader->load('interfaces1.yml');
$interfaces = $container->getInterfaceInjectors('FooClass');
$this->assertEquals(1, count($interfaces), '->load() parses interfaces');
$interface = $interfaces['FooClass'];
$this->assertTrue($interface->hasMethodCall('setBar'), '->load() parses interfaces elements');
}
/**
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::addInterfaceInjector
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::addInterfaceInjectors
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::getInterfaceInjectors
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::hasInterfaceInjectorForClass
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::setDefinition
*/
public function testInterfaceInjection()
{
$definition = new Definition('Symfony\\Tests\\Component\\DependencyInjection\\FooClass');
$injectors[] = $this->getMockInterfaceInjector('Symfony\\Tests\\Component\\DependencyInjection\\FooClass', 1);
$injectors[] = $this->getMockInterfaceInjector('Symfony\\Tests\\Component\\DependencyInjection\\FooClass', 0);
$container = new ContainerBuilder();
$container->addInterfaceInjectors($injectors);
$this->assertEquals(1, count($container->getInterfaceInjectors('Symfony\\Tests\\Component\\DependencyInjection\\FooClass')));
$this->assertTrue($container->hasInterfaceInjectorForClass('Symfony\\Tests\\Component\\DependencyInjection\\FooClass'));
$this->assertFalse($container->hasInterfaceInjectorForClass('\\Foo'));
$container->setDefinition('test', $definition);
$test = $container->get('test');
}
/**
* Merges a ContainerBuilder with the current ContainerBuilder configuration.
*
* Service definitions overrides the current defined ones.
*
* But for parameters, they are overridden by the current ones. It allows
* the parameters passed to the container constructor to have precedence
* over the loaded ones.
*
* $container = new ContainerBuilder(array('foo' => 'bar'));
* $loader = new LoaderXXX($container);
* $loader->load('resource_name');
* $container->register('foo', new stdClass());
*
* In the above example, even if the loaded resource defines a foo
* parameter, the value will still be 'bar' as defined in the ContainerBuilder
* constructor.
*/
public function merge(ContainerBuilder $container)
{
if (true === $this->isFrozen()) {
throw new \LogicException('Cannot merge on a frozen container.');
}
$this->addDefinitions($container->getDefinitions());
$this->addAliases($container->getAliases());
$this->addInterfaceInjectors($container->getInterfaceInjectors());
$this->parameterBag->add($container->getParameterBag()->all());
foreach ($container->getResources() as $resource) {
$this->addResource($resource);
}
foreach ($container->getExtensionConfigs() as $name => $configs) {
if (isset($this->extensionConfigs[$name])) {
$this->extensionConfigs[$name] = array_merge($this->extensionConfigs[$name], $configs);
} else {
$this->extensionConfigs[$name] = $configs;
}
}
}
public function testLoadInterfaceInjectors()
{
$container = new ContainerBuilder();
$loader = new XmlFileLoader($container, new FileLocator(self::$fixturesPath . '/xml'));
$loader->load('interfaces1.xml');
$interfaces = $container->getInterfaceInjectors('FooClass');
$this->assertEquals(1, count($interfaces), '->load() parses <interface> elements');
$interface = $interfaces['FooClass'];
$this->assertTrue($interface->hasMethodCall('setBar'), '->load() applies method calls correctly');
}
