Returns the compiler.
|
public getCompiler ( ) : |
||
| return | The compiler | |
private function then_compiler_passes_are_added()
{
$passes = $this->container->getCompiler()->getPassConfig()->getBeforeOptimizationPasses();
$classes = array_map(function ($pass) {
return get_class($pass);
}, $passes);
$expectedPassClasses = array('Devhelp\\PiwikBundle\\DependencyInjection\\Compiler\\AddPiwikClientDefinition', 'Devhelp\\PiwikBundle\\DependencyInjection\\Compiler\\InsertParamsServices');
$this->assertEquals($expectedPassClasses, $classes);
}
public function process(ContainerBuilder $container)
{
$compiler = $container->getCompiler();
$formatter = $compiler->getLoggingFormatter();
$tags = array_unique(array_merge($container->findTags(), $this->whitelist));
foreach ($container->findUnusedTags() as $tag) {
// skip whitelisted tags
if (in_array($tag, $this->whitelist)) {
continue;
}
// check for typos
$candidates = array();
foreach ($tags as $definedTag) {
if ($definedTag === $tag) {
continue;
}
if (false !== strpos($definedTag, $tag) || levenshtein($tag, $definedTag) <= strlen($tag) / 3) {
$candidates[] = $definedTag;
}
}
$services = array_keys($container->findTaggedServiceIds($tag));
$message = sprintf('Tag "%s" was defined on service(s) "%s", but was never used.', $tag, implode('", "', $services));
if (!empty($candidates)) {
$message .= sprintf(' Did you mean "%s"?', implode('", "', $candidates));
}
$compiler->addLogMessage($formatter->format($this, $message));
}
}
/**
* Process the ContainerBuilder to replace ChildDefinition instances with their real Definition instances.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->compiler = $container->getCompiler();
$this->formatter = $this->compiler->getLoggingFormatter();
$container->setDefinitions($this->resolveArguments($container, $container->getDefinitions(), true));
}
/**
* Processes the ContainerBuilder for inline service definitions.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->compiler = $container->getCompiler();
$this->formatter = $this->compiler->getLoggingFormatter();
$this->graph = $this->compiler->getServiceReferenceGraph();
$container->setDefinitions($this->inlineArguments($container, $container->getDefinitions(), true));
}
/**
* Gets the list of methods to autowire.
*
* @param string $id
* @param \ReflectionClass $reflectionClass
* @param string[] $autowiredMethods
*
* @return \ReflectionMethod[]
*/
private function getMethodsToAutowire($id, \ReflectionClass $reflectionClass, array $autowiredMethods)
{
$found = array();
$regexList = array();
foreach ($autowiredMethods as $pattern) {
$regexList[] = '/^'.str_replace('\*', '.*', preg_quote($pattern, '/')).'$/i';
}
foreach ($reflectionClass->getMethods(\ReflectionMethod::IS_PUBLIC) as $reflectionMethod) {
if ($reflectionMethod->isStatic()) {
continue;
}
foreach ($regexList as $k => $regex) {
if (preg_match($regex, $reflectionMethod->name)) {
$found[] = $autowiredMethods[$k];
yield $reflectionMethod;
continue 2;
}
}
}
if ($notFound = array_diff($autowiredMethods, $found)) {
$compiler = $this->container->getCompiler();
$compiler->addLogMessage($compiler->getLoggingFormatter()->formatUnusedAutowiringPatterns($this, $id, $notFound));
}
}
/**
* Processes a ContainerBuilder object to populate the service reference graph.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->container = $container;
$this->graph = $container->getCompiler()->getServiceReferenceGraph();
$this->graph->clear();
foreach ($container->getDefinitions() as $id => $definition) {
if ($definition->isSynthetic() || $definition->isAbstract()) {
continue;
}
$this->currentId = $id;
$this->currentDefinition = $definition;
$this->processArguments($definition->getArguments());
if ($definition->getFactoryService()) {
$this->processArguments(array(new Reference($definition->getFactoryService())));
}
if (!$this->onlyConstructorArguments) {
$this->processArguments($definition->getMethodCalls());
$this->processArguments($definition->getProperties());
if ($definition->getConfigurator()) {
$this->processArguments(array($definition->getConfigurator()));
}
}
}
foreach ($container->getAliases() as $id => $alias) {
$this->graph->connect($id, $alias, (string) $alias, $this->getDefinition((string) $alias), null);
}
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
if (!$this->integrationExtension->isTransactionalAutoGenerateProxy()) {
// Transactional system or auto generate proxy is disabled
return;
}
$transactionalId = $this->integrationExtension->getTransactionalService();
// Validate transactional service
$transactionalDefinition = $container->getDefinition($transactionalId);
$class = $transactionalDefinition->getClass();
try {
$class = $container->getParameterBag()->resolveValue($class);
$refClass = new \ReflectionClass($class);
$requiredInterface = 'FivePercent\\Component\\Transactional\\TransactionalInterface';
if (!$refClass->implementsInterface($requiredInterface)) {
throw new \RuntimeException(sprintf('The transactional service with class "%s" should implement %s.', $class, $requiredInterface));
}
} catch (\Exception $e) {
throw new \RuntimeException(sprintf('The transactional service with id "%s" is invalid.', $transactionalId), 0, $e);
}
// Get all services
$serviceIds = $container->getServiceIds();
$directory = $container->getParameter('kernel.cache_dir') . '/transactional';
foreach ($serviceIds as $serviceId) {
if ($container->hasAlias($serviceId)) {
// Not check in alias.
continue;
}
$serviceDefinition = $container->getDefinition($serviceId);
if ($serviceDefinition->isAbstract()) {
// Not check in abstract service.
continue;
}
$class = $serviceDefinition->getClass();
$class = $container->getParameterBag()->resolveValue($class);
if (!$class) {
continue;
}
try {
$proxyCodeGenerator = new ProxyFileGenerator($directory, $class);
} catch (\ReflectionException $e) {
$container->getCompiler()->addLogMessage(sprintf('%s Error with create proxy code generator for class "%s". Maybe class not found?', get_class($this), $class));
continue;
}
if ($proxyCodeGenerator->needGenerate()) {
// Generate proxy file
$filePath = $proxyCodeGenerator->generate();
$serviceDefinition->setClass($proxyCodeGenerator->getProxyClassName());
// Add "__setTransactional" method call for set transactional layer
$methodCalls = $serviceDefinition->getMethodCalls();
array_unshift($methodCalls, ['___setTransactional', [new Reference($transactionalId)]]);
$serviceDefinition->setMethodCalls($methodCalls);
// Add resource for control cache
$container->addResource(new FileResource($filePath));
$realClassReflection = new \ReflectionClass($class);
$container->addResource(new FileResource($realClassReflection->getFileName()));
}
}
}
/**
* Processes the ContainerBuilder for inline service definitions.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->graph = $container->getCompiler()->getServiceReferenceGraph();
foreach ($container->getDefinitions() as $definition) {
$definition->setArguments($this->inlineArguments($container, $definition->getArguments()));
$definition->setMethodCalls($this->inlineArguments($container, $definition->getMethodCalls()));
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
if (FALSE === $container->hasDefinition('webprofiler.services')) {
return;
}
$definition = $container->getDefinition('webprofiler.services');
$graph = $container->getCompiler()->getServiceReferenceGraph();
$definition->addMethodCall('setServices', [$this->extractData($container, $graph)]);
}
/**
* Checks the ContainerBuilder object for circular references.
*
* @param ContainerBuilder $container The ContainerBuilder instances
*/
public function process(ContainerBuilder $container)
{
$graph = $container->getCompiler()->getServiceReferenceGraph();
foreach ($graph->getNodes() as $id => $node) {
$this->currentId = $id;
$this->currentPath = array($id);
$this->checkOutEdges($node->getOutEdges());
}
}
public function build(ContainerBuilder $container)
{
$config = $container->getCompiler()->getPassConfig();
$passes = $config->getBeforeOptimizationPasses();
array_unshift($passes, new AnnotationConfigurationPass($this->kernel));
$config->setBeforeOptimizationPasses($passes);
$container->addCompilerPass(new IntegrationPass());
$container->addCompilerPass(new ResourceOptimizationPass(), PassConfig::TYPE_AFTER_REMOVING);
}
private function registerLegacyPass(ContainerBuilder $container)
{
$passConfig = $container->getCompiler()->getPassConfig();
$passConfig->setAfterRemovingPasses(array());
$passConfig->setBeforeOptimizationPasses(array());
$passConfig->setBeforeRemovingPasses(array());
$passConfig->setOptimizationPasses(array());
$passConfig->setRemovingPasses(array());
$container->addCompilerPass(new LegacyPass());
}
/**
* Process the repeatable passes that run more than once.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$compiler = $container->getCompiler();
$this->repeat = false;
foreach ($this->passes as $pass) {
$pass->process($container);
}
if ($this->repeat) {
$this->process($container);
}
}
/**
* Removes abstract definitions from the ContainerBuilder
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$compiler = $container->getCompiler();
$formatter = $compiler->getLoggingFormatter();
foreach ($container->getDefinitions() as $id => $definition) {
if ($definition->isAbstract()) {
$container->removeDefinition($id);
$compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'abstract'));
}
}
}
/**
* Processes the ContainerBuilder for inline service definitions.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->compiler = $container->getCompiler();
$this->formatter = $this->compiler->getLoggingFormatter();
$this->graph = $this->compiler->getServiceReferenceGraph();
foreach ($container->getDefinitions() as $id => $definition) {
$this->currentId = $id;
$definition->setArguments($this->inlineArguments($container, $definition->getArguments()));
$definition->setMethodCalls($this->inlineArguments($container, $definition->getMethodCalls()));
$definition->setProperties($this->inlineArguments($container, $definition->getProperties()));
}
}
/**
* Removes private aliases from the ContainerBuilder
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$compiler = $container->getCompiler();
$formatter = $compiler->getLoggingFormatter();
foreach ($container->getAliases() as $id => $alias) {
if ($alias->isPublic()) {
continue;
}
$container->removeAlias($id);
$compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'private alias'));
}
}
public function process(ContainerBuilder $container)
{
$compiler = $container->getCompiler();
$this->repeat = false;
foreach ($this->passes as $pass) {
$time = microtime(true);
$pass->process($container);
$compiler->addLogMessage(sprintf('%s finished in %.3fs', get_class($pass), microtime(true) - $time));
}
if ($this->repeat) {
$this->process($container);
}
}
/**
* Process the ContainerBuilder to replace DefinitionDecorator instances with their real Definition instances.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->container = $container;
$this->compiler = $container->getCompiler();
$this->formatter = $this->compiler->getLoggingFormatter();
foreach (array_keys($container->getDefinitions()) as $id) {
// yes, we are specifically fetching the definition from the
// container to ensure we are not operating on stale data
$definition = $container->getDefinition($id);
if (!$definition instanceof DefinitionDecorator || $definition->isAbstract()) {
continue;
}
$this->resolveDefinition($id, $definition);
}
}
/**
* Process the Container to replace aliases with service definitions.
*
* @param ContainerBuilder $container
*
* @throws InvalidArgumentException if the service definition does not exist
*/
public function process(ContainerBuilder $container)
{
// Setup
$this->compiler = $container->getCompiler();
$this->formatter = $this->compiler->getLoggingFormatter();
// First collect all alias targets that need to be replaced
$seenAliasTargets = array();
$replacements = array();
foreach ($container->getAliases() as $definitionId => $target) {
$targetId = (string) $target;
// Special case: leave this target alone
if ('service_container' === $targetId) {
continue;
}
// Check if target needs to be replaces
if (isset($replacements[$targetId])) {
$container->setAlias($definitionId, $replacements[$targetId]);
}
// No neeed to process the same target twice
if (isset($seenAliasTargets[$targetId])) {
continue;
}
// Process new target
$seenAliasTargets[$targetId] = true;
try {
$definition = $container->getDefinition($targetId);
} catch (InvalidArgumentException $e) {
throw new InvalidArgumentException(sprintf('Unable to replace alias "%s" with actual definition "%s".', $definitionId, $targetId), null, $e);
}
if ($definition->isPublic()) {
continue;
}
// Remove private definition and schedule for replacement
$definition->setPublic(true);
$container->setDefinition($definitionId, $definition);
$container->removeDefinition($targetId);
$replacements[$targetId] = $definitionId;
}
// Now replace target instances in all definitions
foreach ($container->getDefinitions() as $definitionId => $definition) {
$definition->setArguments($this->updateArgumentReferences($replacements, $definitionId, $definition->getArguments()));
$definition->setMethodCalls($this->updateArgumentReferences($replacements, $definitionId, $definition->getMethodCalls()));
$definition->setProperties($this->updateArgumentReferences($replacements, $definitionId, $definition->getProperties()));
$definition->setFactoryService($this->updateFactoryReferenceId($replacements, $definition->getFactoryService(false)), false);
$definition->setFactory($this->updateFactoryReference($replacements, $definition->getFactory()));
}
}
/**
* Processes the ContainerBuilder to remove unused definitions.
*
* @param ContainerBuilder $container
* @return void
*/
public function process(ContainerBuilder $container)
{
$compiler = $container->getCompiler();
$formatter = $compiler->getLoggingFormatter();
$graph = $compiler->getServiceReferenceGraph();
$hasChanged = false;
foreach ($container->getDefinitions() as $id => $definition) {
if ($definition->isPublic()) {
continue;
}
if ($graph->hasNode($id)) {
$edges = $graph->getNode($id)->getInEdges();
$referencingAliases = array();
$sourceIds = array();
foreach ($edges as $edge) {
$node = $edge->getSourceNode();
$sourceIds[] = $node->getId();
if ($node->isAlias()) {
$referencingAlias[] = $node->getValue();
}
}
$isReferenced = (count(array_unique($sourceIds)) - count($referencingAliases)) > 0;
} else {
$referencingAliases = array();
$isReferenced = false;
}
if (1 === count($referencingAliases) && false === $isReferenced) {
$container->setDefinition((string) reset($referencingAliases), $definition);
$definition->setPublic(true);
$container->removeDefinition($id);
$compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'replaces alias '.reset($referencingAliases)));
} else if (0 === count($referencingAliases) && false === $isReferenced) {
$container->removeDefinition($id);
$compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'unused'));
$hasChanged = true;
}
}
if ($hasChanged) {
$this->repeatedPass->setRepeat();
}
}
public function process(ContainerBuilder $container)
{
$this->container = $container;
$this->graph = $container->getCompiler()->getServiceReferenceGraph();
$this->graph->clear();
foreach ($container->getDefinitions() as $id => $definition) {
$this->currentId = $id;
$this->currentDefinition = $definition;
$this->processArguments($definition->getArguments());
if (!$this->ignoreMethodCalls) {
$this->processArguments($definition->getMethodCalls());
}
}
foreach ($container->getAliases() as $id => $alias) {
$this->graph->connect($id, $alias, (string) $alias, $this->getDefinition((string) $alias), null);
}
}
/**
* Process the Container to replace aliases with service definitions.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->compiler = $container->getCompiler();
$this->formatter = $this->compiler->getLoggingFormatter();
foreach ($container->getAliases() as $id => $alias) {
$aliasId = (string) $alias;
$definition = $container->getDefinition($aliasId);
if ($definition->isPublic()) {
continue;
}
$definition->setPublic(true);
$container->setDefinition($id, $definition);
$container->removeDefinition($aliasId);
$this->updateReferences($container, $aliasId, $id);
// we have to restart the process due to concurrent modification of
// the container
$this->process($container);
break;
}
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
$handlerRegistryDefinition = $container->getDefinition('api.handler_registry');
foreach ($container->findTaggedServiceIds('api.handler') as $id => $attributes) {
$attributes = $this->fixAttributes($attributes);
try {
if (empty($attributes['key'])) {
throw new \RuntimeException('Missing attribute "key".');
}
$key = $attributes['key'];
$definition = $container->getDefinition($id);
if (isset($this->handlers[$key])) {
throw new \RuntimeException(sprintf('The handler with key "%s" already registered for service "%s". ' . 'If you want change handler, please replace service in your service.yml', $key, $this->handlers[$key]));
}
$class = $definition->getClass();
$class = $container->getParameterBag()->resolveValue($class);
$refClass = new \ReflectionClass($class);
$requiredInterface = 'FivePercent\\Component\\Api\\Handler\\HandlerInterface';
if (!$refClass->implementsInterface($requiredInterface)) {
throw new \RuntimeException(sprintf('The API handler should be implemented of "%s" interface.', $requiredInterface));
}
$this->handlers[$key] = $id;
if (!$definition->isPublic() || $definition->isAbstract()) {
$container->getCompiler()->addLogMessage(sprintf('%s: Attention: can not add API handler with id "%s" to manager. ' . 'The handler is abstract or not public.', get_class($this), $id));
} else {
$handlerRegistryDefinition->addMethodCall('addHandler', [$key, $id]);
}
if (!empty($attributes['service_loader'])) {
$this->serviceLoaders[$id] = $attributes['service_loader'];
}
if (!empty($attributes['errors'])) {
$this->errorServices[$id] = $attributes['errors'];
}
} catch (\Exception $e) {
throw new \RuntimeException(sprintf('Could not compile API handler with service id "%s".', $id), 0, $e);
}
}
}
/**
* Process the Container to replace aliases with service definitions.
*
* @param ContainerBuilder $container
*
* @throws InvalidArgumentException if the service definition does not exist
*/
public function process(ContainerBuilder $container)
{
$this->compiler = $container->getCompiler();
$this->formatter = $this->compiler->getLoggingFormatter();
foreach ($container->getAliases() as $id => $alias) {
$aliasId = (string) $alias;
try {
$definition = $container->getDefinition($aliasId);
} catch (InvalidArgumentException $e) {
throw new InvalidArgumentException(sprintf('Unable to replace alias "%s" with "%s".', $alias, $id), null, $e);
}
if ($definition->isPublic()) {
continue;
}
$definition->setPublic(true);
$container->setDefinition($id, $definition);
$container->removeDefinition($aliasId);
$this->updateReferences($container, $aliasId, $id);
// we have to restart the process due to concurrent modification of
// the container
$this->process($container);
break;
}
}
public function testAddGetCompilerPass()
{
$builder = new ContainerBuilder();
$builder->setResourceTracking(false);
$defaultPasses = $builder->getCompiler()->getPassConfig()->getPasses();
$builder->addCompilerPass($pass1 = $this->getMockBuilder('Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface')->getMock(), PassConfig::TYPE_BEFORE_OPTIMIZATION, -5);
$builder->addCompilerPass($pass2 = $this->getMockBuilder('Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface')->getMock(), PassConfig::TYPE_BEFORE_OPTIMIZATION, 10);
$passes = $builder->getCompiler()->getPassConfig()->getPasses();
$this->assertCount(count($passes) - 2, $defaultPasses);
// Pass 1 is executed later
$this->assertTrue(array_search($pass1, $passes, true) > array_search($pass2, $passes, true));
}
/**
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::addCompilerPass
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::getCompilerPassConfig
*/
public function testAddGetCompilerPass()
{
$builder = new ContainerBuilder();
$builder->setResourceTracking(false);
$builderCompilerPasses = $builder->getCompiler()->getPassConfig()->getPasses();
$builder->addCompilerPass($this->getMock('Symfony\\Component\\DependencyInjection\\Compiler\\CompilerPassInterface'));
$this->assertEquals(sizeof($builderCompilerPasses) + 1, sizeof($builder->getCompiler()->getPassConfig()->getPasses()));
}
public function build(ContainerBuilder $container)
{
$config = $container->getCompiler()->getPassConfig();
$container->addCompilerPass(new CollectAsyncTasksPass(), $config::TYPE_AFTER_REMOVING);
}
/**
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::addCompilerPass
* @covers Symfony\Component\DependencyInjection\ContainerBuilder::getCompilerPassConfig
*/
public function testAddGetCompilerPass()
{
if (!class_exists('Symfony\\Component\\Config\\Resource\\FileResource')) {
$this->markTestSkipped('The "Config" component is not available');
}
$builder = new ContainerBuilder();
$builderCompilerPasses = $builder->getCompiler()->getPassConfig()->getPasses();
$builder->addCompilerPass($this->getMock('Symfony\\Component\\DependencyInjection\\Compiler\\CompilerPassInterface'));
$this->assertEquals(sizeof($builderCompilerPasses) + 1, sizeof($builder->getCompiler()->getPassConfig()->getPasses()));
}
public function getCompiler()
{
return $this->delegate->getCompiler();
}
