Returns the compiler.
public getCompiler ( ) : |
||
리턴 | The compiler |
/** * 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)); } }
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); }
/** * 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)); }
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)); } }
/** * 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)); }
/** * 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(); }