public function register(Application $app)
{
//Load Doctrine Configuration
$app['db.configuration'] = $app->share(function () use($app) {
AnnotationRegistry::registerAutoloadNamespace("Doctrine\\ORM\\Mapping", __DIR__ . '/../../../../../doctrine/orm/lib');
$config = new ORMConfiguration();
$cache = $app['debug'] == false ? new ApcCache() : new ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$chain = new DriverChain();
foreach ((array) $app['db.orm.entities'] as $entity) {
switch ($entity['type']) {
case 'annotation':
$reader = new AnnotationReader();
$driver = new AnnotationDriver($reader, (array) $entity['path']);
$chain->addDriver($driver, $entity['namespace']);
break;
/*case 'yml':
$driver = new YamlDriver((array)$entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array)$entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;*/
/*case 'yml':
$driver = new YamlDriver((array)$entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array)$entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;*/
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $type));
break;
}
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['db.orm.proxies_dir']);
$config->setProxyNamespace($app['db.orm.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['db.orm.auto_generate_proxies']);
return $config;
});
//Set Defaut Configuration
$defaults = array('entities' => array(array('type' => 'annotation', 'path' => 'Entity', 'namespace' => 'Entity')), 'proxies_dir' => 'cache/doctrine/Proxy', 'proxies_namespace' => 'DoctrineProxy', 'auto_generate_proxies' => true);
foreach ($defaults as $key => $value) {
if (!isset($app['db.orm.' . $key])) {
$app['db.orm.' . $key] = $value;
}
}
$self = $this;
$app['db.orm.em'] = $app->share(function () use($self, $app) {
return EntityManager::create($app['db'], $app['db.configuration']);
});
}
protected function getMetadataDriverImplementation()
{
$xmlDriver = new XmlDriver(__DIR__ . '/../Driver/Xml');
$chain = new DriverChain();
$chain->addDriver($xmlDriver, 'Mapping\\Fixture\\Xml');
return $chain;
}
/**
* @group DDC-706
*/
public function testIsTransient()
{
$chain = new DriverChain();
$chain->addDriver($this->createAnnotationDriver(), 'Doctrine\\Tests\\Models\\CMS');
$this->assertTrue($chain->isTransient('stdClass'), "stdClass isTransient");
$this->assertFalse($chain->isTransient('Doctrine\\Tests\\Models\\CMS\\CmsUser'), "CmsUser is not Transient");
}
/**
* Hooks only superclass metadata mapping drivers
* into given $driverChain of drivers for ORM
*
* @param \Doctrine\ORM\Mapping\Driver\DriverChain $chain
* @param \Doctrine\Common\Annotations\Reader $reader
*/
public static function registerAbstractMappingIntoDriverChainORM(DriverORM\DriverChain $driverChain, Reader $reader = null)
{
self::registerAnnotations();
if (!$reader) {
$reader = new CachedReader(new AnnotationReader(), new ArrayCache());
}
$annotationDriver = new DriverORM\AnnotationDriver($reader, array(__DIR__ . '/Translatable/Entity/MappedSuperclass', __DIR__ . '/Loggable/Entity/MappedSuperclass', __DIR__ . '/Tree/Entity/MappedSuperclass'));
$driverChain->addDriver($annotationDriver, 'Gedmo');
}
/**
* @group DDC-706
*/
public function testIsTransient()
{
$reader = new \Doctrine\Common\Annotations\AnnotationReader(new \Doctrine\Common\Cache\ArrayCache());
$reader->setDefaultAnnotationNamespace('Doctrine\\ORM\\Mapping\\');
$chain = new DriverChain();
$chain->addDriver(new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($reader, array()), 'Doctrine\\Tests\\Models\\CMS');
$this->assertTrue($chain->isTransient('stdClass'), "stdClass isTransient");
$this->assertFalse($chain->isTransient('Doctrine\\Tests\\Models\\CMS\\CmsUser'), "CmsUser is not Transient");
}
public function setUp()
{
parent::setUp();
$xmlDriver = new XmlDriver(__DIR__ . '/../Driver/Xml');
$chain = new DriverChain();
$chain->addDriver($xmlDriver, 'Mapping\\Fixture\\Xml');
$this->tree = new TreeListener();
$this->evm = new EventManager();
$this->evm->addEventSubscriber($this->tree);
$this->em = $this->getMockSqliteEntityManager(array('Mapping\\Fixture\\Xml\\NestedTree'), $chain);
}
public function testGatherAllClassNames()
{
$className = 'Doctrine\\Tests\\ORM\\Mapping\\DriverChainEntity';
$classMetadata = new \Doctrine\ORM\Mapping\ClassMetadata($className);
$chain = new DriverChain();
$driver1 = $this->getMock('Doctrine\\ORM\\Mapping\\Driver\\Driver');
$driver1->expects($this->once())->method('getAllClassNames')->will($this->returnValue(array('Foo')));
$driver2 = $this->getMock('Doctrine\\ORM\\Mapping\\Driver\\Driver');
$driver2->expects($this->once())->method('getAllClassNames')->will($this->returnValue(array('Bar', 'Baz')));
$chain->addDriver($driver1, 'Doctrine\\Tests\\Models\\Company');
$chain->addDriver($driver2, 'Doctrine\\Tests\\ORM\\Mapping');
$this->assertEquals(array('Foo', 'Bar', 'Baz'), $chain->getAllClassNames());
}
public function setUp()
{
parent::setUp();
$reader = new AnnotationReader();
$annotationDriver = new AnnotationDriver($reader);
$xmlDriver = new XmlDriver(__DIR__ . '/../Driver/Xml');
$chain = new DriverChain();
$chain->addDriver($annotationDriver, 'Gedmo\\Loggable');
$chain->addDriver($xmlDriver, 'Mapping\\Fixture\\Xml');
$this->loggable = new LoggableListener();
$this->evm = new EventManager();
$this->evm->addEventSubscriber($this->loggable);
$this->em = $this->getMockSqliteEntityManager(array('Gedmo\\Loggable\\Entity\\LogEntry', 'Mapping\\Fixture\\Xml\\Loggable', 'Mapping\\Fixture\\Xml\\LoggableWithEmbedded', 'Mapping\\Fixture\\Xml\\Embedded', 'Mapping\\Fixture\\Xml\\Status'), $chain);
}
public function setUp()
{
parent::setUp();
$reader = new AnnotationReader();
$annotationDriver = new AnnotationDriver($reader);
$xmlDriver = new XmlDriver(__DIR__ . '/../Driver/Xml');
$chain = new DriverChain();
$chain->addDriver($xmlDriver, 'Mapping\\Fixture\\Xml');
$chain->addDriver($annotationDriver, 'Mapping\\Fixture');
$this->sortable = new SortableListener();
$this->evm = new EventManager();
$this->evm->addEventSubscriber($this->sortable);
$this->em = $this->getMockSqliteEntityManager(array('Mapping\\Fixture\\Xml\\Sortable', 'Mapping\\Fixture\\SortableGroup'), $chain);
}
public function setUp()
{
parent::setUp();
Validator::$enableMimeTypesConfigException = false;
$reader = new AnnotationReader();
$annotationDriver = new AnnotationDriver($reader);
$xmlDriver = new XmlDriver(__DIR__ . '/../Driver/Xml');
$chain = new DriverChain();
$chain->addDriver($xmlDriver, 'Mapping\\Fixture\\Xml');
$chain->addDriver($annotationDriver, 'Mapping\\Fixture');
$this->listener = new UploadableListener();
$this->evm = new EventManager();
$this->evm->addEventSubscriber($this->listener);
$this->em = $this->getMockSqliteEntityManager(array('Mapping\\Fixture\\Xml\\Uploadable'), $chain);
}
public function setUp()
{
parent::setUp();
$reader = new AnnotationReader();
$reader->setDefaultAnnotationNamespace('Doctrine\\ORM\\Mapping\\');
$annotationDriver = new AnnotationDriver($reader);
$xmlDriver = new XmlDriver(__DIR__ . '/../Driver/Xml');
$chain = new DriverChain();
$chain->addDriver($annotationDriver, 'Gedmo\\Translatable');
$chain->addDriver($xmlDriver, 'Mapping\\Fixture\\Xml');
$this->translatable = new TranslationListener();
$this->evm = new EventManager();
$this->evm->addEventSubscriber($this->translatable);
$this->em = $this->getMockSqliteEntityManager(array('Gedmo\\Translatable\\Entity\\Translation', 'Mapping\\Fixture\\Xml\\Translatable'), $chain);
}
public function setUp()
{
parent::setUp();
$reader = new AnnotationReader();
$annotationDriver = new AnnotationDriver($reader);
$xmlDriver = new XmlDriver(__DIR__ . '/../Driver/Xml');
$chain = new DriverChain();
$chain->addDriver($xmlDriver, 'Mapping\\Fixture\\Xml');
$chain->addDriver($annotationDriver, 'Mapping\\Fixture');
$chain->addDriver($annotationDriver, 'Gedmo\\Tree');
$this->tree = new TreeListener();
$this->evm = new EventManager();
$this->evm->addEventSubscriber($this->tree);
$this->em = $this->getMockSqliteEntityManager(array('Mapping\\Fixture\\Xml\\MaterializedPathTree'), $chain);
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(TESTS_TEMP_DIR);
$config->setProxyNamespace('Gedmo\\Mapping\\Proxy');
$chainDriverImpl = new DriverChain();
$chainDriverImpl->addDriver(new YamlDriver(array(__DIR__ . '/Driver/Yaml')), 'Mapping\\Fixture\\Yaml');
$config->setMetadataDriverImpl($chainDriverImpl);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
//$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$evm = new \Doctrine\Common\EventManager();
$evm->addEventSubscriber(new TimestampableListener());
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config, $evm);
}
/**
* @return MappingDriver
*/
protected function getMetadataDriverImpl()
{
$rootDir = realpath(__DIR__ . '/../../../..');
if (false === $rootDir || false === is_file($rootDir . '/Payment.php')) {
throw new \RuntimeException('Cannot guess Payum root dir.');
}
$driver = new DriverChain();
$xmlDriver = new SimplifiedXmlDriver(array($rootDir . '/Bridge/Doctrine/Resources/mapping' => 'Payum\\Core\\Model'));
$driver->addDriver($xmlDriver, 'Payum\\Core\\Model');
$rc = new \ReflectionClass('\\Doctrine\\ORM\\Mapping\\Driver\\AnnotationDriver');
AnnotationRegistry::registerFile(dirname($rc->getFileName()) . '/DoctrineAnnotations.php');
$rc = new \ReflectionClass('Payum\\Core\\Tests\\Mocks\\Entity\\TestModel');
$annotationDriver = new AnnotationDriver(new AnnotationReader(), array(dirname($rc->getFileName())));
$driver->addDriver($annotationDriver, 'Payum\\Core\\Tests\\Mocks\\Entity');
return $driver;
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(TESTS_TEMP_DIR);
$config->setProxyNamespace('Gedmo\\Mapping\\Proxy');
$chainDriverImpl = new DriverChain();
$chainDriverImpl->addDriver(new YamlDriver(array(__DIR__ . '/Driver/Yaml')), 'Mapping\\Fixture\\Yaml');
$reader = new \Doctrine\Common\Annotations\AnnotationReader();
\Doctrine\Common\Annotations\AnnotationRegistry::registerAutoloadNamespace('Gedmo\\Mapping\\Annotation', VENDOR_PATH . '/../lib');
$chainDriverImpl->addDriver(new \Doctrine\ORM\Mapping\Driver\AnnotationDriver($reader), 'Mapping\\Fixture');
$config->setMetadataDriverImpl($chainDriverImpl);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$evm = new \Doctrine\Common\EventManager();
$evm->addEventSubscriber(new SluggableListener());
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config, $evm);
}
public function setUp()
{
parent::setUp();
// EM with standard annotation mapping
$this->em1 = $this->getMockSqliteEntityManager(array('Sluggable\\Fixture\\Article'));
// EM with yaml and annotation mapping
$reader = new AnnotationReader();
$annotationDriver = new AnnotationDriver($reader);
$reader = new AnnotationReader();
$annotationDriver2 = new AnnotationDriver($reader);
$yamlDriver = new YamlDriver(__DIR__ . '/Driver/Yaml');
$chain = new DriverChain();
$chain->addDriver($annotationDriver, 'Translatable\\Fixture');
$chain->addDriver($yamlDriver, 'Mapping\\Fixture\\Yaml');
$chain->addDriver($annotationDriver2, 'Gedmo\\Translatable');
$this->em2 = $this->getMockSqliteEntityManager(array('Translatable\\Fixture\\PersonTranslation', 'Mapping\\Fixture\\Yaml\\User'), $chain);
// DM with standard annotation mapping
$this->dm1 = $this->getMockDocumentManager('gedmo_extensions_test');
}
public function setUp()
{
$config = new \Doctrine\ORM\Configuration();
$config->setMetadataCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setQueryCacheImpl(new \Doctrine\Common\Cache\ArrayCache());
$config->setProxyDir(TESTS_TEMP_DIR);
$config->setProxyNamespace('Gedmo\\Mapping\\Proxy');
$chainDriverImpl = new DriverChain();
$chainDriverImpl->addDriver(new YamlDriver(array(__DIR__ . '/Driver/Yaml')), 'Mapping\\Fixture\\Yaml');
$config->setMetadataDriverImpl($chainDriverImpl);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
//$config->setSQLLogger(new \Doctrine\DBAL\Logging\EchoSQLLogger());
$evm = new \Doctrine\Common\EventManager();
$this->translatableListener = new TranslationListener();
$this->translatableListener->setTranslatableLocale('en_us');
$evm->addEventSubscriber($this->translatableListener);
$this->em = \Doctrine\ORM\EntityManager::create($conn, $config, $evm);
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($this->em);
$schemaTool->dropSchema(array());
$schemaTool->createSchema(array($this->em->getClassMetadata(self::TEST_YAML_ENTITY_CLASS)));
}
public function setUp()
{
$this->_oldEntityManager = \SoliantEntityAudit\Module::getModuleOptions()->getEntityManager();
$this->_oldAuditedClassNames = \SoliantEntityAudit\Module::getModuleOptions()->getAuditedClassNames();
$this->_oldJoinClasses = \SoliantEntityAudit\Module::getModuleOptions()->resetJoinClasses();
$isDevMode = false;
$config = Setup::createConfiguration($isDevMode, null, null);
$chain = new DriverChain();
// Use ZFC User for authentication tests
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuser'), 'ZfcUser\\Entity');
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuserdoctrineorm'), 'ZfcUserDoctrineORM\\Entity');
$chain->addDriver(new StaticPHPDriver(__DIR__ . "/../Models"), 'SoliantEntityAuditTest\\Models\\LogRevision');
$chain->addDriver(new AuditDriver('.'), 'SoliantEntityAudit\\Entity');
$config->setMetadataDriverImpl($chain);
// Replace entity manager
$moduleOptions = \SoliantEntityAudit\Module::getModuleOptions();
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$moduleOptions->setAuditedClassNames(array('SoliantEntityAuditTest\\Models\\LogRevision\\Album' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Performer' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\Song' => array(), 'SoliantEntityAuditTest\\Models\\LogRevision\\SingleCoverArt' => array()));
$entityManager = EntityManager::create($conn, $config);
$moduleOptions->setEntityManager($entityManager);
$schemaTool = new SchemaTool($entityManager);
// Add auditing listener
$entityManager->getEventManager()->addEventSubscriber(new LogRevision());
$sql = $schemaTool->getUpdateSchemaSql($entityManager->getMetadataFactory()->getAllMetadata());
#print_r($sql);die();
$schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata());
$this->_em = $entityManager;
}
public function loadDoctrineConfiguration(Application $app)
{
$self = $this;
$app['db.orm.config'] = $app->share(function () use($app, $self) {
$cache = $app['db.orm.cache'];
$config = new ORMConfiguration();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$chain = new DriverChain();
foreach ((array) $app['db.orm.entities'] as $entity) {
switch ($entity['type']) {
case 'default':
case 'annotation':
$driver = $config->newDefaultAnnotationDriver((array) $entity['path']);
$chain->addDriver($driver, $entity['namespace']);
break;
case 'yml':
$driver = new YamlDriver((array) $entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array) $entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $entity['type']));
break;
}
$self->autoloader->registerNamespace($entity['namespace'], $entity['path']);
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['db.orm.proxies_dir']);
$config->setProxyNamespace($app['db.orm.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['db.orm.auto_generate_proxies']);
return $config;
});
}
/**
* @group DDC-1412
*/
public function testDefaultDriver()
{
$companyDriver = $this->getMock('Doctrine\\ORM\\Mapping\\Driver\\Driver');
$dafaultDriver = $this->getMock('Doctrine\\ORM\\Mapping\\Driver\\Driver');
$entityClassName = 'Doctrine\\Tests\\ORM\\Mapping\\DriverChainEntity';
$managerClassName = 'Doctrine\\Tests\\Models\\Company\\CompanyManager';
$chain = new DriverChain();
$companyDriver->expects($this->never())->method('loadMetadataForClass');
$companyDriver->expects($this->once())->method('isTransient')->with($this->equalTo($managerClassName))->will($this->returnValue(false));
$dafaultDriver->expects($this->never())->method('loadMetadataForClass');
$dafaultDriver->expects($this->once())->method('isTransient')->with($this->equalTo($entityClassName))->will($this->returnValue(true));
$this->assertNull($chain->getDefaultDriver());
$chain->setDefaultDriver($dafaultDriver);
$chain->addDriver($companyDriver, 'Doctrine\\Tests\\Models\\Company');
$this->assertSame($dafaultDriver, $chain->getDefaultDriver());
$this->assertTrue($chain->isTransient($entityClassName));
$this->assertFalse($chain->isTransient($managerClassName));
}
public function setUp()
{
$this->_oldEntityManager = \ZF\Doctrine\Audit\Module::getModuleOptions()->getEntityManager();
$this->_oldAuditedClassNames = \ZF\Doctrine\Audit\Module::getModuleOptions()->getAuditedClassNames();
$isDevMode = true;
$config = Setup::createConfiguration($isDevMode, null, null);
$chain = new DriverChain();
// zfc user is required
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuser'), 'ZfcUser\\Entity');
$chain->addDriver(new XmlDriver(__DIR__ . '/../../../vendor/zf-commons/zfc-user-doctrine-orm/config/xml/zfcuserdoctrineorm'), 'ZfcUserDoctrineORM\\Entity');
$chain->addDriver(new StaticPHPDriver(__DIR__ . "/../Models"), 'ZFTest\\Doctrine\\Audit\\Models\\Autoloader');
$chain->addDriver(new AuditDriver('.'), 'ZF\\Doctrine\\Audit\\Entity');
// Replace entity manager
$moduleOptions = \ZF\Doctrine\Audit\Module::getModuleOptions();
$moduleOptions->setAuditedClassNames(array('ZFTest\\Doctrine\\Audit\\Models\\Autoloader\\Album' => array(), 'ZFTest\\Doctrine\\Audit\\Models\\Autoloader\\Performer' => array(), 'ZFTest\\Doctrine\\Audit\\Models\\Autoloader\\Song' => array()));
$config->setMetadataDriverImpl($chain);
$conn = array('driver' => 'pdo_sqlite', 'memory' => true);
$entityManager = EntityManager::create($conn, $config);
$moduleOptions->setEntityManager($entityManager);
$schemaTool = new SchemaTool($entityManager);
$schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata());
$this->_em = $entityManager;
}
protected function getMetadataDriverImplementation()
{
$chain = new DriverChain();
$chain->addDriver(new YamlDriver(array(__DIR__ . '/../Fixture/Issue116/Mapping')), 'Sluggable\\Fixture\\Issue116');
return $chain;
}
$configuration = (include 'config/application.config.php');
//Register for annotation driver
$annotationReflection = new ReflectionClass('Doctrine\\ORM\\Mapping\\Driver\\AnnotationDriver');
$annotationsFile = realpath(dirname($annotationReflection->getFileName()) . '/DoctrineAnnotations.php');
AnnotationRegistry::registerFile($annotationsFile);
$reader = new \Doctrine\Common\Annotations\SimpleAnnotationReader();
$reader->addNamespace('Doctrine\\ORM\\Mapping');
$reader = new \Doctrine\Common\Annotations\CachedReader($reader, new ArrayCache());
/***/
// Setup service manager
$serviceManager = new ServiceManager(new ServiceManagerConfiguration($configuration['service_manager']));
$serviceManager->setService('ApplicationConfiguration', $configuration);
$modules = $serviceManager->get('ModuleManager')->loadModules();
$conf = $modules->getEvent()->getConfigListener()->getMergedConfig();
$drivers = $conf->di->instance->orm_driver_chain->parameters->drivers->toArray();
$driverChain = new DriverChain();
foreach ($drivers as $driver) {
if (!is_array($driver)) {
continue;
}
$class = $driver['class'];
$paths = $driver['paths'];
$namespace = $driver['namespace'];
if ($class == 'Doctrine\\ORM\\Mapping\\Driver\\AnnotationDriver') {
$driverObject = new $class($reader, $paths);
} else {
$driverObject = new $class($paths);
}
$driverChain->addDriver($driverObject, $namespace);
}
//$class = "Doctrine\ORM\Mapping\Driver\AnnotationDriver";
public function loadDoctrineConfiguration(Application $app)
{
$app['doctrine.configuration'] = $app->share(function () use($app) {
if (isset($app['doctrine.orm']) and true === $app['doctrine.orm']) {
$config = new ORMConfiguration();
$cache = new ApcCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$chain = new DriverChain();
foreach ((array) $app['doctrine.orm.entities'] as $entity) {
switch ($entity['type']) {
case 'annotation':
$reader = new AnnotationReader();
$reader->setAnnotationNamespaceAlias('Doctrine\\ORM\\Mapping\\', 'orm');
$driver = new AnnotationDriver($reader, (array) $entity['path']);
$chain->addDriver($driver, $entity['namespace']);
break;
case 'yml':
$driver = new YamlDriver((array) $entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array) $entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $type));
break;
}
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['doctrine.orm.proxies_dir']);
$config->setProxyNamespace($app['doctrine.orm.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['doctrine.orm.auto_generate_proxies']);
} else {
$config = new DBALConfiguration();
}
return $config;
});
}
//this needs to be customized, if you want to collect all errors centralized.
$syslogHandler = new SyslogHandler('minerva-warning');
$syslogHandler->setLevel(Logger::ERROR);
$log->pushHandler($syslogHandler);
return $log;
};
/* Doctrine */
$di['orm'] = function () use($di) {
//Create cached annotation reader
AnnotationRegistry::registerFile(__DIR__ . '/../vendor/doctrine/orm/lib/Doctrine/ORM/Mapping/Driver/DoctrineAnnotations.php');
//@note The ArrayCache is not very fast, if possible, replace with e.g. Memcached
$cache = new ArrayCache();
$annotationReader = new AnnotationReader();
$cachedAnnotationReader = new CachedReader($annotationReader, $cache);
//Hook annotation driver into driver chain
$driverChain = new DriverChain();
//Register entities
$annotationDriver = new AnnotationDriver($cachedAnnotationReader, array(join(\DIRECTORY_SEPARATOR, array(__DIR__, '..', 'src', 'app', 'Model', 'Entity'))));
$driverChain->addDriver($annotationDriver, 'Minerva\\Model\\Entity');
//Configure doctrine
$config = new Configuration();
$config->setProxyDir(join(\DIRECTORY_SEPARATOR, array(__DIR__, '..', 'runtime', 'proxy')));
$config->setProxyNamespace('Minerva\\Proxy');
$config->setAutoGenerateProxyClasses(true);
$config->setMetadataDriverImpl($driverChain);
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
//Configure events
$eventManager = new EventManager();
//Configure temporary database for test case usage
$db = EntityManager::create(array('driver' => 'pdo_sqlite', 'memory' => true), $config, $eventManager);
public function loadDoctrineConfiguration(Application $app)
{
$app['doctrine.configuration'] = $app->share(function () use($app) {
if (isset($app['doctrine.orm']) and true === $app['doctrine.orm']) {
// Check available cache drivers
if (extension_loaded('apc')) {
$cache = new ApcCache();
} else {
if (extension_loaded('xcache')) {
$cache = new XcacheCache();
} else {
if (extension_loaded('memcache')) {
$memcache = new \Memcache();
$memcache->connect('127.0.0.1');
$cache = new MemcacheCache();
$cache->setMemcache($memcache);
} else {
$cache = new ArrayCache();
}
}
}
$cache->setNamespace("dc2_");
// to avoid collisions
$config = new ORMConfiguration();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$chain = new DriverChain();
foreach ((array) $app['doctrine.orm.entities'] as $entity) {
switch ($entity['type']) {
case 'annotation':
$reader = new AnnotationReader();
$driver = new AnnotationDriver($reader, (array) $entity['path']);
$chain->addDriver($driver, $entity['namespace']);
break;
case 'yml':
$driver = new YamlDriver((array) $entity['path']);
$driver->setFileExtension('.yml');
$chain->addDriver($driver, $entity['namespace']);
break;
case 'xml':
$driver = new XmlDriver((array) $entity['path'], $entity['namespace']);
$driver->setFileExtension('.xml');
$chain->addDriver($driver, $entity['namespace']);
break;
default:
throw new \InvalidArgumentException(sprintf('"%s" is not a recognized driver', $entity['type']));
break;
}
}
$config->setMetadataDriverImpl($chain);
$config->setProxyDir($app['doctrine.orm.proxies_dir']);
$config->setProxyNamespace($app['doctrine.orm.proxies_namespace']);
$config->setAutoGenerateProxyClasses($app['doctrine.orm.auto_generate_proxies']);
} else {
$config = new DBALConfiguration();
}
return $config;
});
}
