If you are not using the loaders and therefore don't want
to depend on the Config component, set this flag to false.
| public setResourceTracking ( boolean $track ) | ||
| $track | boolean | true if you want to track resources, false otherwise |
/**
* @return SymfonyContainerBuilder
*/
public function compile()
{
$this->registerServices($this->parameters['services']);
$this->builder->setResourceTracking(false);
$this->builder->compile();
return $this->builder;
}
public function __construct()
{
$this->_delegateContainerBuilder = new \Symfony\Component\DependencyInjection\ContainerBuilder();
parent::__construct($this->_delegateContainerBuilder);
/**
* Turn off resource tracking.
*/
$this->_delegateContainerBuilder->setResourceTracking(false);
/**
* Add ourself as the first compiler pass.
*/
$this->_tubePressCompilerPasses[] = $this;
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$parameters = $container->getParameterBag()->all();
$definitions = $container->getDefinitions();
$aliases = $container->getAliases();
$exprLangProviders = $container->getExpressionLanguageProviders();
foreach ($container->getExtensions() as $extension) {
if ($extension instanceof PrependExtensionInterface) {
$extension->prepend($container);
}
}
foreach ($container->getExtensions() as $name => $extension) {
if (!($config = $container->getExtensionConfig($name))) {
// this extension was not called
continue;
}
$config = $container->getParameterBag()->resolveValue($config);
$tmpContainer = new ContainerBuilder($container->getParameterBag());
$tmpContainer->setResourceTracking($container->isTrackingResources());
$tmpContainer->addObjectResource($extension);
foreach ($exprLangProviders as $provider) {
$tmpContainer->addExpressionLanguageProvider($provider);
}
$extension->load($config, $tmpContainer);
$container->merge($tmpContainer);
$container->getParameterBag()->add($parameters);
}
$container->addDefinitions($definitions);
$container->addAliases($aliases);
}
public function testDumpOptimizationString()
{
$definition = new Definition();
$definition->setClass('stdClass');
$definition->addArgument(array(
'only dot' => '.',
'concatenation as value' => '.\'\'.',
'concatenation from the start value' => '\'\'.',
'.' => 'dot as a key',
'.\'\'.' => 'concatenation as a key',
'\'\'.' => 'concatenation from the start key',
'optimize concatenation' => 'string1%some_string%string2',
'optimize concatenation with empty string' => 'string1%empty_value%string2',
'optimize concatenation from the start' => '%empty_value%start',
'optimize concatenation at the end' => 'end%empty_value%',
));
$container = new ContainerBuilder();
$container->setResourceTracking(false);
$container->setDefinition('test', $definition);
$container->setParameter('empty_value', '');
$container->setParameter('some_string', '-');
$container->compile();
$dumper = new PhpDumper($container);
$this->assertStringEqualsFile(self::$fixturesPath.'/php/services10.php', $dumper->dump(), '->dump() dumps an empty container as an empty PHP class');
}
public function testProcessInlinesWhenThereAreMultipleReferencesButFromTheSameDefinition()
{
$container = new ContainerBuilder();
$container->setResourceTracking(false);
$container->register('a', '\\stdClass')->addArgument(new Reference('b'))->addMethodCall('setC', array(new Reference('c')));
$container->register('b', '\\stdClass')->addArgument(new Reference('c'))->setPublic(false);
$container->register('c', '\\stdClass')->setPublic(false);
$container->compile();
$this->assertTrue($container->hasDefinition('a'));
$this->assertFalse($container->hasDefinition('b'));
$this->assertFalse($container->hasDefinition('c'), 'Service C was not inlined.');
}
public function testLazyLoadedService()
{
$loader = new ClosureLoader($container = new ContainerBuilder());
$loader->load(function (ContainerBuilder $container) {
$container->set('a', new \BazClass());
$definition = new Definition('BazClass');
$definition->setLazy(true);
$container->setDefinition('a', $definition);
});
$container->setResourceTracking(true);
$container->compile();
$class = new \BazClass();
$reflectionClass = new \ReflectionClass($class);
$r = new \ReflectionProperty($container, 'resources');
$r->setAccessible(true);
$resources = $r->getValue($container);
$classInList = false;
foreach ($resources as $resource) {
if ($resource->getResource() === $reflectionClass->getFileName()) {
$classInList = true;
break;
}
}
$this->assertTrue($classInList);
}
/**
* @expectedException BadMethodCallException
*/
public function testThrowsExceptionWhenSetDefinitionOnAFrozenContainer()
{
$container = new ContainerBuilder();
$container->setResourceTracking(false);
$container->compile();
$container->setDefinition('a', new Definition());
}
/**
* Allow an extension to prepend the extension configurations.
*
* @param ContainerBuilder $container
*/
public function prepend(ContainerBuilder $container)
{
if (!$this instanceof EntitiesOverridableExtensionInterface) {
return;
}
$mappingConfiguration = $this->getConfigurationInstance();
if ($mappingConfiguration instanceof ConfigurationInterface) {
$config = $container->getExtensionConfig($this::getExtensionName());
$config = $container->getParameterBag()->resolveValue($config);
$tmpContainer = new ContainerBuilder($container->getParameterBag());
$tmpContainer->setResourceTracking($container->isTrackingResources());
$tmpContainer->addObjectResource($this);
$this->loadMappingConfiguration($tmpContainer, $mappingConfiguration, $config);
$container->merge($tmpContainer);
}
/**
* Perform overrides for Doctrine ORM mapping resolves
*/
$overrides = $this->getEntitiesOverrides();
foreach ($overrides as $interface => $override) {
$overrides[$interface] = $container->getParameter($override);
}
$container->prependExtensionConfig('doctrine', ['orm' => ['resolve_target_entities' => $overrides]]);
}
