--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vendor/symfony/src/Symfony/Bundle/DoctrineBundle/DependencyInjection/DoctrineExtension.php Sat Sep 24 15:40:41 2011 +0200
@@ -0,0 +1,415 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Bundle\DoctrineBundle\DependencyInjection;
+
+use Symfony\Component\DependencyInjection\Alias;
+use Symfony\Component\DependencyInjection\Loader\XmlFileLoader;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\DependencyInjection\Definition;
+use Symfony\Component\DependencyInjection\DefinitionDecorator;
+use Symfony\Component\DependencyInjection\Reference;
+use Symfony\Bundle\DoctrineAbstractBundle\DependencyInjection\AbstractDoctrineExtension;
+use Symfony\Component\Config\FileLocator;
+
+/**
+ * DoctrineExtension is an extension for the Doctrine DBAL and ORM library.
+ *
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Benjamin Eberlei <kontakt@beberlei.de>
+ */
+class DoctrineExtension extends AbstractDoctrineExtension
+{
+ public function load(array $configs, ContainerBuilder $container)
+ {
+ $configuration = new Configuration($container->getParameter('kernel.debug'));
+ $config = $this->processConfiguration($configuration, $configs);
+
+ if (!empty($config['dbal'])) {
+ $this->dbalLoad($config['dbal'], $container);
+ }
+
+ if (!empty($config['orm'])) {
+ $this->ormLoad($config['orm'], $container);
+ }
+ }
+
+ /**
+ * Loads the DBAL configuration.
+ *
+ * Usage example:
+ *
+ * <doctrine:dbal id="myconn" dbname="sfweb" user="root" />
+ *
+ * @param array $config An array of configuration settings
+ * @param ContainerBuilder $container A ContainerBuilder instance
+ */
+ protected function dbalLoad(array $config, ContainerBuilder $container)
+ {
+ $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
+ $loader->load('dbal.xml');
+
+ if (empty($config['default_connection'])) {
+ $keys = array_keys($config['connections']);
+ $config['default_connection'] = reset($keys);
+ }
+ $this->defaultConnection = $config['default_connection'];
+
+ $container->setAlias('database_connection', sprintf('doctrine.dbal.%s_connection', $this->defaultConnection));
+ $container->setAlias('doctrine.dbal.event_manager', new Alias(sprintf('doctrine.dbal.%s_connection.event_manager', $this->defaultConnection), false));
+
+ $container->setParameter('doctrine.dbal.connection_factory.types', $config['types']);
+
+ $connections = array();
+ foreach (array_keys($config['connections']) as $name) {
+ $connections[$name] = sprintf('doctrine.dbal.%s_connection', $name);
+ }
+ $container->setParameter('doctrine.connections', $connections);
+ $container->setParameter('doctrine.default_connection', $this->defaultConnection);
+
+ foreach ($config['connections'] as $name => $connection) {
+ $this->loadDbalConnection($name, $connection, $container);
+ }
+ }
+
+ /**
+ * Loads a configured DBAL connection.
+ *
+ * @param string $name The name of the connection
+ * @param array $connection A dbal connection configuration.
+ * @param ContainerBuilder $container A ContainerBuilder instance
+ */
+ protected function loadDbalConnection($name, array $connection, ContainerBuilder $container)
+ {
+ // configuration
+ $configuration = $container->setDefinition(sprintf('doctrine.dbal.%s_connection.configuration', $name), new DefinitionDecorator('doctrine.dbal.connection.configuration'));
+ if (isset($connection['logging']) && $connection['logging']) {
+ $configuration->addMethodCall('setSQLLogger', array(new Reference('doctrine.dbal.logger')));
+ unset ($connection['logging']);
+ }
+
+ // event manager
+ $def = $container->setDefinition(sprintf('doctrine.dbal.%s_connection.event_manager', $name), new DefinitionDecorator('doctrine.dbal.connection.event_manager'));
+
+ // connection
+ if (isset($connection['charset'])) {
+ if ((isset($connection['driver']) && stripos($connection['driver'], 'mysql') !== false) ||
+ (isset($connection['driver_class']) && stripos($connection['driver_class'], 'mysql') !== false)) {
+ $mysqlSessionInit = new Definition('%doctrine.dbal.events.mysql_session_init.class%');
+ $mysqlSessionInit->setArguments(array($connection['charset']));
+ $mysqlSessionInit->setPublic(false);
+ $mysqlSessionInit->addTag('doctrine.event_subscriber', array('connection' => $name));
+
+ $container->setDefinition(
+ sprintf('doctrine.dbal.%s_connection.events.mysqlsessioninit', $name),
+ $mysqlSessionInit
+ );
+ unset($connection['charset']);
+ }
+ }
+
+ $options = $this->getConnectionOptions($connection);
+
+ $container
+ ->setDefinition(sprintf('doctrine.dbal.%s_connection', $name), new DefinitionDecorator('doctrine.dbal.connection'))
+ ->setArguments(array(
+ $options,
+ new Reference(sprintf('doctrine.dbal.%s_connection.configuration', $name)),
+ new Reference(sprintf('doctrine.dbal.%s_connection.event_manager', $name)),
+ $connection['mapping_types'],
+ ))
+ ;
+ }
+
+ protected function getConnectionOptions($connection)
+ {
+ $options = $connection;
+
+ if (isset($options['platform_service'])) {
+ $options['platform'] = new Reference($options['platform_service']);
+ unset($options['platform_service']);
+ }
+ unset($options['mapping_types']);
+
+ foreach (array(
+ 'options' => 'driverOptions',
+ 'driver_class' => 'driverClass',
+ 'wrapper_class' => 'wrapperClass',
+ ) as $old => $new) {
+ if (isset($options[$old])) {
+ $options[$new] = $options[$old];
+ unset($options[$old]);
+ }
+ }
+
+ return $options;
+ }
+
+ /**
+ * Loads the Doctrine ORM configuration.
+ *
+ * Usage example:
+ *
+ * <doctrine:orm id="mydm" connection="myconn" />
+ *
+ * @param array $config An array of configuration settings
+ * @param ContainerBuilder $container A ContainerBuilder instance
+ */
+ protected function ormLoad(array $config, ContainerBuilder $container)
+ {
+ $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
+ $loader->load('orm.xml');
+
+ $this->entityManagers = array();
+ foreach (array_keys($config['entity_managers']) as $name) {
+ $this->entityManagers[$name] = sprintf('doctrine.orm.%s_entity_manager', $name);
+ }
+ $container->setParameter('doctrine.entity_managers', $this->entityManagers);
+
+ if (empty($config['default_entity_manager'])) {
+ $tmp = array_keys($this->entityManagers);
+ $config['default_entity_manager'] = reset($tmp);
+ }
+ $container->setParameter('doctrine.default_entity_manager', $config['default_entity_manager']);
+
+ $options = array('auto_generate_proxy_classes', 'proxy_dir', 'proxy_namespace');
+ foreach ($options as $key) {
+ $container->setParameter('doctrine.orm.'.$key, $config[$key]);
+ }
+
+ $container->setAlias('doctrine.orm.entity_manager', sprintf('doctrine.orm.%s_entity_manager', $config['default_entity_manager']));
+
+ foreach ($config['entity_managers'] as $name => $entityManager) {
+ $entityManager['name'] = $name;
+ $this->loadOrmEntityManager($entityManager, $container);
+ }
+ }
+
+ /**
+ * 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)
+ {
+ if ($entityManager['auto_mapping'] && count($this->entityManagers) > 1) {
+ throw new \LogicException('You cannot enable "auto_mapping" when several entity managers are defined.');
+ }
+
+ $ormConfigDef = $container->setDefinition(sprintf('doctrine.orm.%s_configuration', $entityManager['name']), new DefinitionDecorator('doctrine.orm.configuration'));
+
+ $this->loadOrmEntityManagerMappingInformation($entityManager, $ormConfigDef, $container);
+ $this->loadOrmCacheDrivers($entityManager, $container);
+
+ $methods = 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 ($methods 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));
+ }
+ }
+
+ if (!isset($entityManager['connection'])) {
+ $entityManager['connection'] = $this->defaultConnection;
+ }
+
+ $container
+ ->setDefinition(sprintf('doctrine.orm.%s_entity_manager', $entityManager['name']), new DefinitionDecorator('doctrine.orm.entity_manager.abstract'))
+ ->setArguments(array(
+ new Reference(sprintf('doctrine.dbal.%s_connection', $entityManager['connection'])),
+ new Reference(sprintf('doctrine.orm.%s_configuration', $entityManager['name']))
+ ))
+ ;
+
+ $container->setAlias(
+ sprintf('doctrine.orm.%s_entity_manager.event_manager', $entityManager['name']),
+ new Alias(sprintf('doctrine.dbal.%s_connection.event_manager', $entityManager['connection']), false)
+ );
+ }
+
+ /**
+ * Loads an ORM entity managers bundle mapping information.
+ *
+ * There are two distinct configuration possibilities for mapping information:
+ *
+ * 1. Specify a bundle and optionally details where the entity and mapping information reside.
+ * 2. Specify an arbitrary mapping location.
+ *
+ * @example
+ *
+ * doctrine.orm:
+ * mappings:
+ * MyBundle1: ~
+ * MyBundle2: yml
+ * MyBundle3: { type: annotation, dir: Entities/ }
+ * MyBundle4: { type: xml, dir: Resources/config/doctrine/mapping }
+ * MyBundle5:
+ * type: yml
+ * dir: [bundle-mappings1/, bundle-mappings2/]
+ * alias: BundleAlias
+ * arbitrary_key:
+ * type: xml
+ * dir: %kernel.dir%/../src/vendor/DoctrineExtensions/lib/DoctrineExtensions/Entities
+ * prefix: DoctrineExtensions\Entities\
+ * alias: DExt
+ *
+ * In the case of bundles everything is really optional (which leads to autodetection for this bundle) but
+ * in the mappings key everything except alias is a required argument.
+ *
+ * @param array $entityManager A configured ORM entity manager.
+ * @param ContainerBuilder $container A ContainerBuilder instance
+ */
+ protected function loadOrmEntityManagerMappingInformation(array $entityManager, Definition $ormConfigDef, ContainerBuilder $container)
+ {
+ // reset state of drivers and alias map. They are only used by this methods and children.
+ $this->drivers = array();
+ $this->aliasMap = array();
+
+ $this->loadMappingInformation($entityManager, $container);
+ $this->registerMappingDrivers($entityManager, $container);
+
+ $ormConfigDef->addMethodCall('setEntityNamespaces', array($this->aliasMap));
+ }
+
+ protected function getObjectManagerElementName($name)
+ {
+ return 'doctrine.orm.'.$name;
+ }
+
+ protected function getMappingObjectDefaultName()
+ {
+ return 'Entity';
+ }
+
+ protected function getMappingResourceConfigDirectory()
+ {
+ return 'Resources/config/doctrine';
+ }
+
+ protected function getMappingResourceExtension()
+ {
+ return 'orm';
+ }
+
+ /**
+ * Loads a configured entity managers cache drivers.
+ *
+ * @param array $entityManager A configured ORM entity manager.
+ * @param ContainerBuilder $container A ContainerBuilder instance
+ */
+ protected function loadOrmCacheDrivers(array $entityManager, ContainerBuilder $container)
+ {
+ $this->loadOrmEntityManagerCacheDriver($entityManager, $container, 'metadata_cache');
+ $this->loadOrmEntityManagerCacheDriver($entityManager, $container, 'result_cache');
+ $this->loadOrmEntityManagerCacheDriver($entityManager, $container, 'query_cache');
+ }
+
+ /**
+ * Loads a configured entity managers metadata, query or result cache driver.
+ *
+ * @param array $entityManager A configured ORM entity manager.
+ * @param ContainerBuilder $container A ContainerBuilder instance
+ * @param string $cacheName
+ */
+ protected function loadOrmEntityManagerCacheDriver(array $entityManager, ContainerBuilder $container, $cacheName)
+ {
+ $cacheDriverService = sprintf('doctrine.orm.%s_%s', $entityManager['name'], $cacheName);
+
+ $driver = $cacheName."_driver";
+ $cacheDef = $this->getEntityManagerCacheDefinition($entityManager, $entityManager[$driver], $container);
+ $container->setDefinition($cacheDriverService, $cacheDef);
+ }
+
+ /**
+ * Gets an entity manager cache driver definition for metadata, query and result caches.
+ *
+ * @param array $entityManager The array configuring an entity manager.
+ * @param array $cacheDriver The cache driver configuration.
+ * @param ContainerBuilder $container
+ * @return Definition $cacheDef
+ */
+ protected function getEntityManagerCacheDefinition(array $entityManager, $cacheDriver, ContainerBuilder $container)
+ {
+ switch ($cacheDriver['type']) {
+ case 'memcache':
+ $memcacheClass = !empty($cacheDriver['class']) ? $cacheDriver['class'] : '%doctrine.orm.cache.memcache.class%';
+ $memcacheInstanceClass = !empty($cacheDriver['instance_class']) ? $cacheDriver['instance_class'] : '%doctrine.orm.cache.memcache_instance.class%';
+ $memcacheHost = !empty($cacheDriver['host']) ? $cacheDriver['host'] : '%doctrine.orm.cache.memcache_host%';
+ $memcachePort = !empty($cacheDriver['port']) ? $cacheDriver['port'] : '%doctrine.orm.cache.memcache_port%';
+ $cacheDef = new Definition($memcacheClass);
+ $memcacheInstance = new Definition($memcacheInstanceClass);
+ $memcacheInstance->addMethodCall('connect', array(
+ $memcacheHost, $memcachePort
+ ));
+ $container->setDefinition(sprintf('doctrine.orm.%s_memcache_instance', $entityManager['name']), $memcacheInstance);
+ $cacheDef->addMethodCall('setMemcache', array(new Reference(sprintf('doctrine.orm.%s_memcache_instance', $entityManager['name']))));
+ break;
+ case 'apc':
+ case 'array':
+ case 'xcache':
+ $cacheDef = new Definition('%'.sprintf('doctrine.orm.cache.%s.class', $cacheDriver['type']).'%');
+ break;
+ default:
+ throw new \InvalidArgumentException(sprintf('"%s" is an unrecognized Doctrine cache driver.', $cacheDriver['type']));
+ }
+
+ $cacheDef->setPublic(false);
+ // generate a unique namespace for the given application
+ $namespace = 'sf2orm_'.$entityManager['name'].'_'.md5($container->getParameter('kernel.root_dir').$container->getParameter('kernel.environment'));
+ $cacheDef->addMethodCall('setNamespace', array($namespace));
+
+ return $cacheDef;
+ }
+
+ /**
+ * Returns the base path for the XSD files.
+ *
+ * @return string The XSD base path
+ */
+ public function getXsdValidationBasePath()
+ {
+ return __DIR__.'/../Resources/config/schema';
+ }
+
+ /**
+ * Returns the namespace to be used for this extension (XML namespace).
+ *
+ * @return string The XML namespace
+ */
+ public function getNamespace()
+ {
+ return 'http://symfony.com/schema/dic/doctrine';
+ }
+}