[sluggable] updated tree handlers to manage in memory objects and started odm implementation

lib/Gedmo/Sluggable/Handler/InversedRelativeSlugHandler.php

@@ -108,7 +108,7 @@ class InversedRelativeSlugHandler implements SlugHandlerInterface
                 // update in memory objects
                 foreach ($uow->getIdentityMap() as $className => $objects) {
                     // for inheritance mapped classes, only root is always in the identity map
-                    if ($className !== $meta->rootEntityName) {
+                    if ($className !== $mappedByConfig['useObjectClass']) {
                         continue;
                     }
                     foreach ($objects as $object) {

lib/Gedmo/Sluggable/Handler/TreeSlugHandler.php

@@ -156,7 +156,7 @@ class TreeSlugHandler implements SlugHandlerInterface
             // update in memory objects
             foreach ($uow->getIdentityMap() as $className => $objects) {
                 // for inheritance mapped classes, only root is always in the identity map
-                if ($className !== $meta->rootEntityName) {
+                if ($className !== $wrapped->getRootObjectName()) {
                     continue;
                 }
                 foreach ($objects as $object) {

lib/Gedmo/Sluggable/Mapping/Event/Adapter/ODM.php

@@ -6,6 +6,7 @@ use Gedmo\Mapping\Event\Adapter\ODM as BaseAdapterODM;
 use Doctrine\Common\Persistence\Mapping\ClassMetadata;
 use Doctrine\ODM\MongoDB\Cursor;
 use Gedmo\Sluggable\Mapping\Event\SluggableAdapter;
+use Gedmo\Tool\Wrapper\AbstractWrapper;
 
 /**
  * Doctrine event adapter for ODM adapted
@@ -42,4 +43,20 @@ final class ODM extends BaseAdapterODM implements SluggableAdapter
         }
         return $result;
     }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function replaceRelative($object, array $config, $target, $replacement)
+    {
+        throw new \Exception('not implemented yet');
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function replaceInverseRelative($object, array $config, $target, $replacement)
+    {
+        throw new \Exception('not implemented yet');
+    }
 }

lib/Gedmo/Tool/Wrapper/EntityWrapper.php

@@ -71,6 +71,14 @@ class EntityWrapper extends AbstractWrapper
         return (bool)$this->getIdentifier();
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public function getRootObjectName()
+    {
+        return $this->meta->rootEntityName;
+    }
+
     /**
      * {@inheritDoc}
      */

lib/Gedmo/Tool/Wrapper/MongoDocumentWrapper.php

@@ -53,6 +53,14 @@ class MongoDocumentWrapper extends AbstractWrapper
         return $this->meta->getReflectionProperty($property)->getValue($this->object);
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    public function getRootObjectName()
+    {
+        return $this->meta->rootDocumentName;
+    }
+
     /**
      * {@inheritDoc}
      */

lib/Gedmo/Tool/WrapperInterface.php

@@ -67,4 +67,11 @@ interface WrapperInterface
      * @return array|mixed
      */
     function getIdentifier($single = true);
+
+    /**
+     * Get root object class name
+     *
+     * @return string
+     */
+    function getRootObjectName();
 }

tests/Gedmo/Mapping/Fixture/Sluggable.php

@@ -31,19 +31,31 @@ class Sluggable
 
     /**
      * @Gedmo\Slug(handlers={
-     *      @Gedmo\SlugHandler(class="Some\Class", options={
-     *          @Gedmo\SlugHandlerOption(name="relation", value="parent"),
+     *      @Gedmo\SlugHandler(class="Gedmo\Sluggable\Handler\TreeSlugHandler", options={
+     *          @Gedmo\SlugHandlerOption(name="parentRelation", value="parent"),
+     *          @Gedmo\SlugHandlerOption(name="targetField", value="title"),
      *          @Gedmo\SlugHandlerOption(name="separator", value="/")
      *      }),
-     *      @Gedmo\SlugHandler(class="Some\Class2", options={
-     *          @Gedmo\SlugHandlerOption(name="option", value="val"),
-     *          @Gedmo\SlugHandlerOption(name="option2", value="val2")
+     *      @Gedmo\SlugHandler(class="Gedmo\Sluggable\Handler\RelativeSlugHandler", options={
+     *          @Gedmo\SlugHandlerOption(name="relationField", value="user"),
+     *          @Gedmo\SlugHandlerOption(name="relativeSlugField", value="slug"),
+     *          @Gedmo\SlugHandlerOption(name="separator", value="/")
      *      })
      * }, separator="-", updatable=false)
      * @ORM\Column(name="slug", type="string", length=64, unique=true)
      */
     private $slug;
 
+    /**
+     * @ORM\ManyToOne(targetEntity="Sluggable")
+     */
+    private $parent;
+
+    /**
+    * @ORM\ManyToOne(targetEntity="User")
+    */
+    private $user;
+
     public function getId()
     {
         return $this->id;

tests/Gedmo/Mapping/SluggableMappingTest.php

@@ -92,21 +92,25 @@ class SluggableMappingTest extends \PHPUnit_Framework_TestCase
         $this->assertArrayHasKey('handlers', $config);
         $handlers = $config['handlers'];
         $this->assertEquals(2, count($handlers));
-        $this->assertArrayHasKey('Some\\Class', $handlers);
-        $this->assertArrayHasKey('Some\\Class2', $handlers);
+        $this->assertArrayHasKey('Gedmo\Sluggable\Handler\TreeSlugHandler', $handlers);
+        $this->assertArrayHasKey('Gedmo\Sluggable\Handler\RelativeSlugHandler', $handlers);
 
-        $first = $handlers['Some\\Class'];
-        $this->assertEquals(2, count($first));
-        $this->assertArrayHasKey('relation', $first);
+        $first = $handlers['Gedmo\Sluggable\Handler\TreeSlugHandler'];
+        $this->assertEquals(3, count($first));
+        $this->assertArrayHasKey('parentRelation', $first);
+        $this->assertArrayHasKey('targetField', $first);
         $this->assertArrayHasKey('separator', $first);
-        $this->assertEquals('parent', $first['relation']);
+        $this->assertEquals('parent', $first['parentRelation']);
+        $this->assertEquals('title', $first['targetField']);
         $this->assertEquals('/', $first['separator']);
 
-        $second = $handlers['Some\\Class2'];
-        $this->assertEquals(2, count($second));
-        $this->assertArrayHasKey('option', $second);
-        $this->assertArrayHasKey('option2', $second);
-        $this->assertEquals('val', $second['option']);
-        $this->assertEquals('val2', $second['option2']);
+        $second = $handlers['Gedmo\Sluggable\Handler\RelativeSlugHandler'];
+        $this->assertEquals(3, count($second));
+        $this->assertArrayHasKey('relationField', $second);
+        $this->assertArrayHasKey('relativeSlugField', $second);
+        $this->assertArrayHasKey('separator', $second);
+        $this->assertEquals('user', $second['relationField']);
+        $this->assertEquals('slug', $second['relativeSlugField']);
+        $this->assertEquals('/', $second['separator']);
     }
 }

tests/Gedmo/Sluggable/Fixture/Document/Article.php

@@ -26,7 +26,13 @@ class Article
     private $code;
 
     /**
-     * @Gedmo\Slug
+     * @Gedmo\Slug(handlers={
+     *      @Gedmo\SlugHandler(class="Gedmo\Sluggable\Handler\InversedRelativeSlugHandler", options={
+     *          @Gedmo\SlugHandlerOption(name="relationClass", value="Sluggable\Fixture\Document\RelativeSlug"),
+     *          @Gedmo\SlugHandlerOption(name="mappedBy", value="article"),
+     *          @Gedmo\SlugHandlerOption(name="inverseSlugField", value="alias")
+     *      })
+     * }, separator="-", updatable=true)
      * @ODM\String
      */
     private $slug;

tests/Gedmo/Sluggable/Fixture/Document/RelativeSlug.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Sluggable\Fixture\Document;
+
+use Doctrine\ODM\MongoDB\Mapping\Annotations as ODM;
+use Gedmo\Mapping\Annotation as Gedmo;
+
+/**
+ * @ODM\Document
+ */
+class RelativeSlug
+{
+    /**
+     * @ODM\Id
+     */
+    private $id;
+
+    /**
+     * @Gedmo\Sluggable(slugField="alias")
+     * @ODM\String
+     */
+    private $title;
+
+    /**
+     * @Gedmo\Slug(handlers={
+     *      @Gedmo\SlugHandler(class="Gedmo\Sluggable\Handler\RelativeSlugHandler", options={
+     *          @Gedmo\SlugHandlerOption(name="relationField", value="article"),
+     *          @Gedmo\SlugHandlerOption(name="relativeSlugField", value="slug"),
+     *          @Gedmo\SlugHandlerOption(name="separator", value="/")
+     *      })
+     * }, separator="-", updatable=true)
+     * @ODM\String
+     */
+    private $alias;
+
+    /**
+     * @ODM\ReferenceOne(targetDocument="Article")
+     */
+    private $article;
+
+    public function setArticle(Article $article = null)
+    {
+        $this->article = $article;
+    }
+
+    public function getArticle()
+    {
+        return $this->article;
+    }
+
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    public function setTitle($title)
+    {
+        $this->title = $title;
+    }
+
+    public function getTitle()
+    {
+        return $this->title;
+    }
+
+    public function getSlug()
+    {
+        return $this->alias;
+    }
+}

tests/Gedmo/Sluggable/RelativeSlugHandlerDocumentTest.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace Gedmo\Sluggable;
+
+use Tool\BaseTestCaseMongoODM;
+use Doctrine\Common\EventManager;
+use Sluggable\Fixture\Document\Article;
+use Sluggable\Fixture\Document\RelativeSlug;
+
+/**
+ * These are tests for sluggable behavior
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @package Gedmo.Sluggable
+ * @link http://www.gediminasm.org
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class RelativeSlugHandlerDocumentTest extends BaseTestCaseMongoODM
+{
+    const ARTICLE = 'Sluggable\\Fixture\\Document\\Article';
+    const SLUG = 'Sluggable\\Fixture\\Document\\RelativeSlug';
+
+    protected function setUp()
+    {
+        parent::setUp();
+        $evm = new EventManager();
+        $evm->addEventSubscriber(new SluggableListener);
+
+        $this->getMockDocumentManager($evm);
+    }
+
+    public function testSlugGeneration()
+    {
+        $this->populate();
+        $repo = $this->dm->getRepository(self::SLUG);
+
+        $thomas = $repo->findOneByTitle('Thomas');
+        $this->assertEquals('sport-test/thomas', $thomas->getSlug());
+
+        $jen = $repo->findOneByTitle('Jen');
+        $this->assertEquals('sport-test/jen', $jen->getSlug());
+
+        $john = $repo->findOneByTitle('John');
+        $this->assertEquals('cars-code/john', $john->getSlug());
+
+        $single = $repo->findOneByTitle('Single');
+        $this->assertEquals('single', $single->getSlug());
+    }
+
+    public function testUpdateOperations()
+    {
+        $this->populate();
+        $repo = $this->dm->getRepository(self::SLUG);
+
+        /*$thomas = $repo->findOneByTitle('Thomas');
+        $thomas->setTitle('Ninja');
+        $this->dm->persist($thomas);
+        $this->dm->flush();
+
+        $this->assertEquals('sport-test/ninja', $thomas->getSlug());
+
+        $sport = $this->dm->getRepository(self::ARTICLE)->findOneByTitle('Sport');
+        $sport->setTitle('Martial Arts');
+
+        $this->dm->persist($sport);
+        $this->dm->flush();
+
+        $this->assertEquals('martial-arts-test/ninja', $thomas->getSlug());
+
+        $jen = $repo->findOneByTitle('Jen');
+        $this->assertEquals('martial-arts-test/jen', $jen->getSlug());*/
+    }
+
+    private function populate()
+    {
+        $sport = new Article;
+        $sport->setTitle('Sport');
+        $sport->setCode('test');
+        $this->dm->persist($sport);
+
+        $cars = new Article;
+        $cars->setTitle('Cars');
+        $cars->setCode('code');
+        $this->dm->persist($cars);
+
+        $thomas = new RelativeSlug;
+        $thomas->setTitle('Thomas');
+        $thomas->setArticle($sport);
+        $this->dm->persist($thomas);
+
+        $jen = new RelativeSlug;
+        $jen->setTitle('Jen');
+        $jen->setArticle($sport);
+        $this->dm->persist($jen);
+
+        $john = new RelativeSlug;
+        $john->setTitle('John');
+        $john->setArticle($cars);
+        $this->dm->persist($john);
+
+        $single = new RelativeSlug;
+        $single->setTitle('Single');
+        $this->dm->persist($single);
+
+        $this->dm->flush();
+    }
+}