public function __construct()
{
// load database configuration from CodeIgniter
require APPPATH . 'config/database.php';
//A Doctrine Autoloader is needed to load the models
// first argument of classloader is namespace and second argument is path
// setup models/entity namespace
$entityLoader = new ClassLoader('models', APPPATH);
$entityLoader->register();
foreach (glob(APPPATH . 'modules/*', GLOB_ONLYDIR) as $m) {
$module = str_replace(APPPATH . 'modules/', '', $m);
$entityLoader = new ClassLoader($module, APPPATH . 'modules');
$entityLoader->register();
}
//Register proxies namespace
$proxyLoader = new ClassLoader('Proxies', APPPATH . 'Proxies');
$proxyLoader->register();
// Set up caches
$config = new Configuration();
$cache = new ArrayCache();
$config->setMetadataCacheImpl($cache);
$driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models'));
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
// Set up entity
$reader = new AnnotationReader($cache);
$models = array(APPPATH . 'models');
foreach (glob(APPPATH . 'modules/*/models', GLOB_ONLYDIR) as $m) {
array_push($models, $m);
}
$driver = new AnnotationDriver($reader, $models);
$config->setMetadataDriverImpl($driver);
// Setup Gedmo
$cachedAnnotationReader = new Doctrine\Common\Annotations\CachedReader($reader, $cache);
// create a driver chain for metadata reading
$driverChain = new Doctrine\ORM\Mapping\Driver\DriverChain();
// load superclass metadata mapping only, into driver chain
// also registers Gedmo annotations.NOTE: you can personalize it
Gedmo\DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $cachedAnnotationReader);
$event = new EventManager();
$timestampableListener = new TimestampableListener();
$timestampableListener->setAnnotationReader($cachedAnnotationReader);
$event->addEventSubscriber($timestampableListener);
$slugListener = new SluggableListener();
$slugListener->setAnnotationReader($cachedAnnotationReader);
$event->addEventSubscriber($slugListener);
// Proxy configuration
$config->setProxyDir(APPPATH . '/proxies');
$config->setProxyNamespace('Proxies');
// Set up logger
// $logger = new EchoSQLLogger;
// $config->setSQLLogger($logger);
$config->setAutoGenerateProxyClasses(TRUE);
// Database connection information
$connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']);
// Create EntityManager
$this->em = EntityManager::create($connectionOptions, $config, $event);
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$sluggableListener = new SluggableListener();
$sluggableListener->addManagedFilter(self::SOFT_DELETEABLE_FILTER_NAME, true);
$evm->addEventSubscriber($sluggableListener);
$this->softDeleteableListener = new SoftDeleteableListener();
$evm->addEventSubscriber($this->softDeleteableListener);
$config = $this->getMockAnnotatedConfig();
$config->addFilter(self::SOFT_DELETEABLE_FILTER_NAME, 'Gedmo\\SoftDeleteable\\Filter\\SoftDeleteableFilter');
$this->em = $this->getMockSqliteEntityManager($evm, $config);
$this->em->getFilters()->enable(self::SOFT_DELETEABLE_FILTER_NAME);
}
/**
* Transliterates the slug and prefixes the slug
* by collection of parent slugs
*
* @param string $text
* @param string $separator
* @param object $object
* @return string
*/
public function transliterate($text, $separator, $object)
{
$slug = call_user_func_array($this->originalTransliterator, array($text, $separator, $object));
if (strlen($this->parentSlug)) {
$slug = $this->parentSlug . $this->usedPathSeparator . $slug;
}
$this->sluggable->setTransliterator($this->originalTransliterator);
return $slug;
}
/**
* {@inheritDoc}
*/
public function onSlugCompletion(SluggableAdapter $ea, array &$config, $object, &$slug)
{
$this->om = $ea->getObjectManager();
$isInsert = $this->om->getUnitOfWork()->isScheduledForInsert($object);
if (!$isInsert) {
$options = $config['handlers'][get_called_class()];
$wrapped = AbstractWrapper::wrapp($object, $this->om);
$oldSlug = $wrapped->getPropertyValue($config['slug']);
$mappedByConfig = $this->sluggable->getConfiguration($this->om, $options['relationClass']);
if ($mappedByConfig) {
$meta = $this->om->getClassMetadata($options['relationClass']);
if (!$meta->isSingleValuedAssociation($options['mappedBy'])) {
throw new InvalidMappingException("Unable to find " . $wrapped->getMetadata()->name . " relation - [{$options['mappedBy']}] in class - {$meta->name}");
}
if (!isset($mappedByConfig['slugs'][$options['inverseSlugField']])) {
throw new InvalidMappingException("Unable to find slug field - [{$options['inverseSlugField']}] in class - {$meta->name}");
}
$mappedByConfig['slug'] = $mappedByConfig['slugs'][$options['inverseSlugField']]['slug'];
$mappedByConfig['mappedBy'] = $options['mappedBy'];
$ea->replaceInverseRelative($object, $mappedByConfig, $slug, $oldSlug);
$uow = $this->om->getUnitOfWork();
// update in memory objects
foreach ($uow->getIdentityMap() as $className => $objects) {
// for inheritance mapped classes, only root is always in the identity map
if ($className !== $mappedByConfig['useObjectClass']) {
continue;
}
foreach ($objects as $object) {
if (property_exists($object, '__isInitialized__') && !$object->__isInitialized__) {
continue;
}
$oid = spl_object_hash($object);
$objectSlug = $meta->getReflectionProperty($mappedByConfig['slug'])->getValue($object);
if (preg_match("@^{$oldSlug}@smi", $objectSlug)) {
$objectSlug = str_replace($oldSlug, $slug, $objectSlug);
$meta->getReflectionProperty($mappedByConfig['slug'])->setValue($object, $objectSlug);
$ea->setOriginalObjectProperty($uow, $oid, $mappedByConfig['slug'], $objectSlug);
}
}
}
}
}
}
/**
* @test
*/
public function shouldBeAbleToMapSluggableMetadata()
{
$meta = $this->em->getClassMetadata('Mapping\\Fixture\\Xml\\Sluggable');
$config = $this->sluggable->getConfiguration($this->em, $meta->name);
$this->assertArrayHasKey('slug', $config['slugs']);
$this->assertCount(1, $config['slugs']);
$config = $config['slugs']['slug'];
$this->assertEquals('slug', $config['slug']);
$this->assertArrayHasKey('style', $config);
$this->assertEquals('camel', $config['style']);
$this->assertArrayHasKey('updatable', $config);
$this->assertFalse($config['updatable']);
$this->assertArrayHasKey('unique', $config);
$this->assertTrue($config['unique']);
$this->assertArrayHasKey('separator', $config);
$this->assertEquals('_', $config['separator']);
$this->assertArrayHasKey('fields', $config);
$this->assertCount(3, $config['fields']);
$fields = $config['fields'];
$this->assertEquals('title', $fields[0]);
$this->assertEquals('ean', $fields[1]);
$this->assertEquals('code', $fields[2]);
$this->assertArrayHasKey('handlers', $config);
$this->assertEquals(2, count($config['handlers']));
$handlers = $config['handlers'];
$this->assertArrayHasKey('Gedmo\\Sluggable\\Handler\\TreeSlugHandler', $handlers);
$this->assertArrayHasKey('Gedmo\\Sluggable\\Handler\\RelativeSlugHandler', $handlers);
$first = $handlers['Gedmo\\Sluggable\\Handler\\TreeSlugHandler'];
$this->assertEquals(2, count($first));
$this->assertArrayHasKey('parentRelationField', $first);
$this->assertArrayHasKey('separator', $first);
$this->assertEquals('parent', $first['parentRelationField']);
$this->assertEquals('/', $first['separator']);
$second = $handlers['Gedmo\\Sluggable\\Handler\\RelativeSlugHandler'];
$this->assertEquals(3, count($second));
$this->assertArrayHasKey('relationField', $second);
$this->assertArrayHasKey('relationSlugField', $second);
$this->assertArrayHasKey('separator', $second);
$this->assertEquals('parent', $second['relationField']);
$this->assertEquals('test', $second['relationSlugField']);
$this->assertEquals('-', $second['separator']);
}
/**
* Transliterates the slug and prefixes the slug
* by collection of parent slugs
*
* @param string $text
* @param string $separator
* @param object $object
* @return string
*/
public function transliterate($text, $separator, $object)
{
$slug = call_user_func_array($this->originalTransliterator, array($text, $separator, $object));
// For tree slugs, we "urlize" each part of the slug before appending "/"
$slug = Urlizer::urlize($slug, $separator);
if (strlen($this->parentSlug)) {
$slug = $this->parentSlug . $this->usedPathSeparator . $slug;
}
$this->sluggable->setTransliterator($this->originalTransliterator);
return $slug;
}
/**
* Transliterates the slug and prefixes the slug
* by collection of parent slugs
*
* @param string $text
* @param string $separator
* @param object $object
* @return string
*/
public function transliterate($text, $separator, $object)
{
$slug = call_user_func_array(
$this->originalTransliterator,
array($text, $separator, $object)
);
if (strlen($this->parentSlug)) {
$options = $this->getOptions($object);
$slug = $this->parentSlug . $options['separator'] . $slug;
}
$this->sluggable->setTransliterator($this->originalTransliterator);
return $slug;
}
/**
* Transliterates the slug and prefixes the slug
* by relative one
*
* @param string $text
* @param string $separator
* @param object $object
* @return string
*/
public function transliterate($text, $separator, $object)
{
$result = call_user_func_array($this->originalTransliterator, array($text, $separator, $object));
$wrapped = AbstractWrapper::wrapp($object, $this->om);
$relation = $wrapped->getPropertyValue($this->usedOptions['relationField']);
if ($relation) {
$wrappedRelation = AbstractWrapper::wrapp($relation, $this->om);
$slug = $wrappedRelation->getPropertyValue($this->usedOptions['relationSlugField']);
$result = $slug . $this->usedOptions['separator'] . $result;
}
$this->sluggable->setTransliterator($this->originalTransliterator);
return $result;
}
/**
* @test
*/
public function shouldBeAbleToMapSluggableMetadata()
{
$meta = $this->em->getClassMetadata('Mapping\\Fixture\\Xml\\Sluggable');
$config = $this->sluggable->getConfiguration($this->em, $meta->name);
$this->assertArrayHasKey('slug', $config['slugs']);
$this->assertCount(1, $config['slugs']);
$config = $config['slugs']['slug'];
$this->assertEquals('slug', $config['slug']);
$this->assertArrayHasKey('style', $config);
$this->assertEquals('camel', $config['style']);
$this->assertArrayHasKey('updatable', $config);
$this->assertFalse($config['updatable']);
$this->assertArrayHasKey('unique', $config);
$this->assertTrue($config['unique']);
$this->assertArrayHasKey('separator', $config);
$this->assertEquals('_', $config['separator']);
$this->assertArrayHasKey('fields', $config);
$this->assertCount(3, $config['fields']);
$fields = $config['fields'];
$this->assertEquals('title', $fields[0]);
$this->assertEquals('ean', $fields[1]);
$this->assertEquals('code', $fields[2]);
}
public function testSluggableMetadata()
{
$meta = $this->em->getClassMetadata('Mapping\\Fixture\\Xml\\Sluggable');
$config = $this->sluggable->getConfiguration($this->em, $meta->name);
$this->assertArrayHasKey('slugFields', $config);
$this->assertEquals('slug', $config['slugFields']['slug']['slug']);
$this->assertArrayHasKey('style', $config['slugFields']['slug']);
$this->assertEquals('camel', $config['slugFields']['slug']['style']);
$this->assertArrayHasKey('updatable', $config['slugFields']['slug']);
$this->assertTrue($config['slugFields']['slug']['updatable']);
$this->assertArrayHasKey('unique', $config['slugFields']['slug']);
$this->assertTrue($config['slugFields']['slug']['unique']);
$this->assertArrayHasKey('separator', $config['slugFields']['slug']);
$this->assertEquals('_', $config['slugFields']['slug']['separator']);
$this->assertArrayHasKey('fields', $config);
$this->assertEquals(3, count($config['fields']['slug']));
$fields = $config['fields'];
$this->assertEquals('title', $fields['slug'][0]['field']);
$this->assertEquals(0, $fields['slug'][0]['position']);
$this->assertEquals('code', $fields['slug'][1]['field']);
$this->assertEquals(false, $fields['slug'][1]['position']);
$this->assertEquals('ean', $fields['slug'][2]['field']);
$this->assertEquals(1, $fields['slug'][2]['position']);
}
/**
* {@inheritDoc}
*/
public function postSlugBuild(SluggableAdapter $ea, array &$config, $object, &$slug)
{
$this->sluggable->setTransliterator(array($this, 'transliterate'));
}
/**
* @param EventManager $manager
* @param EntityManagerInterface $em
* @param Reader $reader
*/
public function addSubscribers(EventManager $manager, EntityManagerInterface $em, Reader $reader)
{
$subscriber = new SluggableListener();
$subscriber->setAnnotationReader($reader);
$manager->addEventSubscriber($subscriber);
}
protected function getNamespace()
{
return parent::getNamespace();
}
/**
*
* @return EntityManager
*/
public function getEntityManager()
{
$cache = new DoctrineCache\ArrayCache();
$annotationReader = new AnnotationReader();
$cachedAnnotationReader = new CachedReader($annotationReader, $cache);
// create a driver chain for metadata reading
$driverChain = new MappingDriverChain();
// load superclass metadata mapping only, into driver chain
// also registers Gedmo annotations.NOTE: you can personalize it
Gedmo\DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $cachedAnnotationReader);
// now we want to register our application entities,
// for that we need another metadata driver used for Entity namespace
$annotationDriver = new AnnotationDriver($cachedAnnotationReader, $this->paths);
$driverChain->addDriver($annotationDriver, $this->namespace);
// general ORM configuration
$isDevMode = $this->env != "production";
$config = DoctrineSetup::createAnnotationMetadataConfiguration($this->paths, $isDevMode);
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setMetadataDriverImpl($driverChain);
$config->setProxyDir($this->proxy_path);
$config->setProxyNamespace($this->namespace . '\\Proxy');
$config->setAutoGenerateProxyClasses($isDevMode);
// Third, create event manager and hook prefered extension listeners
$evm = new EventManager();
// gedmo extension listeners
// sluggable
$sluggableListener = new Gedmo\Sluggable\SluggableListener();
// you should set the used annotation reader to listener, to avoid creating new one for mapping drivers
$sluggableListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($sluggableListener);
// tree
$treeListener = new Gedmo\Tree\TreeListener();
$treeListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($treeListener);
// loggable, not used in example
$loggableListener = new Gedmo\Loggable\LoggableListener();
$loggableListener->setAnnotationReader($cachedAnnotationReader);
$loggableListener->setUsername('unknown');
$evm->addEventSubscriber($loggableListener);
// timestampable
$timestampableListener = new Gedmo\Timestampable\TimestampableListener();
$timestampableListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($timestampableListener);
// blameable
$blameableListener = new Gedmo\Blameable\BlameableListener();
$blameableListener->setAnnotationReader($cachedAnnotationReader);
$blameableListener->setUserValue('unknown');
// determine from your environment
$evm->addEventSubscriber($blameableListener);
// translatable - buggy !!!
/*
$translatableListener = new Gedmo\Translatable\TranslatableListener();
// current translation locale should be set from session or hook later into the listener
// most important, before entity manager is flushed
$translatableListener->setTranslatableLocale('en');
$translatableListener->setDefaultLocale('en');
$translatableListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($translatableListener);
*/
// sortable, not used in example
$sortableListener = new Gedmo\Sortable\SortableListener();
$sortableListener->setAnnotationReader($cachedAnnotationReader);
$evm->addEventSubscriber($sortableListener);
// mysql set names UTF-8 if required
$evm->addEventSubscriber(new \Doctrine\DBAL\Event\Listeners\MysqlSessionInit());
// Finally, create entity manager
return EntityManager::create($this->dbParams, $config, $evm);
}
