/**
* Processes the ContainerBuilder to resolve parameter placeholders.
*
* @param ContainerBuilder $container
*
* @throws ParameterNotFoundException
*/
public function process(ContainerBuilder $container)
{
$parameterBag = $container->getParameterBag();
foreach ($container->getDefinitions() as $id => $definition) {
try {
$definition->setClass($parameterBag->resolveValue($definition->getClass()));
$definition->setFile($parameterBag->resolveValue($definition->getFile()));
$definition->setArguments($parameterBag->resolveValue($definition->getArguments()));
if ($definition->getFactoryClass(false)) {
$definition->setFactoryClass($parameterBag->resolveValue($definition->getFactoryClass(false)));
}
$factory = $definition->getFactory();
if (is_array($factory) && isset($factory[0])) {
$factory[0] = $parameterBag->resolveValue($factory[0]);
$definition->setFactory($factory);
}
$calls = array();
foreach ($definition->getMethodCalls() as $name => $arguments) {
$calls[$parameterBag->resolveValue($name)] = $parameterBag->resolveValue($arguments);
}
$definition->setMethodCalls($calls);
$definition->setProperties($parameterBag->resolveValue($definition->getProperties()));
} catch (ParameterNotFoundException $e) {
$e->setSourceId($id);
throw $e;
}
}
$aliases = array();
foreach ($container->getAliases() as $name => $target) {
$aliases[$parameterBag->resolveValue($name)] = $parameterBag->resolveValue($target);
}
$container->setAliases($aliases);
$parameterBag->resolve();
}
public function process(ContainerBuilder $container)
{
if ($container->has('fos_rest.serializer')) {
$class = $container->getParameterBag()->resolveValue($container->findDefinition('fos_rest.serializer')->getClass());
if (!is_subclass_of($class, 'FOS\\RestBundle\\Serializer\\Serializer')) {
throw new \InvalidArgumentException(sprintf('"fos_rest.serializer" must implement FOS\\RestBundle\\Serializer\\Serializer (instance of "%s" given).', $class));
}
return;
}
if (!$container->has('serializer') && !$container->has('jms_serializer.serializer')) {
throw new \InvalidArgumentException('Neither a service called "jms_serializer.serializer" nor "serializer" is available and no serializer is explicitly configured. You must either enable the JMSSerializerBundle, enable the FrameworkBundle serializer or configure a custom serializer.');
}
if ($container->has('serializer')) {
$class = $container->getParameterBag()->resolveValue($container->findDefinition('serializer')->getClass());
if (is_subclass_of($class, 'Symfony\\Component\\Serializer\\SerializerInterface')) {
$container->setAlias('fos_rest.serializer', 'fos_rest.serializer.symfony');
$container->removeDefinition('fos_rest.serializer.exception_wrapper_serialize_handler');
} elseif (is_subclass_of($class, 'JMS\\Serializer\\SerializerInterface')) {
$container->setAlias('fos_rest.serializer', 'fos_rest.serializer.jms');
} elseif (is_subclass_of($class, 'FOS\\RestBundle\\Serializer\\Serializer')) {
$container->setAlias('fos_rest.serializer', 'serializer');
} else {
throw new \InvalidArgumentException(sprintf('"fos_rest.serializer" must implement FOS\\RestBundle\\Serializer\\Serializer (instance of "%s" given).', $class));
}
return;
} else {
$container->removeDefinition('fos_rest.serializer.exception_wrapper_normalizer');
}
if ($container->has('jms_serializer.serializer')) {
$container->setAlias('fos_rest.serializer', 'fos_rest.serializer.jms');
} else {
$container->removeDefinition('fos_rest.serializer.exception_wrapper_serialize_handler');
}
}
/**
* Collect information about services and parameters from the cached dumped xml container
*
* @param Request $request The Request Object
* @param Response $response The Response Object
* @param \Exception $exception The Exception
*/
public function collect(Request $request, Response $response, \Exception $exception = null)
{
$parameters = array();
$services = array();
$this->loadContainerBuilder();
if ($this->containerBuilder !== false) {
foreach ($this->containerBuilder->getParameterBag()->all() as $key => $value) {
$service = substr($key, 0, strpos($key, '.'));
if (!isset($parameters[$service])) {
$parameters[$service] = array();
}
$parameters[$service][$key] = $value;
}
$serviceIds = $this->containerBuilder->getServiceIds();
foreach ($serviceIds as $serviceId) {
$definition = $this->resolveServiceDefinition($serviceId);
if ($definition instanceof Definition && $definition->isPublic()) {
$services[$serviceId] = array('class' => $definition->getClass(), 'scope' => $definition->getScope());
} elseif ($definition instanceof Alias) {
$services[$serviceId] = array('alias' => $definition);
} else {
continue;
// We don't want private services
}
}
ksort($services);
ksort($parameters);
}
$this->data['parameters'] = $parameters;
$this->data['services'] = $services;
}
/**
* Processes the ContainerBuilder to resolve parameter placeholders.
*
* @param ContainerBuilder $container
*/
public function process(ContainerBuilder $container)
{
$this->parameterBag = $container->getParameterBag();
foreach ($container->getDefinitions() as $id => $definition) {
try {
$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);
$definition->setProperties($this->resolveValue($definition->getProperties()));
} catch (ParameterNotFoundException $e) {
$e->setSourceId($id);
throw $e;
}
}
$aliases = array();
foreach ($container->getAliases() as $name => $target) {
$aliases[$this->resolveValue($name)] = $this->resolveValue($target);
}
$container->setAliases($aliases);
$parameterBag = $container->getParameterBag();
foreach ($parameterBag->all() as $key => $value) {
try {
$parameterBag->set($key, $this->resolveValue($value));
} catch (ParameterNotFoundException $e) {
$e->setSourceKey($key);
throw $e;
}
}
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
if ($container->has('swarrot.factory.default') || !$container->hasParameter('swarrot.provider_config')) {
return;
}
$providersIds = [];
foreach ($container->findTaggedServiceIds('swarrot.provider_factory') as $id => $tags) {
foreach ($tags as $tag) {
if (!isset($tag['alias'])) {
throw new \InvalidArgumentException(sprintf('The provider\'s alias is no defined for the service "%s"', $id));
}
$providersIds[$tag['alias']] = $id;
}
}
list($provider, $connections) = $container->getParameter('swarrot.provider_config');
if (!isset($providersIds[$provider])) {
throw new \InvalidArgumentException(sprintf('Invalid provider "%s"', $provider));
}
$id = $providersIds[$provider];
$definition = $container->getDefinition($id);
$className = $container->getParameterBag()->resolveValue($definition->getClass());
$reflection = new \ReflectionClass($className);
if (!$reflection->implementsInterface('Swarrot\\SwarrotBundle\\Broker\\FactoryInterface')) {
throw new \InvalidArgumentException(sprintf('The provider "%s" is not valid', $provider));
}
foreach ($connections as $name => $connectionConfig) {
$definition->addMethodCall('addConnection', [$name, $connectionConfig]);
}
$container->setAlias('swarrot.factory.default', $id);
$container->getParameterBag()->remove('swarrot.provider_config');
}
/**
* Loads the configuration.
*
* @param array $configs An array of configuration settings
* @param ContainerBuilder $container A ContainerBuilder instance
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('assetic.xml');
$loader->load('templating_twig.xml');
// $loader->load('templating_php.xml'); // not ready yet
$config = self::processConfigs($configs, $container->getParameter('kernel.debug'), array_keys($container->getParameter('kernel.bundles')));
$container->setParameter('assetic.debug', $config['debug']);
$container->setParameter('assetic.use_controller', $config['use_controller']);
$container->setParameter('assetic.read_from', $config['read_from']);
$container->setParameter('assetic.write_to', $config['write_to']);
$container->setParameter('assetic.default_javascripts_output', $config['default_javascripts_output']);
$container->setParameter('assetic.default_stylesheets_output', $config['default_stylesheets_output']);
if (isset($config['closure'])) {
$container->setParameter('assetic.google_closure_compiler_jar', $config['closure']);
$loader->load('google_closure_compiler.xml');
}
if (isset($config['yui'])) {
$container->setParameter('assetic.yui_jar', $config['yui']);
$loader->load('yui_compressor.xml');
}
if ($container->getParameterBag()->resolveValue($container->getParameterBag()->get('assetic.use_controller'))) {
$loader->load('controller.xml');
$container->setParameter('assetic.twig_extension.class', '%assetic.twig_extension.dynamic.class%');
} else {
$loader->load('asset_writer.xml');
$container->setParameter('assetic.twig_extension.class', '%assetic.twig_extension.static.class%');
}
if ($container->hasParameter('assetic.less.compress')) {
$container->getDefinition('assetic.filter.less')->addMethodCall('setCompress', array('%assetic.less.compress%'));
}
$this->registerFormulaResources($container, $container->getParameterBag()->resolveValue($config['bundles']));
}
/**
* Loads the configuration.
*
* When the debug flag is true, files in an asset collections will be
* rendered individually.
*
* In XML:
*
* <assetic:config
* debug="true"
* use-controller="true"
* document-root="/path/to/document/root"
* closure="/path/to/google_closure/compiler.jar"
* yui="/path/to/yuicompressor.jar"
* default-javascripts-output="js/build/*.js"
* default-stylesheets-output="css/build/*.css"
* />
*
* In YAML:
*
* assetic:
* debug: true
* use_controller: true
* document_root: /path/to/document/root
* closure: /path/to/google_closure/compiler.jar
* yui: /path/to/yuicompressor.jar
* default_javascripts_output: js/build/*.js
* default_stylesheets_output: css/build/*.css
*
* @param array $configs An array of configuration settings
* @param ContainerBuilder $container A ContainerBuilder instance
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('assetic.xml');
$loader->load('templating_twig.xml');
// $loader->load('templating_php.xml'); // not ready yet
$configuration = new Configuration();
$processor = new Processor();
$config = $processor->process($configuration->getConfigTree($container->getParameter('kernel.debug')), $configs);
$container->setParameter('assetic.debug', $config['debug']);
$container->setParameter('assetic.use_controller', $config['use_controller']);
$container->setParameter('assetic.document_root', $config['document_root']);
$container->setParameter('assetic.default_javascripts_output', $config['default_javascripts_output']);
$container->setParameter('assetic.default_stylesheets_output', $config['default_stylesheets_output']);
if (isset($config['closure'])) {
$container->setParameter('assetic.google_closure_compiler_jar', $config['closure']);
$loader->load('google_closure_compiler.xml');
}
if (isset($config['yui'])) {
$container->setParameter('assetic.yui_jar', $config['yui']);
$loader->load('yui_compressor.xml');
}
if ($container->getParameterBag()->resolveValue($container->getParameterBag()->get('assetic.use_controller'))) {
$loader->load('controller.xml');
$container->setParameter('assetic.twig_extension.class', '%assetic.twig_extension.dynamic.class%');
} else {
$loader->load('asset_writer.xml');
$container->setParameter('assetic.twig_extension.class', '%assetic.twig_extension.static.class%');
}
if ($container->hasParameter('assetic.less.compress')) {
$container->getDefinition('assetic.filter.less')->addMethodCall('setCompress', array('%assetic.less.compress%'));
}
}
public function process(ContainerBuilder $container)
{
$fingersCrossedHandlersId = 'long_running.monolog.clear_fingers_crossed_handlers';
if ($container->has($fingersCrossedHandlersId)) {
$fingersCrossedServiceReferences = [];
foreach ($container->getDefinitions() as $serviceId => $definition) {
if (strpos($serviceId, 'monolog.handler.') === 0) {
$class = $container->getParameterBag()->resolveValue($definition->getClass());
if (is_a($class, 'Monolog\\Handler\\FingersCrossedHandler', true)) {
$fingersCrossedServiceReferences[] = new Reference($serviceId);
}
}
}
$definition = $container->getDefinition($fingersCrossedHandlersId);
$definition->replaceArgument(0, $fingersCrossedServiceReferences);
}
$bufferHandlersId = 'long_running.monolog.close_buffer_handlers';
if ($container->has($bufferHandlersId)) {
$bufferHandlerServiceReferences = [];
foreach ($container->getDefinitions() as $serviceId => $definition) {
if (strpos($serviceId, 'monolog.handler.') === 0) {
$class = $container->getParameterBag()->resolveValue($definition->getClass());
if (is_a($class, 'Monolog\\Handler\\BufferHandler', true)) {
$bufferHandlerServiceReferences[] = new Reference($serviceId);
}
}
}
$definition = $container->getDefinition($bufferHandlersId);
$definition->replaceArgument(0, $bufferHandlerServiceReferences);
}
}
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)
{
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()));
}
}
}
public function testDefaultConfiguration()
{
// An extension is only loaded in the container if a configuration is provided for it.
// Then, we need to explicitely load it.
$this->container->loadFromExtension($this->extension->getAlias());
$this->container->compile();
$this->assertTrue($this->container->getParameterBag()->has('gg_team_breadcrumb'));
}
/** {@inheritdoc} */
protected function loadInternal(array $mergedConfig, ContainerBuilder $container)
{
$container->getParameterBag()->set('basster_legacy_bridge.legacy_path', $mergedConfig['legacy_path']);
$container->getParameterBag()->set('basster_legacy_bridge.prepend_script', $mergedConfig['prepend_script']);
$container->getParameterBag()->set('basster_legacy_bridge.append_script', $mergedConfig['append_script']);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
}
public function process(ContainerBuilder $container)
{
if ($container->hasDefinition('assetic.filter.yui_css') && !$container->getParameterBag()->resolveValue($container->getParameter('assetic.filter.yui_css.jar'))) {
throw new \RuntimeException('The "assetic.filters.yui_css" configuration requires a "jar" value.');
}
if ($container->hasDefinition('assetic.filter.yui_js') && !$container->getParameterBag()->resolveValue($container->getParameter('assetic.filter.yui_js.jar'))) {
throw new \RuntimeException('The "assetic.filters.yui_js" configuration requires a "jar" value.');
}
}
public function testLoad()
{
$this->skrzAutowiringExtension->load(["autowiring" => ["ignored_services" => [1], "preferred_services" => [2], "autoscan_psr4" => [3]]], $this->containerBuilder);
$parameterBag = $this->containerBuilder->getParameterBag();
$this->assertSame([1], $parameterBag->get("autowiring.ignored_services"));
$this->assertSame([2], $parameterBag->get("autowiring.preferred_services"));
$this->assertSame([3], $parameterBag->get("autowiring.autoscan_psr4"));
$this->assertSame(["@Component", "@Controller", "@Repository", "@Service"], $parameterBag->get("autowiring.fast_annotation_checks"));
}
/**
* Register the sections configuration as service-container parameters
* and a RequestMatcher service.
*
* The following pattern is used, where '{service-prefix}' is the value of $servicePrefix
* and '{section-name}' the name the processed section (repeated for each registered section).
*
* Like:
*
* '{service-prefix}.{section-name}.host' => 'example.com'
* '{service-prefix}.{section-name}.host_pattern' => '^example\.com$'
* '{service-prefix}.{section-name}.prefix' => '/'
* '{service-prefix}.{section-name}.path' => '^/(?!(backend|api)/)'
* '{service-prefix}.{section-name}.request_matcher' => {RequestMatcher service}
*
* Note: when the host is empty the 'host_pattern' is '.*' (as the route requirement)
* cannot be empty. The host pattern for the request_matcher is null then.
*
* @param ContainerBuilder $container
*/
public function registerToContainer(ContainerBuilder $container)
{
foreach ($this->resolveSections($this->sections) as $name => $config) {
$servicePrefix = rtrim($config['service_prefix'], '.') . '.';
$container->setParameter($servicePrefix . $name . '.host', (string) $config['host']);
$container->setParameter($servicePrefix . $name . '.host_pattern', (string) ($config['host_pattern'] ?: '.*'));
$container->setParameter($servicePrefix . $name . '.prefix', $config['prefix']);
$container->setParameter($servicePrefix . $name . '.path', $config['path']);
$container->register($servicePrefix . $name . '.request_matcher', RequestMatcher::class)->setArguments([$container->getParameterBag()->escapeValue($config['path']), $container->getParameterBag()->escapeValue($config['host_pattern'])]);
}
}
public function testParametersAreCreated()
{
$this->extension->load($this->config, $this->containerBuilder);
$parameters = $this->containerBuilder->getParameterBag();
$this->assertEquals(44, count($parameters->all()));
$this->assertTrue($parameters->has('apinnecke_oauth.resource_owners'));
$this->assertTrue($parameters->has('apinnecke_oauth.resource_owners.xing.client_id'));
$this->assertTrue($parameters->has('apinnecke_oauth.resource_owners.xing.client_secret'));
$this->assertTrue($parameters->has('apinnecke_oauth.resource_owners.xing.callback_url'));
$this->assertTrue($parameters->has('apinnecke_oauth.resource_owners.facebook.client_id'));
$this->assertTrue($parameters->has('apinnecke_oauth.resource_owners.facebook.client_secret'));
$this->assertTrue($parameters->has('apinnecke_oauth.resource_owners.facebook.callback_url'));
}
public function process(ContainerBuilder $container)
{
$useController = $container->getParameterBag()->resolveValue($container->getParameter('assetic.use_controller'));
$routerResource = $container->getParameterBag()->resolveValue($container->getParameter('router.resource'));
if (!$useController || !$routerResource) {
return;
}
$file = $container->getParameter('kernel.cache_dir') . '/assetic/routing.yml';
if (!is_dir($dir = dirname($file))) {
mkdir($dir, 0777, true);
}
file_put_contents($file, Yaml::dump(array('_assetic' => array('resource' => '.', 'type' => 'assetic'), '_app' => array('resource' => $container->getParameter('router.resource')))));
$container->setParameter('router.resource', $file);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
if (!in_array('FOS\\UserBundle\\FOSUserBundle', $container->getParameter('kernel.bundles'))) {
$container->removeDefinition('hatimeria_admin.user.form.extensions_collector');
$container->removeDefinition('hatimeria_admin.user.form.handler');
} else {
$fos_class = $container->getParameterBag()->resolveValue($container->getParameterBag()->get('fos_user.model.user.class'));
$builder = $container->getDefinition('hatimeria_admin.user.form.handler');
$builder->replaceArgument(2, new Reference('fos_user.user_manager'));
$builder->replaceArgument(3, $fos_class);
}
}
public function testEmptyConfigUsesDefaultValuesAndServicesAreCreated()
{
$this->extension->load(array(), $this->container);
$this->assertTrue($this->container->has('data_collector.ladybug_data_collector'));
$this->assertTrue($this->container->has('ladybug.twig.extension'));
$this->assertTrue($this->container->has('ladybug.dumper'));
$this->assertTrue($this->container->has('ladybug.event_listener.ladybug_config_listener'));
$bundleOptions = $this->container->getParameterBag('raul_fraile_ladybug')->get('ladybug.options');
$this->assertEquals('modern', $bundleOptions['theme']);
$this->assertFalse($bundleOptions['expanded']);
$this->assertFalse($bundleOptions['silenced']);
$this->assertEquals(9, $bundleOptions['array_max_nesting_level']);
$this->assertEquals(3, $bundleOptions['object_max_nesting_level']);
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
$parameters = $container->getParameterBag()->all();
$definitions = $container->getDefinitions();
$aliases = $container->getAliases();
foreach ($container->getExtensions() as $name => $extension) {
$tmpContainer = new ContainerBuilder($container->getParameterBag());
$tmpContainer->addObjectResource($extension);
$extension->load($container->getExtensionConfig($name), $tmpContainer);
$container->merge($tmpContainer);
}
$container->addDefinitions($definitions);
$container->addAliases($aliases);
$container->getParameterBag()->add($parameters);
}
public static function createContainer(array $parameters = array(), array $extensions = array(), array $compilerPasses = array())
{
$container = new ContainerBuilder();
foreach ($extensions as $extension) {
if ($extension instanceof ExtensionInterface) {
$container->registerExtension($extension);
if (!method_exists($extension, 'getAutoload') || $extension->getAutoload()) {
$container->loadFromExtension($extension->getAlias(), $parameters);
}
}
}
$container->getParameterBag()->add($parameters);
foreach ($compilerPasses as $compilerPass) {
if ($compilerPass instanceof CompilerPassInterface) {
$container->addCompilerPass($compilerPass);
}
}
// $loader = new YamlFileLoader(
// $container,
// new FileLocator(__DIR__ . '/../../../config/')
// );
// $loader->load('config.yml');
$container->compile();
return $container;
}
/**
* Processes HTTP responder tags
*
* @param ContainerBuilder $container The container builder
*
* @return void
*/
public function process(ContainerBuilder $container)
{
if (!$container->has('novuso_common.responder_service_map')) {
return;
}
$definition = $container->findDefinition('novuso_common.responder_service_map');
$taggedServices = $container->findTaggedServiceIds('novuso_common.http_responder');
foreach ($taggedServices as $id => $tags) {
$def = $container->getDefinition($id);
if (!$def->isPublic()) {
$message = sprintf('The service "%s" must be public as responders are lazy-loaded', $id);
throw new InvalidArgumentException($message);
}
if ($def->isAbstract()) {
$message = sprintf('The service "%s" must not be abstract as responders are lazy-loaded', $id);
throw new InvalidArgumentException($message);
}
$class = $container->getParameterBag()->resolveValue($def->getClass());
$refClass = new ReflectionClass($class);
if (!$refClass->isSubclassOf(Responder::class)) {
$message = sprintf('Service "%s" must extend "%s"', $id, Responder::class);
throw new InvalidArgumentException($message);
}
foreach ($tags as $attributes) {
if (!isset($attributes['action'])) {
$message = sprintf('Service "%s" is missing action attribute', $id);
throw new InvalidArgumentException($message);
}
$definition->addMethodCall('registerResponder', [$attributes['action'], $id]);
}
}
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$classes = array();
$annotatedClasses = array();
foreach ($container->getExtensions() as $extension) {
if ($extension instanceof Extension) {
$classes = array_merge($classes, $extension->getClassesToCompile());
$annotatedClasses = array_merge($annotatedClasses, $extension->getAnnotatedClassesToCompile());
}
}
$classes = $container->getParameterBag()->resolveValue($classes);
$annotatedClasses = $container->getParameterBag()->resolveValue($annotatedClasses);
$existingClasses = $this->getClassesInComposerClassMaps();
$this->kernel->setClassCache($this->expandClasses($classes, $existingClasses));
$this->kernel->setAnnotatedClassCache($this->expandClasses($annotatedClasses, $existingClasses));
}
/**
* @dataProvider crossCheckLoadersDumpers
*/
public function testCrossCheck($fixture, $type)
{
$loaderClass = 'Symfony\\Component\\DependencyInjection\\Loader\\' . ucfirst($type) . 'FileLoader';
$dumperClass = 'Symfony\\Component\\DependencyInjection\\Dumper\\' . ucfirst($type) . 'Dumper';
$tmp = tempnam('sf_service_container', 'sf');
file_put_contents($tmp, file_get_contents(self::$fixturesPath . '/' . $type . '/' . $fixture));
$container1 = new ContainerBuilder();
$loader1 = new $loaderClass($container1, new FileLocator());
$loader1->load($tmp);
$dumper = new $dumperClass($container1);
file_put_contents($tmp, $dumper->dump());
$container2 = new ContainerBuilder();
$loader2 = new $loaderClass($container2, new FileLocator());
$loader2->load($tmp);
unlink($tmp);
$this->assertEquals($container2->getAliases(), $container1->getAliases(), 'loading a dump from a previously loaded container returns the same container');
$this->assertEquals($container2->getDefinitions(), $container1->getDefinitions(), 'loading a dump from a previously loaded container returns the same container');
$this->assertEquals($container2->getParameterBag()->all(), $container1->getParameterBag()->all(), '->getParameterBag() returns the same value for both containers');
$this->assertEquals(serialize($container2), serialize($container1), 'loading a dump from a previously loaded container returns the same container');
$services1 = array();
foreach ($container1 as $id => $service) {
$services1[$id] = serialize($service);
}
$services2 = array();
foreach ($container2 as $id => $service) {
$services2[$id] = serialize($service);
}
unset($services1['service_container'], $services2['service_container']);
$this->assertEquals($services2, $services1, 'Iterator on the containers returns the same services');
}
/**
* Processes command handler tags
*
* @param ContainerBuilder $container The container builder
*
* @return void
*
* @throws RuntimeException When a command handler definition is not valid
*/
public function process(ContainerBuilder $container)
{
if (!$container->has('novuso_common.command_service_map')) {
return;
}
$definition = $container->findDefinition('novuso_common.command_service_map');
$taggedServices = $container->findTaggedServiceIds('novuso_common.command_handler');
foreach ($taggedServices as $id => $tags) {
$def = $container->getDefinition($id);
if (!$def->isPublic()) {
$message = sprintf('The service "%s" must be public as command handlers are lazy-loaded', $id);
throw new RuntimeException($message);
}
if ($def->isAbstract()) {
$message = sprintf('The service "%s" must not be abstract as command handlers are lazy-loaded', $id);
throw new RuntimeException($message);
}
$class = $container->getParameterBag()->resolveValue($def->getClass());
$refClass = new ReflectionClass($class);
if (!$refClass->implementsInterface(CommandHandler::class)) {
$message = sprintf('Service "%s" must implement interface "%s"', $id, CommandHandler::class);
throw new RuntimeException($message);
}
foreach ($tags as $attributes) {
if (!isset($attributes['command'])) {
$message = sprintf('Service "%s" is missing command attribute', $id);
throw new RuntimeException($message);
}
$definition->addMethodCall('registerHandler', [$attributes['command'], $id]);
}
}
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
if (!$this->integrationExtension->isVarTagValidatorEnabled()) {
if (count($container->findTaggedServiceIds('validator.var_tag.constraint_factory')) > 0) {
throw new \RuntimeException('Could not compile var tag validator constraint factory, because system is not enabled.');
}
return;
}
$registryDefinition = $container->getDefinition('validator.var_tag.constraint_factory_registry');
foreach ($container->findTaggedServiceIds('validator.var_tag.constraint_factory') as $id => $tags) {
$factoryDefinition = $container->getDefinition($id);
$class = $factoryDefinition->getClass();
try {
$class = $container->getParameterBag()->resolveValue($class);
$refClass = new \ReflectionClass($class);
$requiredInterface = 'FivePercent\\Component\\VarTagValidator\\Constraint\\ConstraintFactoryInterface';
if (!$refClass->implementsInterface($requiredInterface)) {
throw new \RuntimeException(sprintf('The var tag constraint factory should implement "%s" interface.', $requiredInterface));
}
foreach ($tags as $attributes) {
if (empty($attributes['type'])) {
throw new \RuntimeException('Missing attribute "type".');
}
$registryDefinition->addMethodCall('addConstraintFactory', [$attributes['type'], new Reference($id)]);
}
} catch (\Exception $e) {
throw new \RuntimeException(sprintf('Could not compile var tag validator constraint factory with service id "%s".', $id));
}
}
}
/**
* {@inheritdoc}
*
* @throws InvalidConfigurationException
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
foreach ($config as $key => $value) {
$container->setParameter($this->getAlias() . '.' . $key, $value);
}
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
// Deprecated factory methods handling.
// To be removed and set directly on config file when bumping Symfony requirements to >=2.6
$aliceFakerDefinition = $container->getDefinition('hautelook_alice.faker');
if (method_exists($aliceFakerDefinition, 'setFactory')) {
$aliceFakerDefinition->setFactory(['Faker\\Factory', 'create']);
} else {
$aliceFakerDefinition->setFactoryClass('Faker\\Factory');
$aliceFakerDefinition->setFactoryMethod('create');
}
foreach ($config['db_drivers'] as $driver => $isEnabled) {
if (true === $isEnabled || null === $isEnabled && true === $this->isExtensionEnabled($driver)) {
$loader->load(sprintf('%s.xml', $driver));
if ('orm' === $driver) {
$this->setCommandFactory($container->getDefinition('hautelook_alice.doctrine.command.deprecated_load_command'));
$this->setCommandFactory($container->getDefinition('hautelook_alice.doctrine.command.load_command'));
} else {
$this->setCommandFactory($container->getDefinition(sprintf('hautelook_alice.doctrine.%s.command.load_command', $driver)));
}
}
}
$container->getDefinition('hautelook_alice.alice.fixtures.loader')->replaceArgument(3, $container->getParameterBag()->all());
}
/**
* {@inheritdoc}
*/
public function process(ContainerBuilder $container)
{
$translationTargets = $container->getParameter('sonata_translation.targets');
$adminExtensionReferences = $this->getAdminExtensionReferenceByTypes(array_keys($translationTargets));
foreach ($container->findTaggedServiceIds('sonata.admin') as $id => $attributes) {
$admin = $container->getDefinition($id);
$modelClass = $container->getParameterBag()->resolveValue($admin->getArgument(1));
if (!class_exists($modelClass)) {
continue;
}
$modelClassReflection = new \ReflectionClass($modelClass);
foreach ($adminExtensionReferences as $type => $reference) {
foreach ($translationTargets[$type]['implements'] as $interface) {
if ($modelClassReflection->implementsInterface($interface)) {
$admin->addMethodCall('addExtension', array($reference));
}
}
foreach ($translationTargets[$type]['instanceof'] as $class) {
if ($modelClassReflection->getName() == $class || $modelClassReflection->isSubclassOf($class)) {
$admin->addMethodCall('addExtension', array($reference));
}
}
}
}
}
/**
* {@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 process(ContainerBuilder $container)
{
if (!$container->hasDefinition($this->handlerService)) {
return;
}
$definition = $container->getDefinition($this->handlerService);
foreach ($container->findTaggedServiceIds($this->rendererTag) as $id => $tags) {
$def = $container->getDefinition($id);
if (!$def->isPublic()) {
throw new \InvalidArgumentException(sprintf('The service "%s" must be public as fragment renderer are lazy-loaded.', $id));
}
if ($def->isAbstract()) {
throw new \InvalidArgumentException(sprintf('The service "%s" must not be abstract as fragment renderer are lazy-loaded.', $id));
}
$refClass = new \ReflectionClass($container->getParameterBag()->resolveValue($def->getClass()));
$interface = 'Symfony\\Component\\HttpKernel\\Fragment\\FragmentRendererInterface';
if (!$refClass->implementsInterface($interface)) {
throw new \InvalidArgumentException(sprintf('Service "%s" must implement interface "%s".', $id, $interface));
}
foreach ($tags as $tag) {
if (!isset($tag['alias'])) {
@trigger_error(sprintf('Service "%s" will have to define the "alias" attribute on the "%s" tag as of Symfony 3.0.', $id, $this->rendererTag), E_USER_DEPRECATED);
// register the handler as a non-lazy-loaded one
$definition->addMethodCall('addRenderer', array(new Reference($id)));
} else {
$definition->addMethodCall('addRendererService', array($tag['alias'], $id));
}
}
}
}
