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))); } }