public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('html_purifier.xml');
/* Prepend the default configuration. This cannot be defined within the
* Configuration class, since the root node's children are array
* prototypes.
*
* This cache path may be suppressed by either unsetting the "default"
* configuration (relying on canBeUnset() on the prototype node) or
* setting the "Cache.SerializerPath" option to null.
*/
array_unshift($configs, array('default' => array('Cache.SerializerPath' => '%kernel.cache_dir%/htmlpurifier')));
$configs = $this->processConfiguration(new Configuration(), $configs);
$configs = array_map(array($this, 'resolveServices'), $configs);
$paths = array();
foreach ($configs as $name => $config) {
$configDefinition = new Definition('%exercise_html_purifier.config.class%');
$configDefinition->setFactoryClass('%exercise_html_purifier.config.class%');
if ('default' === $name) {
$configDefinition->setFactoryMethod('create')->addArgument($config);
} else {
$configDefinition->setFactoryMethod('inherit')->addArgument(new Reference('exercise_html_purifier.config.default'))->addMethodCall('loadArray', array($config));
}
$configId = 'exercise_html_purifier.config.' . $name;
$container->setDefinition($configId, $configDefinition);
$container->setDefinition('exercise_html_purifier.' . $name, new Definition('%exercise_html_purifier.class%', array(new Reference($configId))));
if (isset($config['Cache.SerializerPath'])) {
$paths[] = $config['Cache.SerializerPath'];
}
}
$container->setParameter('exercise_html_purifier.cache_warmer.serializer.paths', array_unique($paths));
}
private function loadDoctrine(ContainerBuilder $container, $config)
{
$this->loadConfiguration($container, $config);
$definition = new Definition('Doctrine\\DBAL\\Connection', array(array('driver' => 'pdo_sqlite', 'memory' => true), new Reference('doctrine.configuration')));
$definition->setFactoryClass('Doctrine\\DBAL\\DriverManager');
$definition->setFactoryMethod('getConnection');
$container->setDefinition('doctrine.connection', $definition);
}
private function loadDoctrine(ContainerBuilder $container, $config)
{
$this->loadConfiguration($container, $config);
$this->loadEventManager($container, $config);
$definition = new Definition('Doctrine\\ORM\\EntityManager', array(array('driver' => 'pdo_sqlite', 'memory' => true), new Reference('doctrine.configuration'), new Reference('doctrine.event_manager')));
$definition->setFactoryClass('Doctrine\\ORM\\EntityManager');
$definition->setFactoryMethod('create');
$container->setDefinition('doctrine', $definition);
}
/**
* {@inheritDoc}
*/
public function process(ContainerBuilder $container)
{
$driver = $container->getDefinition('prezent_doctrine_translatable.driver_chain');
foreach ($container->getParameter('doctrine.entity_managers') as $name => $manager) {
$adapter = new Definition('Metadata\\Driver\\DriverInterface', array(new Reference(sprintf('doctrine.orm.%s_metadata_driver', $name))));
$adapter->setFactoryClass('Prezent\\Doctrine\\Translatable\\Mapping\\Driver\\DoctrineAdapter');
$adapter->setFactoryMethod('fromMetadataDriver');
$driver->addMethodCall('addDriver', array($adapter));
}
}
public function testRecognizesNonExistingFactoryMethod()
{
$definition = new Definition('stdClass');
$definition->setFactoryClass('Matthias\\SymfonyServiceDefinitionValidator\\Tests\\Fixtures\\FactoryClass');
$definition->setFactoryMethod('nonExistingFactoryMethod');
$containerBuilder = new ContainerBuilder();
$validator = new ServiceDefinitionValidator($containerBuilder, $this->createMockDefinitionArgumentsValidator(), $this->createMockMethodCallsValidator());
$this->setExpectedException('Matthias\\SymfonyServiceDefinitionValidator\\Exception\\MethodNotFoundException');
$validator->validate($definition);
}
public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('platinum_pixs_aws.xml');
$configs = $this->processConfiguration(new Configuration(), $configs);
$configs['default'] = array();
foreach ($configs as $name => $config) {
$definition = new Definition('%platinum_pixs_aws.class%');
$definition->setFactoryClass('%platinum_pixs_aws.class%')->setFactoryMethod('factory')->setArguments(array($config))->addTag('platinum_pixs_aws');
$container->setDefinition('platinum_pixs_aws.' . $name, $definition);
}
}
/**
* {@inheritDoc}
*/
public function create(ContainerBuilder $container, $resolverName, array $config)
{
$awsS3ClientDefinition = new Definition('Aws\S3\S3Client');
$awsS3ClientDefinition->setFactoryClass('Aws\S3\S3Client');
$awsS3ClientDefinition->setFactoryMethod('factory');
$awsS3ClientDefinition->addArgument($config['client_config']);
$awsS3ClientId = 'liip_imagine.cache.resolver.'.$resolverName.'.client';
$container->setDefinition($awsS3ClientId, $awsS3ClientDefinition);
$resolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.aws_s3');
$resolverDefinition->replaceArgument(0, new Reference($awsS3ClientId));
$resolverDefinition->replaceArgument(1, $config['bucket']);
$resolverDefinition->replaceArgument(2, $config['acl']);
$resolverDefinition->replaceArgument(3, array_replace($config['url_options'], $config['get_options']));
$resolverDefinition->replaceArgument(4, $config['put_options']);
$resolverId = 'liip_imagine.cache.resolver.'.$resolverName;
$container->setDefinition($resolverId, $resolverDefinition);
if (isset($config['cache_prefix'])) {
$resolverDefinition->addMethodCall('setCachePrefix', array($config['cache_prefix']));
}
if ($config['proxies']) {
$proxiedResolverId = 'liip_imagine.cache.resolver.'.$resolverName.'.proxied';
$container->setDefinition($proxiedResolverId, $resolverDefinition);
$proxyResolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.proxy');
$proxyResolverDefinition->replaceArgument(0, new Reference($proxiedResolverId));
$proxyResolverDefinition->replaceArgument(1, $config['proxies']);
$container->setDefinition($resolverId, $proxyResolverDefinition);
}
if ($config['cache']) {
$cachedResolverId = 'liip_imagine.cache.resolver.'.$resolverName.'.cached';
$container->setDefinition($cachedResolverId, $container->getDefinition($resolverId));
$cacheResolverDefinition = new DefinitionDecorator('liip_imagine.cache.resolver.prototype.cache');
$cacheResolverDefinition->replaceArgument(0, new Reference($config['cache']));
$cacheResolverDefinition->replaceArgument(1, new Reference($cachedResolverId));
$container->setDefinition($resolverId, $cacheResolverDefinition);
}
$container->getDefinition($resolverId)->addTag('liip_imagine.cache.resolver', array(
'resolver' => $resolverName,
));
return $resolverId;
}
/**
* Creates a complex setting factory.
*
* The factory has a variable number of arguments.
* Dynamic settings are added as tupples: first the argument without the leading and trailing $, so that it is not
* transformed by the config resolver pass, then the argument as a string, so that it does get transformed.
*
* @param string $argumentValue The original argument ($var$/$another_var$)
* @param array $dynamicSettings Array of dynamic settings in $argumentValue
*
* @return Definition
*/
private function createFactoryDefinition($argumentValue, $dynamicSettings)
{
$definition = new Definition('stdClass', array($argumentValue));
$definition->setFactoryClass('eZ\\Bundle\\EzPublishCoreBundle\\DependencyInjection\\Configuration\\ComplexSettings\\ComplexSettingValueFactory');
$definition->setFactoryMethod('getArgumentValue');
foreach ($dynamicSettings as $dynamicSetting) {
// Trim the '$' so that the dynamic setting doesn't get transformed
$definition->addArgument(trim($dynamicSetting, '$'));
// This one will be transformed
$definition->addArgument($dynamicSetting);
}
return $definition;
}
/**
* {@inheritDoc}
*/
protected function addApis(Definition $paymentDefinition, ContainerBuilder $container, $contextName, array $config)
{
$internalConnectorDefinition = new Definition('Klarna_Checkout_ConnectorInterface');
$internalConnectorDefinition->setFactoryClass('Klarna_Checkout_Connector');
$internalConnectorDefinition->setFactoryMethod('create');
$internalConnectorDefinition->addArgument($config['secret']);
$internalConnectorId = 'payum.context.' . $contextName . '.internal_connector';
$container->setDefinition($internalConnectorId, $internalConnectorDefinition);
$connectorDefinition = new Definition('%payum.klarna.checkout.connector.class%');
$connectorDefinition->addArgument(new Reference($internalConnectorId));
$connectorDefinition->addArgument($config['merchant_id']);
$connectorDefinition->addArgument($config['sandbox'] ? Constants::BASE_URI_SANDBOX : Constants::BASE_URI_LIVE);
$connectorDefinition->addArgument(Constants::CONTENT_TYPE_V2_PLUS_JSON);
$connectorId = 'payum.context.' . $contextName . '.connector';
$container->setDefinition($connectorId, $connectorDefinition);
$paymentDefinition->addMethodCall('addApi', array(new Reference($connectorId)));
}
public function load(array $configs, ContainerBuilder $container)
{
$configuration = $this->getConfiguration($configs, $container);
$config = $this->processConfiguration($configuration, $configs);
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('metrics.xml');
$registry = $container->getDefinition('beberlei_metrics.registry');
$registry->addMethodCall('setDefaultName', array($config['default']));
foreach ($config['collectors'] as $name => $collector) {
$def = new Definition('Beberlei\\Metrics\\Collector\\Collector');
$def->setFactoryMethod('create');
$def->setFactoryClass('%beberlei_metrics.factory.class%');
$def->setArguments(array($collector['type'], $collector));
$container->setDefinition('beberlei_metrics.collector.' . $name, $def);
$registry->addMethodCall('set', array($name, new Reference('beberlei_metrics.collector.' . $name)));
}
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
$loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$container->setParameter('lexik_monolog_browser.base_layout', $config['base_layout']);
$container->setParameter('lexik_monolog_browser.logs_per_page', $config['logs_per_page']);
$container->setParameter('lexik_monolog_browser.doctrine.table_name', $config['doctrine']['table_name']);
if (isset($config['doctrine']['connection_name'])) {
$container->setAlias('lexik_monolog_browser.doctrine_dbal.connection', sprintf('doctrine.dbal.%s_connection', $config['doctrine']['connection_name']));
}
if (isset($config['doctrine']['connection'])) {
$connectionDefinition = new Definition('Doctrine\\DBAL\\Connection', array($config['doctrine']['connection']));
$connectionDefinition->setFactoryClass('Doctrine\\DBAL\\DriverManager');
$connectionDefinition->setFactoryMethod('getConnection');
$container->setDefinition('lexik_monolog_browser.doctrine_dbal.connection', $connectionDefinition);
}
}
public function load(array $configs, ContainerBuilder $container)
{
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('compat.xml');
foreach ($configs as $config) {
if (isset($config['default_layout_resource'])) {
$container->setParameter('whitewashing.zfmvccompat.default_layout_resource', $config['default_layout_resource']);
}
if (isset($config['catchall_bundles'])) {
$container->setParameter('whitewashing.zfmvccompat.catchall_bundles', $config['catchall_bundles']);
}
if (isset($config['db_conn'])) {
$def = new Definition('Zend_Db_Adapter_Abstract');
$def->setFactoryClass('Zend_Db');
$def->setFactoryMethod('factory');
$def->setArguments(array($config['db_conn']['adapter'], $config['db_conn']['params']));
$container->setDefinition('whitewashing.zfmvcompat.db', $def);
}
}
}
private function getAllParameters()
{
$service = new Definition();
$service->setClass('stdClass');
$service->setAbstract(true);
$service->setFactoryClass('stdClass');
$service->setFactoryMethod('get');
$service->setFactoryService('service.fact');
$service->setFile('/file.php');
$service->setLazy(true);
$service->addMethodCall('methodCall1');
$service->addMethodCall('methodCall2', array('arg1', 'arg2'));
$service->addMethodCall('methodCall3', array(new Reference('arg.one')));
$service->setProperty('prop1', 'val1');
$service->setProperty('prop2', new Reference('prop.one'));
$service->setPublic(false);
$service->setScope('request');
$service->setSynchronized(true);
$service->setSynthetic(true);
return new ServiceElement('service.two', $service);
}
/**
* {@inheritDoc}
*/
public function load(array $configs, ContainerBuilder $container)
{
$configuration = new Configuration();
$config = $this->processConfiguration($configuration, $configs);
if (!isset($config['table'])) {
return;
}
$loader = new XmlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
$loader->load('services.xml');
$aws_config = array();
if (isset($config['aws'])) {
$aws_config = $config['aws'];
}
if (!isset($config['dynamo_client_id'])) {
$dynamoClass = $container->getParameter("dynamo_session_client.class");
$def = new Definition($dynamoClass);
$def->setFactoryClass($dynamoClass);
$def->setFactoryMethod("factory");
$def->setArguments(array($aws_config));
$container->setDefinition("dynamo_session_client", $def);
$config['dynamo_client_id'] = "dynamo_session_client";
} else {
$container->removeDefinition("dynamo_session_client");
$container->setAlias("dynamo_session_client", $config['dynamo_client_id']);
}
$container->setParameter("dynamo_session_table", $config['table']);
$container->setParameter("dynamo_session_read_capacity", $config['read_capacity']);
$container->setParameter("dynamo_session_write_capacity", $config['write_capacity']);
$dynamo_config = array('table_name' => $config['table'], 'locking_strategy' => $config['locking_strategy']);
foreach (array('automatic_gc', 'gc_batch_size', 'session_lifetime') as $key) {
if (isset($config[$key])) {
$dynamo_config[$key] = $config[$key];
}
}
$handler = $container->getDefinition("dynamo_session_handler");
$handler->setArguments(array(new Reference("dynamo_session_client"), $dynamo_config));
}
/**
* Resolves the definition
*
* @param string $id The definition identifier
* @param DefinitionDecorator $definition
*
* @return Definition
*/
private function resolveDefinition($id, DefinitionDecorator $definition)
{
if (!$this->container->hasDefinition($parent = $definition->getParent())) {
throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $id));
}
$parentDef = $this->container->getDefinition($parent);
if ($parentDef instanceof DefinitionDecorator) {
$parentDef = $this->resolveDefinition($parent, $parentDef);
}
$this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $id, $parent));
$def = new Definition();
// merge in parent definition
// purposely ignored attributes: scope, abstract, tags
$def->setClass($parentDef->getClass());
$def->setArguments($parentDef->getArguments());
$def->setMethodCalls($parentDef->getMethodCalls());
$def->setProperties($parentDef->getProperties());
$def->setFactoryClass($parentDef->getFactoryClass());
$def->setFactoryMethod($parentDef->getFactoryMethod());
$def->setFactoryService($parentDef->getFactoryService());
$def->setConfigurator($parentDef->getConfigurator());
$def->setFile($parentDef->getFile());
$def->setPublic($parentDef->isPublic());
// overwrite with values specified in the decorator
$changes = $definition->getChanges();
if (isset($changes['class'])) {
$def->setClass($definition->getClass());
}
if (isset($changes['factory_class'])) {
$def->setFactoryClass($definition->getFactoryClass());
}
if (isset($changes['factory_method'])) {
$def->setFactoryMethod($definition->getFactoryMethod());
}
if (isset($changes['factory_service'])) {
$def->setFactoryService($definition->getFactoryService());
}
if (isset($changes['configurator'])) {
$def->setConfigurator($definition->getConfigurator());
}
if (isset($changes['file'])) {
$def->setFile($definition->getFile());
}
if (isset($changes['public'])) {
$def->setPublic($definition->isPublic());
}
// merge arguments
foreach ($definition->getArguments() as $k => $v) {
if (is_numeric($k)) {
$def->addArgument($v);
continue;
}
if (0 !== strpos($k, 'index_')) {
throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k));
}
$index = (int) substr($k, strlen('index_'));
$def->replaceArgument($index, $v);
}
// merge properties
foreach ($definition->getProperties() as $k => $v) {
$def->setProperty($k, $v);
}
// append method calls
if (count($calls = $definition->getMethodCalls()) > 0) {
$def->setMethodCalls(array_merge($def->getMethodCalls(), $calls));
}
// these attributes are always taken from the child
$def->setAbstract($definition->isAbstract());
$def->setScope($definition->getScope());
$def->setTags($definition->getTags());
// set new definition on container
$this->container->setDefinition($id, $def);
return $def;
}
/**
* Loads a configured ORM entity manager.
*
* You need to be aware that ormLoad() can be called multiple times, which makes this method tricky to implement.
* There are two possible runtime scenarios:
*
* 1. If the EntityManager was defined before, override only the new calls to Doctrine\ORM\Configuration
* 2. If the EntityManager was not defined before, gather all the defaults for not specified options and set all the information.
*
* @param array $entityManager A configured ORM entity manager.
* @param ContainerBuilder $container A ContainerBuilder instance
*/
protected function loadOrmEntityManager(array $entityManager, ContainerBuilder $container)
{
$configServiceName = sprintf('doctrine.orm.%s_configuration', $entityManager['name']);
$ormConfigDef = new Definition('Doctrine\\ORM\\Configuration');
$ormConfigDef->setPublic(false);
$container->setDefinition($configServiceName, $ormConfigDef);
$this->loadOrmEntityManagerMappingInformation($entityManager, $ormConfigDef, $container);
$this->loadOrmCacheDrivers($entityManager, $container);
$uniqueMethods = array('setMetadataCacheImpl' => new Reference(sprintf('doctrine.orm.%s_metadata_cache', $entityManager['name'])), 'setQueryCacheImpl' => new Reference(sprintf('doctrine.orm.%s_query_cache', $entityManager['name'])), 'setResultCacheImpl' => new Reference(sprintf('doctrine.orm.%s_result_cache', $entityManager['name'])), 'setMetadataDriverImpl' => new Reference('doctrine.orm.' . $entityManager['name'] . '_metadata_driver'), 'setProxyDir' => $entityManager['proxy_dir'], 'setProxyNamespace' => $entityManager['proxy_namespace'], 'setAutoGenerateProxyClasses' => $entityManager['auto_generate_proxy_classes'], 'setClassMetadataFactoryName' => $entityManager['class_metadata_factory_name']);
foreach ($uniqueMethods as $method => $arg) {
$ormConfigDef->addMethodCall($method, array($arg));
}
$entityManagerService = sprintf('doctrine.orm.%s_entity_manager', $entityManager['name']);
$connectionName = isset($entityManager['connection']) ? $entityManager['connection'] : $entityManager['name'];
$ormEmArgs = array(new Reference(sprintf('doctrine.dbal.%s_connection', $connectionName)), new Reference(sprintf('doctrine.orm.%s_configuration', $entityManager['name'])));
$ormEmDef = new Definition('%doctrine.orm.entity_manager_class%', $ormEmArgs);
$ormEmDef->setFactoryClass('%doctrine.orm.entity_manager_class%');
$ormEmDef->setFactoryMethod('create');
$ormEmDef->addTag('doctrine.orm.entity_manager');
$container->setDefinition($entityManagerService, $ormEmDef);
$container->setAlias(sprintf('doctrine.orm.%s_entity_manager.event_manager', $entityManager['name']), new Alias(sprintf('doctrine.dbal.%s_connection.event_manager', $connectionName), false));
}
/**
* Creates a definition for the AWS provider
*
* @param array $config A Configuration array for the client
* @param ContainerBuilder $container The container
* @param string $name The provider key
*
* @return Reference
*/
private function createAwsClient($config, ContainerBuilder $container, $name)
{
$service = sprintf('uecode_qpush.provider.%s', $name);
if (!$container->hasDefinition($service)) {
if (!class_exists('Aws\\Common\\Aws')) {
throw new \RuntimeException('You must require "aws/aws-sdk-php" to use the AWS provider.');
}
$aws = new Definition('Aws\\Common\\Aws');
$aws->setFactoryClass('Aws\\Common\\Aws');
$aws->setFactoryMethod('factory');
$aws->setArguments([['key' => $config['key'], 'secret' => $config['secret'], 'region' => $config['region']]]);
$container->setDefinition($service, $aws)->setPublic(false);
}
return new Reference($service);
}
/**
* Loads a document manager configuration.
*
* @param array $documentManager A document manager configuration array
* @param string $defaultDM The default document manager name
* @param string $defaultDB The default db name
* @param string $defaultMetadataCache The default metadata cache configuration
* @param ContainerBuilder $container A ContainerBuilder instance
*/
protected function loadDocumentManager(array $documentManager, $defaultDM, $defaultDB, $defaultMetadataCache, ContainerBuilder $container)
{
$defaultDatabase = isset($documentManager['default_database']) ? $documentManager['default_database'] : $defaultDB;
$configServiceName = sprintf('doctrine.odm.mongodb.%s_configuration', $documentManager['name']);
if ($container->hasDefinition($configServiceName)) {
$odmConfigDef = $container->getDefinition($configServiceName);
} else {
$odmConfigDef = new Definition('%doctrine.odm.mongodb.configuration_class%');
$container->setDefinition($configServiceName, $odmConfigDef);
}
$this->loadDocumentManagerBundlesMappingInformation($documentManager, $odmConfigDef, $container);
$this->loadDocumentManagerMetadataCacheDriver($documentManager, $container, $defaultMetadataCache);
$methods = array('setMetadataCacheImpl' => new Reference(sprintf('doctrine.odm.mongodb.%s_metadata_cache', $documentManager['name'])), 'setMetadataDriverImpl' => new Reference(sprintf('doctrine.odm.mongodb.%s_metadata_driver', $documentManager['name'])), 'setProxyDir' => '%doctrine.odm.mongodb.proxy_dir%', 'setProxyNamespace' => '%doctrine.odm.mongodb.proxy_namespace%', 'setAutoGenerateProxyClasses' => '%doctrine.odm.mongodb.auto_generate_proxy_classes%', 'setHydratorDir' => '%doctrine.odm.mongodb.hydrator_dir%', 'setHydratorNamespace' => '%doctrine.odm.mongodb.hydrator_namespace%', 'setAutoGenerateHydratorClasses' => '%doctrine.odm.mongodb.auto_generate_hydrator_classes%', 'setDefaultDB' => $defaultDatabase);
if ($documentManager['logging']) {
$methods['setLoggerCallable'] = array(new Reference('doctrine.odm.mongodb.logger'), 'logQuery');
}
foreach ($methods as $method => $arg) {
if ($odmConfigDef->hasMethodCall($method)) {
$odmConfigDef->removeMethodCall($method);
}
$odmConfigDef->addMethodCall($method, array($arg));
}
// event manager
$eventManagerName = isset($documentManager['event_manager']) ? $documentManager['event_manager'] : $documentManager['name'];
$eventManagerId = sprintf('doctrine.odm.mongodb.%s_event_manager', $eventManagerName);
if (!$container->hasDefinition($eventManagerId)) {
$eventManagerDef = new Definition('%doctrine.odm.mongodb.event_manager_class%');
$eventManagerDef->addTag('doctrine.odm.mongodb.event_manager');
$eventManagerDef->setPublic(false);
$container->setDefinition($eventManagerId, $eventManagerDef);
}
$odmDmArgs = array(new Reference(sprintf('doctrine.odm.mongodb.%s_connection', isset($documentManager['connection']) ? $documentManager['connection'] : $documentManager['name'])), new Reference(sprintf('doctrine.odm.mongodb.%s_configuration', $documentManager['name'])), new Reference($eventManagerId));
$odmDmDef = new Definition('%doctrine.odm.mongodb.document_manager_class%', $odmDmArgs);
$odmDmDef->setFactoryClass('%doctrine.odm.mongodb.document_manager_class%');
$odmDmDef->setFactoryMethod('create');
$odmDmDef->addTag('doctrine.odm.mongodb.document_manager');
$container->setDefinition(sprintf('doctrine.odm.mongodb.%s_document_manager', $documentManager['name']), $odmDmDef);
if ($documentManager['name'] == $defaultDM) {
$container->setAlias('doctrine.odm.mongodb.document_manager', new Alias(sprintf('doctrine.odm.mongodb.%s_document_manager', $documentManager['name'])));
$container->setAlias('doctrine.odm.mongodb.event_manager', new Alias(sprintf('doctrine.odm.mongodb.%s_event_manager', $documentManager['name'])));
}
}
/**
* Loads a configured ORM entity manager.
*
* @param array $entityManager A configured ORM entity manager.
* @param ContainerBuilder $container A ContainerBuilder instance
*/
protected function loadOrmEntityManager(array $entityManager, ContainerBuilder $container)
{
$configServiceName = sprintf('doctrine.orm.%s_configuration', $entityManager['name']);
$ormConfigDef = new Definition('%doctrine.orm.configuration_class%');
$ormConfigDef->setPublic(false);
$container->setDefinition($configServiceName, $ormConfigDef);
$this->loadOrmEntityManagerMappingInformation($entityManager, $ormConfigDef, $container);
$this->loadOrmCacheDrivers($entityManager, $container);
$uniqueMethods = array('setMetadataCacheImpl' => new Reference(sprintf('doctrine.orm.%s_metadata_cache', $entityManager['name'])), 'setQueryCacheImpl' => new Reference(sprintf('doctrine.orm.%s_query_cache', $entityManager['name'])), 'setResultCacheImpl' => new Reference(sprintf('doctrine.orm.%s_result_cache', $entityManager['name'])), 'setMetadataDriverImpl' => new Reference('doctrine.orm.' . $entityManager['name'] . '_metadata_driver'), 'setProxyDir' => '%doctrine.orm.proxy_dir%', 'setProxyNamespace' => '%doctrine.orm.proxy_namespace%', 'setAutoGenerateProxyClasses' => '%doctrine.orm.auto_generate_proxy_classes%', 'setClassMetadataFactoryName' => $entityManager['class_metadata_factory_name']);
foreach ($uniqueMethods as $method => $arg) {
$ormConfigDef->addMethodCall($method, array($arg));
}
foreach ($entityManager['hydrators'] as $name => $class) {
$ormConfigDef->addMethodCall('addCustomHydrationMode', array($name, $class));
}
if (!empty($entityManager['dql'])) {
foreach ($entityManager['dql']['string_functions'] as $name => $function) {
$ormConfigDef->addMethodCall('addCustomStringFunction', array($name, $function));
}
foreach ($entityManager['dql']['numeric_functions'] as $name => $function) {
$ormConfigDef->addMethodCall('addCustomNumericFunction', array($name, $function));
}
foreach ($entityManager['dql']['datetime_functions'] as $name => $function) {
$ormConfigDef->addMethodCall('addCustomDatetimeFunction', array($name, $function));
}
}
$entityManagerService = sprintf('doctrine.orm.%s_entity_manager', $entityManager['name']);
$connectionId = isset($entityManager['connection']) ? sprintf('doctrine.dbal.%s_connection', $entityManager['connection']) : 'database_connection';
$eventManagerID = isset($entityManager['connection']) ? sprintf('doctrine.dbal.%s_connection.event_manager', $entityManager['connection']) : 'doctrine.dbal.event_manager';
$ormEmArgs = array(new Reference($connectionId), new Reference(sprintf('doctrine.orm.%s_configuration', $entityManager['name'])));
$ormEmDef = new Definition('%doctrine.orm.entity_manager_class%', $ormEmArgs);
$ormEmDef->setFactoryClass('%doctrine.orm.entity_manager_class%');
$ormEmDef->setFactoryMethod('create');
$ormEmDef->addTag('doctrine.orm.entity_manager');
$container->setDefinition($entityManagerService, $ormEmDef);
$container->setAlias(sprintf('doctrine.orm.%s_entity_manager.event_manager', $entityManager['name']), new Alias($eventManagerID, false));
}
/**
* Parses a definition.
*
* @param string $id
* @param array $service
* @param string $file
*
* @throws InvalidArgumentException When tags are invalid
*/
private function parseDefinition($id, $service, $file)
{
if (is_string($service) && 0 === strpos($service, '@')) {
$this->container->setAlias($id, substr($service, 1));
return;
}
if (!is_array($service)) {
throw new InvalidArgumentException(sprintf('A service definition must be an array or a string starting with "@" but %s found for service "%s" in %s. Check your YAML syntax.', gettype($service), $id, $file));
}
if (isset($service['alias'])) {
$public = !array_key_exists('public', $service) || (bool) $service['public'];
$this->container->setAlias($id, new Alias($service['alias'], $public));
return;
}
if (isset($service['parent'])) {
$definition = new DefinitionDecorator($service['parent']);
} else {
$definition = new Definition();
}
if (isset($service['class'])) {
$definition->setClass($service['class']);
}
if (isset($service['scope'])) {
$definition->setScope($service['scope']);
}
if (isset($service['synthetic'])) {
$definition->setSynthetic($service['synthetic']);
}
if (isset($service['synchronized'])) {
@trigger_error(sprintf('The "synchronized" key of service "%s" in file "%s" is deprecated since version 2.7 and will be removed in 3.0.', $id, $file), E_USER_DEPRECATED);
$definition->setSynchronized($service['synchronized'], 'request' !== $id);
}
if (isset($service['lazy'])) {
$definition->setLazy($service['lazy']);
}
if (isset($service['public'])) {
$definition->setPublic($service['public']);
}
if (isset($service['abstract'])) {
$definition->setAbstract($service['abstract']);
}
if (isset($service['factory'])) {
if (is_string($service['factory'])) {
if (strpos($service['factory'], ':') !== false && strpos($service['factory'], '::') === false) {
$parts = explode(':', $service['factory']);
$definition->setFactory(array($this->resolveServices('@' . $parts[0]), $parts[1]));
} else {
$definition->setFactory($service['factory']);
}
} else {
$definition->setFactory(array($this->resolveServices($service['factory'][0]), $service['factory'][1]));
}
}
if (isset($service['factory_class'])) {
@trigger_error(sprintf('The "factory_class" key of service "%s" in file "%s" is deprecated since version 2.6 and will be removed in 3.0. Use "factory" instead.', $id, $file), E_USER_DEPRECATED);
$definition->setFactoryClass($service['factory_class']);
}
if (isset($service['factory_method'])) {
@trigger_error(sprintf('The "factory_method" key of service "%s" in file "%s" is deprecated since version 2.6 and will be removed in 3.0. Use "factory" instead.', $id, $file), E_USER_DEPRECATED);
$definition->setFactoryMethod($service['factory_method']);
}
if (isset($service['factory_service'])) {
@trigger_error(sprintf('The "factory_service" key of service "%s" in file "%s" is deprecated since version 2.6 and will be removed in 3.0. Use "factory" instead.', $id, $file), E_USER_DEPRECATED);
$definition->setFactoryService($service['factory_service']);
}
if (isset($service['file'])) {
$definition->setFile($service['file']);
}
if (isset($service['arguments'])) {
$definition->setArguments($this->resolveServices($service['arguments']));
}
if (isset($service['properties'])) {
$definition->setProperties($this->resolveServices($service['properties']));
}
if (isset($service['configurator'])) {
if (is_string($service['configurator'])) {
$definition->setConfigurator($service['configurator']);
} else {
$definition->setConfigurator(array($this->resolveServices($service['configurator'][0]), $service['configurator'][1]));
}
}
if (isset($service['calls'])) {
if (!is_array($service['calls'])) {
throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
}
foreach ($service['calls'] as $call) {
if (isset($call['method'])) {
$method = $call['method'];
$args = isset($call['arguments']) ? $this->resolveServices($call['arguments']) : array();
} else {
$method = $call[0];
$args = isset($call[1]) ? $this->resolveServices($call[1]) : array();
}
$definition->addMethodCall($method, $args);
}
}
if (isset($service['tags'])) {
if (!is_array($service['tags'])) {
throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
}
foreach ($service['tags'] as $tag) {
if (!is_array($tag)) {
throw new InvalidArgumentException(sprintf('A "tags" entry must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
}
if (!isset($tag['name'])) {
throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file));
}
if (!is_string($tag['name']) || '' === $tag['name']) {
throw new InvalidArgumentException(sprintf('The tag name for service "%s" in %s must be a non-empty string.', $id, $file));
}
$name = $tag['name'];
unset($tag['name']);
foreach ($tag as $attribute => $value) {
if (!is_scalar($value) && null !== $value) {
throw new InvalidArgumentException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s" in %s. Check your YAML syntax.', $id, $name, $attribute, $file));
}
}
$definition->addTag($name, $tag);
}
}
if (isset($service['decorates'])) {
if ('' !== $service['decorates'] && '@' === $service['decorates'][0]) {
throw new InvalidArgumentException(sprintf('The value of the "decorates" option for the "%s" service must be the id of the service without the "@" prefix (replace "%s" with "%s").', $id, $service['decorates'], substr($service['decorates'], 1)));
}
$renameId = isset($service['decoration_inner_name']) ? $service['decoration_inner_name'] : null;
$definition->setDecoratedService($service['decorates'], $renameId);
}
$this->container->setDefinition($id, $definition);
}
/**
* @param Bean $bean
* @return mixed
*/
public function create(Bean $bean)
{
$useConfigurator = true;
$originalClass = $class = ltrim($bean->class, '\\');
if ($bean->factoryMethod) {
// We don't have a clue what what the real class is, fake it and hope nothing breaks;
$class = "stdClass";
} else {
if (class_exists($class)) {
$rClass = new \ReflectionClass($class);
if (!$rClass->implementsInterface('MooDev\\Bounce\\Config\\Configurable')) {
// The class definitely doesn't need the configurator, so we can disable it.
$useConfigurator = false;
}
}
}
$usesLookupMethods = false;
if ($bean->lookupMethods) {
if (!$this->proxyGeneratorFactory) {
throw new BounceException("Proxy generator not configured, cannot use lookup-method");
}
// If we have lookup methods then the class is actually a generated proxy.
$class = ltrim($this->proxyGeneratorFactory->loadProxy($bean), '\\');
$usesLookupMethods = true;
}
$def = new Definition($class);
if ($usesLookupMethods) {
// The proxy will take an additional, first, constructor arg which is expected to be a bean factory.
$def->addArgument($this->getBeanFactory());
}
if ($useConfigurator) {
// We use the configurator if we know the class of the bean and it implements Configurable
// or if we have no idea what the class of the bean is (there's a factory method.)
$def->setConfigurator($this->getConfigurator());
}
if ($bean->scope) {
// This is getting killed off in Symfony 3. Sigh.
// TODO: deal with Symfony 3.
switch ($bean->scope) {
case "singleton":
$def->setScope(ContainerBuilder::SCOPE_CONTAINER);
break;
case "prototype":
$def->setScope(ContainerBuilder::SCOPE_PROTOTYPE);
break;
default:
$def->setScope($bean->scope);
}
}
foreach ($bean->constructorArguments as $constructorArgument) {
$def->addArgument($this->convertValueProviderToValue($constructorArgument));
}
foreach ($bean->properties as $name => $property) {
// TODO: Could support setter injection using Reflection here?
$def->setProperty($name, $this->convertValueProviderToValue($property));
}
if ($bean->factoryBean) {
$def->setFactoryService($bean->factoryBean);
$def->setFactoryMethod($bean->factoryMethod);
} elseif ($bean->factoryMethod) {
$def->setFactoryClass($originalClass);
$def->setFactoryMethod($bean->factoryMethod);
}
return $def;
}
public function getFactoryMethodIsNotStaticData()
{
$factoryClass = 'Matthias\\SymfonyServiceDefinitionValidator\\Tests\\Fixtures\\FactoryClass';
$factoryMethod = 'createNonStatic';
$data = array();
if (method_exists('Symfony\\Component\\DependencyInjection\\Definition', 'setFactoryClass')) {
$definition = new Definition();
$definition->setFactoryClass($factoryClass);
$definition->setFactoryMethod($factoryMethod);
$data[] = array($definition);
}
if (method_exists('Symfony\\Component\\DependencyInjection\\Definition', 'setFactory')) {
$definition = new Definition();
$definition->setFactory(array($factoryClass, $factoryMethod));
$data[] = array($definition);
}
return $data;
}
/**
* {@inheritdoc}
*
* @api
*/
public function setFactoryClass($class)
{
$this->changes['factory_class'] = true;
return parent::setFactoryClass($class);
}
/**
* Parses a definition.
*
* @param string $id
* @param array $service
* @param string $file
*
* @throws InvalidArgumentException When tags are invalid
*/
private function parseDefinition($id, $service, $file)
{
if (is_string($service) && 0 === strpos($service, '@')) {
$this->container->setAlias($id, substr($service, 1));
return;
} elseif (isset($service['alias'])) {
$public = !array_key_exists('public', $service) || (Boolean) $service['public'];
$this->container->setAlias($id, new Alias($service['alias'], $public));
return;
}
if (isset($service['parent'])) {
$definition = new DefinitionDecorator($service['parent']);
} else {
$definition = new Definition();
}
if (isset($service['class'])) {
$definition->setClass($service['class']);
}
if (isset($service['scope'])) {
$definition->setScope($service['scope']);
}
if (isset($service['synthetic'])) {
$definition->setSynthetic($service['synthetic']);
}
if (isset($service['public'])) {
$definition->setPublic($service['public']);
}
if (isset($service['abstract'])) {
$definition->setAbstract($service['abstract']);
}
if (isset($service['factory_class'])) {
$definition->setFactoryClass($service['factory_class']);
}
if (isset($service['factory_method'])) {
$definition->setFactoryMethod($service['factory_method']);
}
if (isset($service['factory_service'])) {
$definition->setFactoryService($service['factory_service']);
}
if (isset($service['file'])) {
$definition->setFile($service['file']);
}
if (isset($service['arguments'])) {
$definition->setArguments($this->resolveServices($service['arguments']));
}
if (isset($service['properties'])) {
$definition->setProperties($this->resolveServices($service['properties']));
}
if (isset($service['configurator'])) {
if (is_string($service['configurator'])) {
$definition->setConfigurator($service['configurator']);
} else {
$definition->setConfigurator(array($this->resolveServices($service['configurator'][0]), $service['configurator'][1]));
}
}
if (isset($service['calls'])) {
foreach ($service['calls'] as $call) {
$args = isset($call[1]) ? $this->resolveServices($call[1]) : array();
$definition->addMethodCall($call[0], $args);
}
}
if (isset($service['tags'])) {
if (!is_array($service['tags'])) {
throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s.', $id, $file));
}
foreach ($service['tags'] as $tag) {
if (!isset($tag['name'])) {
throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file));
}
$name = $tag['name'];
unset($tag['name']);
foreach ($tag as $attribute => $value) {
if (!is_scalar($value)) {
throw new InvalidArgumentException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s" in %s.', $id, $name, $file));
}
}
$definition->addTag($name, $tag);
}
}
$this->container->setDefinition($id, $definition);
}
private function buildDirectiveSetDefinition(ContainerBuilder $container, $config, $type)
{
$directiveDefinition = new Definition('Nelmio\\SecurityBundle\\ContentSecurityPolicy\\DirectiveSet');
if (version_compare(Kernel::VERSION, '2.6', '>=')) {
$directiveDefinition->setFactory(array('Nelmio\\SecurityBundle\\ContentSecurityPolicy\\DirectiveSet', 'fromConfig'));
} else {
$directiveDefinition->setFactoryClass('Nelmio\\SecurityBundle\\ContentSecurityPolicy\\DirectiveSet');
$directiveDefinition->setFactoryMethod('fromConfig');
}
$pmDefinition = $container->getDefinition('nelmio_security.policy_manager');
if (isset($config[$type]) && $config[$type]['browser_adaptive']['enabled']) {
$service = $config[$type]['browser_adaptive']['parser'];
if ($service === 'nelmio_security.ua_parser.ua_php' && !class_exists('UAParser\\Parser')) {
throw new \RuntimeException('You must require "ua-parser/uap-php" as a dependency to use the browser_adaptive feature or configure your own "nelmio_security.ua_parser.service"');
}
$container->setParameter('nelmio_browser_adaptive_parser', $service);
$uaParser = $container->getDefinition('nelmio_security.ua_parser');
$uaParser->setArguments(array($container->getDefinition('nelmio_security.ua_parser.ua_php')));
$pmDefinition->setArguments(array($uaParser));
}
$directiveDefinition->setArguments(array($pmDefinition, $config, $type));
return $directiveDefinition;
}
/**
* Loads a xml-entity manager configuration.
*
* @param array $xmlEntityManager A xml-entity manager configuration array
* @param string $defaultXEM The default xml-entity manager name
* @param string $defaultStorage The default db name
* @param string $defaultMetadataCache The default metadata cache configuration
* @param ContainerBuilder $container A ContainerBuilder instance
*/
protected function loadXmlEntityManager(array $xmlEntityManager, $defaultXEM, $defaultStorage, $defaultMetadataCache, ContainerBuilder $container)
{
$defaultStorage = isset($xmlEntityManager['storage']) ? $xmlEntityManager['storage'] : $defaultStorage;
$configServiceName = sprintf('doctrine.oxm.%s_configuration', $xmlEntityManager['name']);
if ($container->hasDefinition($configServiceName)) {
$oxmConfigDef = $container->getDefinition($configServiceName);
} else {
$oxmConfigDef = new Definition('%doctrine.oxm.configuration.class%');
$container->setDefinition($configServiceName, $oxmConfigDef);
}
$this->loadXmlEntityManagerBundlesMappingInformation($xmlEntityManager, $oxmConfigDef, $container);
$this->loadXmlEntityManagerMetadataCacheDriver($xmlEntityManager, $container, $defaultMetadataCache);
$methods = array('setMetadataCacheImpl' => new Reference(sprintf('doctrine.oxm.%s_metadata_cache', $xmlEntityManager['name'])), 'setMetadataDriverImpl' => new Reference(sprintf('doctrine.oxm.%s_metadata_driver', $xmlEntityManager['name'])), 'setProxyDir' => '%doctrine.oxm.proxy_dir%', 'setProxyNamespace' => '%doctrine.oxm.proxy_namespace%', 'setAutoGenerateProxyClasses' => '%doctrine.oxm.auto_generate_proxy_classes%');
// if ($xmlEntityManager['logging']) {
// $methods['setLoggerCallable'] = array(new Reference('doctrine.oxm.logger'), 'logQuery');
// }
foreach ($methods as $method => $arg) {
if ($oxmConfigDef->hasMethodCall($method)) {
$oxmConfigDef->removeMethodCall($method);
}
$oxmConfigDef->addMethodCall($method, array($arg));
}
// event manager
$eventManagerName = isset($xmlEntityManager['event_manager']) ? $xmlEntityManager['event_manager'] : $xmlEntityManager['name'];
$eventManagerId = sprintf('doctrine.oxm.%s_event_manager', $eventManagerName);
if (!$container->hasDefinition($eventManagerId)) {
$eventManagerDef = new Definition('%doctrine.oxm.event_manager.class%');
$eventManagerDef->addTag('doctrine.oxm.event_manager');
$eventManagerDef->setPublic(false);
$container->setDefinition($eventManagerId, $eventManagerDef);
}
$oxmXemArgs = array(new Reference(sprintf('doctrine.oxm.%s_storage', isset($xmlEntityManager['storage']) ? $xmlEntityManager['storage'] : $xmlEntityManager['name'])), new Reference(sprintf('doctrine.oxm.%s_configuration', $xmlEntityManager['name'])), new Reference($eventManagerId));
$oxmXemDef = new Definition('%doctrine.oxm.xml_entity_manager.class%', $oxmXemArgs);
$oxmXemDef->setFactoryClass('%doctrine.oxm.xml_entity_manager.class%');
// $oxmXemDef->setFactoryMethod('create');
$oxmXemDef->addTag('doctrine.oxm.xml_entity_manager');
$container->setDefinition(sprintf('doctrine.oxm.%s_xml_entity_manager', $xmlEntityManager['name']), $oxmXemDef);
// oxm marshaller
$oxmMarshallerDef = new Definition('%doctrine.oxm.xml_marshaller.class%');
$oxmMarshallerDef->setFactoryService(sprintf('doctrine.oxm.%s_xml_entity_manager', $xmlEntityManager['name']));
$oxmMarshallerDef->setFactoryMethod('getMarshaller');
$container->setDefinition(sprintf('doctrine.oxm.%s_xml_marshaller', $xmlEntityManager['name']), $oxmMarshallerDef);
if ($xmlEntityManager['name'] == $defaultXEM) {
$container->setAlias('doctrine.oxm.xml_entity_manager', new Alias(sprintf('doctrine.oxm.%s_xml_entity_manager', $xmlEntityManager['name'])));
$container->setAlias('doctrine.oxm.xml_marshaller', new Alias(sprintf('doctrine.oxm.%s_xml_marshaller', $xmlEntityManager['name'])));
$container->setAlias('doctrine.oxm.event_manager', new Alias(sprintf('doctrine.oxm.%s_event_manager', $xmlEntityManager['name'])));
}
}
/**
* Parses a definition.
*
* @param string $id
* @param array $service
* @param string $file
*
* @throws InvalidArgumentException When tags are invalid
*/
private function parseDefinition($id, $service, $file)
{
if (is_string($service) && 0 === strpos($service, '@')) {
$this->container->setAlias($id, substr($service, 1));
return;
}
if (!is_array($service)) {
throw new InvalidArgumentException(sprintf('A service definition must be an array or a string starting with "@" but %s found for service "%s" in %s. Check your YAML syntax.', gettype($service), $id, $file));
}
if (isset($service['alias'])) {
$public = !array_key_exists('public', $service) || (bool) $service['public'];
$this->container->setAlias($id, new Alias($service['alias'], $public));
return;
}
if (isset($service['parent'])) {
$definition = new DefinitionDecorator($service['parent']);
} else {
$definition = new Definition();
}
if (isset($service['class'])) {
$definition->setClass($service['class']);
}
if (isset($service['scope'])) {
$definition->setScope($service['scope']);
}
if (isset($service['synthetic'])) {
$definition->setSynthetic($service['synthetic']);
}
if (isset($service['synchronized'])) {
$definition->setSynchronized($service['synchronized']);
}
if (isset($service['lazy'])) {
$definition->setLazy($service['lazy']);
}
if (isset($service['public'])) {
$definition->setPublic($service['public']);
}
if (isset($service['abstract'])) {
$definition->setAbstract($service['abstract']);
}
if (isset($service['factory'])) {
if (is_string($service['factory'])) {
if (strpos($service['factory'], ':') !== false && strpos($service['factory'], '::') === false) {
$parts = explode(':', $service['factory']);
$definition->setFactory(array($this->resolveServices('@' . $parts[0]), $parts[1]));
} else {
$definition->setFactory($service['factory']);
}
} else {
$definition->setFactory(array($this->resolveServices($service['factory'][0]), $service['factory'][1]));
}
}
if (isset($service['factory_class'])) {
$definition->setFactoryClass($service['factory_class']);
}
if (isset($service['factory_method'])) {
$definition->setFactoryMethod($service['factory_method']);
}
if (isset($service['factory_service'])) {
$definition->setFactoryService($service['factory_service']);
}
if (isset($service['file'])) {
$definition->setFile($service['file']);
}
if (isset($service['arguments'])) {
$definition->setArguments($this->resolveServices($service['arguments']));
}
if (isset($service['properties'])) {
$definition->setProperties($this->resolveServices($service['properties']));
}
if (isset($service['configurator'])) {
if (is_string($service['configurator'])) {
$definition->setConfigurator($service['configurator']);
} else {
$definition->setConfigurator(array($this->resolveServices($service['configurator'][0]), $service['configurator'][1]));
}
}
if (isset($service['calls'])) {
if (!is_array($service['calls'])) {
throw new InvalidArgumentException(sprintf('Parameter "calls" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
}
foreach ($service['calls'] as $call) {
$args = isset($call[1]) ? $this->resolveServices($call[1]) : array();
$definition->addMethodCall($call[0], $args);
}
}
if (isset($service['tags'])) {
if (!is_array($service['tags'])) {
throw new InvalidArgumentException(sprintf('Parameter "tags" must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
}
foreach ($service['tags'] as $tag) {
if (!is_array($tag)) {
throw new InvalidArgumentException(sprintf('A "tags" entry must be an array for service "%s" in %s. Check your YAML syntax.', $id, $file));
}
if (!isset($tag['name'])) {
throw new InvalidArgumentException(sprintf('A "tags" entry is missing a "name" key for service "%s" in %s.', $id, $file));
}
$name = $tag['name'];
unset($tag['name']);
foreach ($tag as $attribute => $value) {
if (!is_scalar($value) && null !== $value) {
throw new InvalidArgumentException(sprintf('A "tags" attribute must be of a scalar-type for service "%s", tag "%s", attribute "%s" in %s. Check your YAML syntax.', $id, $name, $attribute, $file));
}
}
$definition->addTag($name, $tag);
}
}
if (isset($service['decorates'])) {
$renameId = isset($service['decoration_inner_name']) ? $service['decoration_inner_name'] : null;
$definition->setDecoratedService($service['decorates'], $renameId);
}
$this->container->setDefinition($id, $definition);
}
/**
* Set the name of the class that acts as a factory using the factory method,
* which will be invoked statically.
*
* @param string $factoryClass The factory class name
*
* @return tubepress_api_ioc_DefinitionInterface The current instance
*
* @api
* @since 4.0.0
*/
public function setFactoryClass($factoryClass)
{
$this->_underlyingSymfonyDefinition->setFactoryClass($factoryClass);
return $this;
}
/**
* Resolves the definition.
*
* @param ContainerBuilder $container The ContainerBuilder
* @param DefinitionDecorator $definition
*
* @return Definition
*
* @throws \RuntimeException When the definition is invalid
*/
private function resolveDefinition(ContainerBuilder $container, DefinitionDecorator $definition)
{
if (!$container->hasDefinition($parent = $definition->getParent())) {
throw new RuntimeException(sprintf('The parent definition "%s" defined for definition "%s" does not exist.', $parent, $this->currentId));
}
$parentDef = $container->getDefinition($parent);
if ($parentDef instanceof DefinitionDecorator) {
$id = $this->currentId;
$this->currentId = $parent;
$parentDef = $this->resolveDefinition($container, $parentDef);
$container->setDefinition($parent, $parentDef);
$this->currentId = $id;
}
$this->compiler->addLogMessage($this->formatter->formatResolveInheritance($this, $this->currentId, $parent));
$def = new Definition();
// merge in parent definition
// purposely ignored attributes: scope, abstract, tags
$def->setClass($parentDef->getClass());
$def->setArguments($parentDef->getArguments());
$def->setMethodCalls($parentDef->getMethodCalls());
$def->setProperties($parentDef->getProperties());
$def->setAutowiringTypes($parentDef->getAutowiringTypes());
if ($parentDef->getFactoryClass(false)) {
$def->setFactoryClass($parentDef->getFactoryClass(false));
}
if ($parentDef->getFactoryMethod(false)) {
$def->setFactoryMethod($parentDef->getFactoryMethod(false));
}
if ($parentDef->getFactoryService(false)) {
$def->setFactoryService($parentDef->getFactoryService(false));
}
if ($parentDef->isDeprecated()) {
$def->setDeprecated(true, $parentDef->getDeprecationMessage('%service_id%'));
}
$def->setFactory($parentDef->getFactory());
$def->setConfigurator($parentDef->getConfigurator());
$def->setFile($parentDef->getFile());
$def->setPublic($parentDef->isPublic());
$def->setLazy($parentDef->isLazy());
// overwrite with values specified in the decorator
$changes = $definition->getChanges();
if (isset($changes['class'])) {
$def->setClass($definition->getClass());
}
if (isset($changes['factory_class'])) {
$def->setFactoryClass($definition->getFactoryClass(false));
}
if (isset($changes['factory_method'])) {
$def->setFactoryMethod($definition->getFactoryMethod(false));
}
if (isset($changes['factory_service'])) {
$def->setFactoryService($definition->getFactoryService(false));
}
if (isset($changes['factory'])) {
$def->setFactory($definition->getFactory());
}
if (isset($changes['configurator'])) {
$def->setConfigurator($definition->getConfigurator());
}
if (isset($changes['file'])) {
$def->setFile($definition->getFile());
}
if (isset($changes['public'])) {
$def->setPublic($definition->isPublic());
}
if (isset($changes['lazy'])) {
$def->setLazy($definition->isLazy());
}
if (isset($changes['deprecated'])) {
$def->setDeprecated($definition->isDeprecated(), $definition->getDeprecationMessage('%service_id%'));
}
if (isset($changes['decorated_service'])) {
$decoratedService = $definition->getDecoratedService();
if (null === $decoratedService) {
$def->setDecoratedService($decoratedService);
} else {
$def->setDecoratedService($decoratedService[0], $decoratedService[1], $decoratedService[2]);
}
}
// merge arguments
foreach ($definition->getArguments() as $k => $v) {
if (is_numeric($k)) {
$def->addArgument($v);
continue;
}
if (0 !== strpos($k, 'index_')) {
throw new RuntimeException(sprintf('Invalid argument key "%s" found.', $k));
}
$index = (int) substr($k, strlen('index_'));
$def->replaceArgument($index, $v);
}
// merge properties
foreach ($definition->getProperties() as $k => $v) {
$def->setProperty($k, $v);
}
// append method calls
if (count($calls = $definition->getMethodCalls()) > 0) {
$def->setMethodCalls(array_merge($def->getMethodCalls(), $calls));
}
// merge autowiring types
foreach ($definition->getAutowiringTypes() as $autowiringType) {
$def->addAutowiringType($autowiringType);
}
// these attributes are always taken from the child
$def->setAbstract($definition->isAbstract());
$def->setScope($definition->getScope(false), false);
$def->setShared($definition->isShared());
$def->setTags($definition->getTags());
return $def;
}
/**
* Loads a document manager configuration.
*
* @param array $documentManager A document manager configuration array
* @param string $defaultDM The default document manager name
* @param string $defaultDB The default db name
* @param string $defaultMetadataCache The default metadata cache configuration
* @param ContainerBuilder $container A ContainerBuilder instance
*/
protected function loadDocumentManager(array $documentManager, $defaultDM, $defaultDB, $defaultMetadataCache, ContainerBuilder $container)
{
$configServiceName = sprintf('doctrine.odm.mongodb.%s_configuration', $documentManager['name']);
$connectionName = isset($documentManager['connection']) ? $documentManager['connection'] : $documentManager['name'];
$defaultDatabase = isset($documentManager['database']) ? $documentManager['database'] : $defaultDB;
if ($container->hasDefinition($configServiceName)) {
$odmConfigDef = $container->getDefinition($configServiceName);
} else {
$odmConfigDef = new Definition('%doctrine.odm.mongodb.configuration.class%');
$container->setDefinition($configServiceName, $odmConfigDef);
}
$this->loadDocumentManagerBundlesMappingInformation($documentManager, $odmConfigDef, $container);
$this->loadDocumentManagerMetadataCacheDriver($documentManager, $container, $defaultMetadataCache);
$methods = array('setMetadataCacheImpl' => new Reference(sprintf('doctrine.odm.mongodb.%s_metadata_cache', $documentManager['name'])), 'setMetadataDriverImpl' => new Reference(sprintf('doctrine.odm.mongodb.%s_metadata_driver', $documentManager['name'])), 'setProxyDir' => '%doctrine.odm.mongodb.proxy_dir%', 'setProxyNamespace' => '%doctrine.odm.mongodb.proxy_namespace%', 'setAutoGenerateProxyClasses' => '%doctrine.odm.mongodb.auto_generate_proxy_classes%', 'setHydratorDir' => '%doctrine.odm.mongodb.hydrator_dir%', 'setHydratorNamespace' => '%doctrine.odm.mongodb.hydrator_namespace%', 'setAutoGenerateHydratorClasses' => '%doctrine.odm.mongodb.auto_generate_hydrator_classes%', 'setDefaultDB' => $defaultDatabase);
// logging
$loggers = array();
if ($container->getParameterBag()->resolveValue($documentManager['logging'])) {
$loggers[] = new Reference('doctrine.odm.mongodb.logger');
}
// profiler
if ($container->getParameterBag()->resolveValue($documentManager['profiler']['enabled'])) {
$dataCollectorId = sprintf('doctrine.odm.mongodb.data_collector.%s', $container->getParameterBag()->resolveValue($documentManager['profiler']['pretty']) ? 'pretty' : 'standard');
$loggers[] = new Reference($dataCollectorId);
$container->getDefinition($dataCollectorId)->addTag('data_collector', array('id' => 'mongodb', 'template' => 'DoctrineMongoDBBundle:Collector:mongodb'));
}
if (1 < count($loggers)) {
$methods['setLoggerCallable'] = array(new Reference('doctrine.odm.mongodb.logger.aggregate'), 'logQuery');
$container->getDefinition('doctrine.odm.mongodb.logger.aggregate')->addArgument($loggers);
} elseif ($loggers) {
$methods['setLoggerCallable'] = array($loggers[0], 'logQuery');
}
foreach ($methods as $method => $arg) {
if ($odmConfigDef->hasMethodCall($method)) {
$odmConfigDef->removeMethodCall($method);
}
$odmConfigDef->addMethodCall($method, array($arg));
}
$odmDmArgs = array(new Reference(sprintf('doctrine.odm.mongodb.%s_connection', $connectionName)), new Reference(sprintf('doctrine.odm.mongodb.%s_configuration', $documentManager['name'])), new Reference(sprintf('doctrine.odm.mongodb.%s_connection.event_manager', $connectionName)));
$odmDmDef = new Definition('%doctrine.odm.mongodb.document_manager.class%', $odmDmArgs);
$odmDmDef->setFactoryClass('%doctrine.odm.mongodb.document_manager.class%');
$odmDmDef->setFactoryMethod('create');
$odmDmDef->addTag('doctrine.odm.mongodb.document_manager');
$container->setDefinition(sprintf('doctrine.odm.mongodb.%s_document_manager', $documentManager['name']), $odmDmDef);
if ($documentManager['name'] == $defaultDM) {
$container->setAlias('doctrine.odm.mongodb.document_manager', new Alias(sprintf('doctrine.odm.mongodb.%s_document_manager', $documentManager['name'])));
$container->setAlias('doctrine.odm.mongodb.event_manager', new Alias(sprintf('doctrine.odm.mongodb.%s_connection.event_manager', $connectionName)));
}
}
