[sluggable] adjusted tests, annotation and yml drivers to different slug mapping, fixed slug handlers

lib/Gedmo/Sluggable/Handler/InversedRelativeSlugHandler.php

@@ -32,14 +32,6 @@ class InversedRelativeSlugHandler implements SlugHandlerInterface
      */
     protected $sluggable;
 
-    /**
-     * Options for relative slug handler object
-     * classes
-     *
-     * @var array
-     */
-    private $options;
-
     /**
      * $options = array(
      *     'relationClass' => 'objectclass',
@@ -53,19 +45,6 @@ class InversedRelativeSlugHandler implements SlugHandlerInterface
         $this->sluggable = $sluggable;
     }
 
-    /**
-    * {@inheritDoc}
-    */
-    public function getOptions($object)
-    {
-        $meta = $this->om->getClassMetadata(get_class($object));
-        if (!isset($this->options[$meta->name])) {
-            $config = $this->sluggable->getConfiguration($this->om, $meta->name);
-            $this->options[$meta->name] = $config['handlers'][get_called_class()];
-        }
-        return $this->options[$meta->name];
-    }
-
     /**
      * {@inheritDoc}
      */
@@ -82,7 +61,17 @@ class InversedRelativeSlugHandler implements SlugHandlerInterface
      * {@inheritDoc}
      */
     public static function validate(array $options, ClassMetadata $meta)
-    {}
+    {
+        if (!isset($options['relationClass']) || !strlen($options['relationClass'])) {
+            throw new InvalidMappingException("'relationClass' option must be specified for object slug mapping - {$meta->name}");
+        }
+        if (!isset($options['mappedBy']) || !strlen($options['mappedBy'])) {
+            throw new InvalidMappingException("'mappedBy' option must be specified for object slug mapping - {$meta->name}");
+        }
+        if (!isset($options['inverseSlugField']) || !strlen($options['inverseSlugField'])) {
+            throw new InvalidMappingException("'inverseSlugField' option must be specified for object slug mapping - {$meta->name}");
+        }
+    }
 
     /**
      * {@inheritDoc}
@@ -92,7 +81,7 @@ class InversedRelativeSlugHandler implements SlugHandlerInterface
         $this->om = $ea->getObjectManager();
         $isInsert = $this->om->getUnitOfWork()->isScheduledForInsert($object);
         if (!$isInsert) {
-            $options = $this->getOptions($object);
+            $options = $config['handlers'][get_called_class()];
             $wrapped = AbstractWrapper::wrapp($object, $this->om);
             $oldSlug = $wrapped->getPropertyValue($config['slug']);
             $mappedByConfig = $this->sluggable->getConfiguration(
@@ -104,10 +93,10 @@ class InversedRelativeSlugHandler implements SlugHandlerInterface
                 if (!$meta->isSingleValuedAssociation($options['mappedBy'])) {
                     throw new InvalidMappingException("Unable to find ".$wrapped->getMetadata()->name." relation - [{$options['mappedBy']}] in class - {$meta->name}");
                 }
-                if (!isset($mappedByConfig['slugFields'][$options['inverseSlugField']])) {
+                if (!isset($mappedByConfig['slugs'][$options['inverseSlugField']])) {
                     throw new InvalidMappingException("Unable to find slug field - [{$options['inverseSlugField']}] in class - {$meta->name}");
                 }
-                $mappedByConfig['slug'] = $mappedByConfig['slugFields'][$options['inverseSlugField']]['slug'];
+                $mappedByConfig['slug'] = $mappedByConfig['slugs'][$options['inverseSlugField']]['slug'];
                 $mappedByConfig['mappedBy'] = $options['mappedBy'];
                 $ea->replaceInverseRelative($object, $mappedByConfig, $slug, $oldSlug);
                 $uow = $this->om->getUnitOfWork();

lib/Gedmo/Sluggable/Handler/RelativeSlugHandler.php

@@ -23,6 +23,8 @@ use Gedmo\Exception\InvalidMappingException;
 */
 class RelativeSlugHandler implements SlugHandlerInterface
 {
+    const SEPARATOR = '/';
+
     /**
      * @var Doctrine\Common\Persistence\ObjectManager
      */
@@ -34,12 +36,11 @@ class RelativeSlugHandler implements SlugHandlerInterface
     protected $sluggable;
 
     /**
-     * Options for relative slug handler object
-     * classes
+     * Used options
      *
      * @var array
      */
-    private $options;
+    private $usedOptions;
 
     /**
      * Callable of original transliterator
@@ -82,14 +83,17 @@ class RelativeSlugHandler implements SlugHandlerInterface
     /**
      * {@inheritDoc}
      */
-    public function onChangeDecision(SluggableAdapter $ea, $slugFieldConfig, $object, &$slug, &$needToChangeSlug)
+    public function onChangeDecision(SluggableAdapter $ea, $config, $object, &$slug, &$needToChangeSlug)
     {
         $this->om = $ea->getObjectManager();
         $isInsert = $this->om->getUnitOfWork()->isScheduledForInsert($object);
+        $this->usedOptions = $config['handlers'][get_called_class()];
+        if (!isset($this->usedOptions['separator'])) {
+            $this->usedOptions['separator'] = self::SEPARATOR;
+        }
         if (!$isInsert && !$needToChangeSlug) {
             $changeSet = $ea->getObjectChangeSet($this->om->getUnitOfWork(), $object);
-            $options = $this->getOptions($object);
-            if (isset($changeSet[$options['relationField']])) {
+            if (isset($changeSet[$this->usedOptions['relationField']])) {
                 $needToChangeSlug = true;
             }
         }
@@ -112,9 +116,6 @@ class RelativeSlugHandler implements SlugHandlerInterface
         if (!$meta->isSingleValuedAssociation($options['relationField'])) {
             throw new InvalidMappingException("Unable to find slug relation through field - [{$options['relationField']}] in class - {$meta->name}");
         }
-        /*if (!$meta->isSingleValuedAssociation($options['relation'])) {
-            throw new InvalidMappingException("Unable to find slug relation through field - [{$options['relation']}] in class - {$meta->name}");
-        }*/
     }
 
     /**
@@ -134,17 +135,16 @@ class RelativeSlugHandler implements SlugHandlerInterface
      */
     public function transliterate($text, $separator, $object)
     {
-        $options = $this->getOptions($object);
         $result = call_user_func_array(
             $this->originalTransliterator,
             array($text, $separator, $object)
         );
         $wrapped = AbstractWrapper::wrapp($object, $this->om);
-        $relation = $wrapped->getPropertyValue($options['relationField']);
+        $relation = $wrapped->getPropertyValue($this->usedOptions['relationField']);
         if ($relation) {
             $wrappedRelation = AbstractWrapper::wrapp($relation, $this->om);
-            $slug = $wrappedRelation->getPropertyValue($options['relationSlugField']);
-            $result = $slug . $options['separator'] . $result;
+            $slug = $wrappedRelation->getPropertyValue($this->usedOptions['relationSlugField']);
+            $result = $slug . $this->usedOptions['separator'] . $result;
         }
         $this->sluggable->setTransliterator($this->originalTransliterator);
         return $result;

lib/Gedmo/Sluggable/Handler/SlugHandlerInterface.php

@@ -28,14 +28,6 @@ interface SlugHandlerInterface
      */
     function __construct(SluggableListener $sluggable);
 
-    /**
-     * Get the options for specific object
-     *
-     * @param object $object
-     * @return array
-     */
-    function getOptions($object);
-
     /**
      * Callback on slug handlers before the decision
      * is made whether or not the slug needs to be

lib/Gedmo/Sluggable/Handler/TreeSlugHandler.php

@@ -22,6 +22,8 @@ use Gedmo\Exception\InvalidMappingException;
 */
 class TreeSlugHandler implements SlugHandlerInterface
 {
+    const SEPARATOR = '/';
+
     /**
      * @var Doctrine\Common\Persistence\ObjectManager
      */
@@ -32,14 +34,6 @@ class TreeSlugHandler implements SlugHandlerInterface
      */
     protected $sluggable;
 
-    /**
-     * Options for relative slug handler object
-     * classes
-     *
-     * @var array
-     */
-    private $options;
-
     /**
      * Callable of original transliterator
      * which is used by sluggable
@@ -63,44 +57,31 @@ class TreeSlugHandler implements SlugHandlerInterface
     private $parentSlug;
 
     /**
-     * {@inheritDoc}
+     * Used path separator
+     *
+     * @var string
      */
-    public function __construct(SluggableListener $sluggable)
-    {
-        $this->sluggable = $sluggable;
-    }
+    private $usedPathSeparator;
 
     /**
-     * $options = array(
-     *     'separator' => '/',
-     *     'parentRelationField' => 'parent'
-     * )
      * {@inheritDoc}
      */
-    public function getOptions($object)
+    public function __construct(SluggableListener $sluggable)
     {
-        $meta = $this->om->getClassMetadata(get_class($object));
-        if (!isset($this->options[$meta->name])) {
-            $config = $this->sluggable->getConfiguration($this->om, $meta->name);
-            $options = $config['handlers'][get_called_class()];
-            $default = array(
-                'separator' => '/'
-            );
-            $this->options[$meta->name] = array_merge($default, $options);
-        }
-        return $this->options[$meta->name];
+        $this->sluggable = $sluggable;
     }
 
     /**
      * {@inheritDoc}
      */
-    public function onChangeDecision(SluggableAdapter $ea, $slugFieldConfig, $object, &$slug, &$needToChangeSlug)
+    public function onChangeDecision(SluggableAdapter $ea, $config, $object, &$slug, &$needToChangeSlug)
     {
         $this->om = $ea->getObjectManager();
         $this->isInsert = $this->om->getUnitOfWork()->isScheduledForInsert($object);
+        $options = $config['handlers'][get_called_class()];
+        $this->usedPathSeparator = isset($options['separator']) ? $options['separator'] : self::SEPARATOR;
         if (!$this->isInsert && !$needToChangeSlug) {
             $changeSet = $ea->getObjectChangeSet($this->om->getUnitOfWork(), $object);
-            $options = $this->getOptions($object);
             if (isset($changeSet[$options['parentRelationField']])) {
                 $needToChangeSlug = true;
             }
@@ -112,7 +93,7 @@ class TreeSlugHandler implements SlugHandlerInterface
      */
     public function postSlugBuild(SluggableAdapter $ea, array &$config, $object, &$slug)
     {
-        $options = $this->getOptions($object);
+        $options = $config['handlers'][get_called_class()];
         $this->originalTransliterator = $this->sluggable->getTransliterator();
         $this->sluggable->setTransliterator(array($this, 'transliterate'));
         $this->parentSlug = '';
@@ -140,14 +121,12 @@ class TreeSlugHandler implements SlugHandlerInterface
     public function onSlugCompletion(SluggableAdapter $ea, array &$config, $object, &$slug)
     {
         if (!$this->isInsert) {
-            $options = $this->getOptions($object);
+            $options = $config['handlers'][get_called_class()];
             $wrapped = AbstractWrapper::wrapp($object, $this->om);
             $meta = $wrapped->getMetadata();
-            $extConfig = $this->sluggable->getConfiguration($this->om, $meta->name);
-            $config['useObjectClass'] = $extConfig['useObjectClass'];
             $target = $wrapped->getPropertyValue($config['slug']);
-            $config['pathSeparator'] = $options['separator'];
-            $ea->replaceRelative($object, $config, $target.$options['separator'], $slug);
+            $config['pathSeparator'] = $this->usedPathSeparator;
+            $ea->replaceRelative($object, $config, $target.$config['pathSeparator'], $slug);
             $uow = $this->om->getUnitOfWork();
             // update in memory objects
             foreach ($uow->getIdentityMap() as $className => $objects) {
@@ -161,7 +140,7 @@ class TreeSlugHandler implements SlugHandlerInterface
                     }
                     $oid = spl_object_hash($object);
                     $objectSlug = $meta->getReflectionProperty($config['slug'])->getValue($object);
-                    if (preg_match("@^{$target}{$options['separator']}@smi", $objectSlug)) {
+                    if (preg_match("@^{$target}{$config['pathSeparator']}@smi", $objectSlug)) {
                         $objectSlug = str_replace($target, $slug, $objectSlug);
                         $meta->getReflectionProperty($config['slug'])->setValue($object, $objectSlug);
                         $ea->setOriginalObjectProperty($uow, $oid, $config['slug'], $objectSlug);
@@ -187,8 +166,7 @@ class TreeSlugHandler implements SlugHandlerInterface
             array($text, $separator, $object)
         );
         if (strlen($this->parentSlug)) {
-            $options = $this->getOptions($object);
-            $slug = $this->parentSlug . $options['separator'] . $slug;
+            $slug = $this->parentSlug . $this->usedPathSeparator . $slug;
         }
         $this->sluggable->setTransliterator($this->originalTransliterator);
         return $slug;

lib/Gedmo/Sluggable/Mapping/Driver/Annotation.php

@@ -126,7 +126,7 @@ class Annotation implements AnnotationDriverInterface
                     throw new InvalidMappingException("Slug must contain at least one field for slug generation in class - {$meta->name}");
                 }
                 foreach ($slug->fields as $slugField) {
-                    if (!$meta->hasField($slugField)) {
+                    if (!$meta->hasField($slugField) || $meta->isInheritedField($slugField)) {
                         throw new InvalidMappingException("Unable to find slug [{$slugField}] as mapped property in entity - {$meta->name}");
                     }
                     if (!$this->isValidField($meta, $slugField)) {

lib/Gedmo/Sluggable/Mapping/Driver/Yaml.php

@@ -41,18 +41,7 @@ class Yaml extends File implements Driver
      * {@inheritDoc}
      */
     public function validateFullMetadata(ClassMetadata $meta, array $config)
-    {
-        if ($config) {
-            if (!isset($config['fields'])) {
-                throw new InvalidMappingException("Unable to find any sluggable fields specified for Sluggable entity - {$meta->name}");
-            }
-            foreach ($config['fields'] as $slugField => $fields) {
-                if (!isset($config['slugFields'][$slugField])) {
-                    throw new InvalidMappingException("Unable to find {$slugField} slugField specified for Sluggable entity - {$meta->name}, you should specify slugField annotation property");
-                }
-            }
-        }
-    }
+    {}
 
     /**
      * {@inheritDoc}
@@ -64,31 +53,47 @@ class Yaml extends File implements Driver
         if (isset($mapping['fields'])) {
             foreach ($mapping['fields'] as $field => $fieldMapping) {
                 if (isset($fieldMapping['gedmo'])) {
-
-                    if (isset($fieldMapping['gedmo']['sluggable']) || in_array('sluggable', $fieldMapping['gedmo'])) {
+                    if (isset($fieldMapping['gedmo']['slug'])) {
+                        $slug = $fieldMapping['gedmo']['slug'];
                         if (!$this->isValidField($meta, $field)) {
-                            throw new InvalidMappingException("Cannot slug field - [{$field}] type is not valid and must be 'string' in class - {$meta->name}");
+                            throw new InvalidMappingException("Cannot use field - [{$field}] for slug storage, type is not valid and must be 'string' or 'text' in class - {$meta->name}");
                         }
-                        $sluggable = (isset($fieldMapping['gedmo']['sluggable'])? $fieldMapping['gedmo']['sluggable']:array());
-                        $slugField = (isset($sluggable['slugField'])? $sluggable['slugField']:'slug');
-                        $position = (isset($sluggable['position'])? $sluggable['position']:0);
-                        $config['fields'][$slugField][] = array('field' => $field, 'position' => $position, 'slugField' => $slugField);
-                    } elseif (isset($fieldMapping['gedmo']['slug']) || in_array('slug', $fieldMapping['gedmo'])) {
-                        $slug = isset($fieldMapping['gedmo']['slug']) ? $fieldMapping['gedmo']['slug'] : array();
-                        if (!$this->isValidField($meta, $field)) {
-                            throw new InvalidMappingException("Cannot use field - [{$field}] for slug storage, type is not valid and must be 'string' in class - {$meta->name}");
+                        // process slug handlers
+                        $handlers = array();
+                        if (isset($slug['handlers'])) {
+                            foreach ($slug['handlers'] as $handlerClass => $options) {
+                                if (!strlen($handlerClass)) {
+                                    throw new InvalidMappingException("SlugHandler class: {$handlerClass} should be a valid class name in entity - {$meta->name}");
+                                }
+                                $handlers[$handlerClass] = $options;
+                                $handlerClass::validate($handlers[$handlerClass], $meta);
+                            }
+                        }
+                        // process slug fields
+                        if (empty($slug['fields']) || !is_array($slug['fields'])) {
+                            throw new InvalidMappingException("Slug must contain at least one field for slug generation in class - {$meta->name}");
+                        }
+                        foreach ($slug['fields'] as $slugField) {
+                            if (!$meta->hasField($slugField) || $meta->isInheritedField($slugField)) {
+                                throw new InvalidMappingException("Unable to find slug [{$slugField}] as mapped property in entity - {$meta->name}");
+                            }
+                            if (!$this->isValidField($meta, $slugField)) {
+                                throw new InvalidMappingException("Cannot use field - [{$slugField}] for slug storage, type is not valid and must be 'string' or 'text' in class - {$meta->name}");
+                            }
                         }
-                        $config['slugFields'][$field]['slug'] = $field;
-                        $config['slugFields'][$field]['style'] = isset($slug['style']) ?
+                        $config['slugs'][$field]['fields'] = $slug['fields'];
+                        $config['slugs'][$field]['handlers'] = $handlers;
+                        $config['slugs'][$field]['slug'] = $field;
+                        $config['slugs'][$field]['style'] = isset($slug['style']) ?
                             (string)$slug['style'] : 'default';
 
-                        $config['slugFields'][$field]['updatable'] = isset($slug['updatable']) ?
+                        $config['slugs'][$field]['updatable'] = isset($slug['updatable']) ?
                             (bool)$slug['updatable'] : true;
 
-                        $config['slugFields'][$field]['unique'] = isset($slug['unique']) ?
+                        $config['slugs'][$field]['unique'] = isset($slug['unique']) ?
                             (bool)$slug['unique'] : true;
 
-                        $config['slugFields'][$field]['separator'] = isset($slug['separator']) ?
+                        $config['slugs'][$field]['separator'] = isset($slug['separator']) ?
                             (string)$slug['separator'] : '-';
                     }
                 }

lib/Gedmo/Sluggable/SluggableListener.php

@@ -184,6 +184,7 @@ class SluggableListener extends MappedEventSubscriber
         $config = $this->getConfiguration($om, $meta->name);
         foreach ($config['slugs'] as $slugField => $options) {
             $hasHandlers = count($options['handlers']);
+            $options['useObjectClass'] = $config['useObjectClass'];
             $fields = $options['fields'];
             //$slugFieldConfig = $config['slugFields'][$slugField];
             // collect the slug from fields
@@ -252,9 +253,7 @@ class SluggableListener extends MappedEventSubscriber
                 // make unique slug if requested
                 if ($options['unique'] && !is_null($slug)) {
                     $this->exponent = 0;
-                    $arrayConfig = $options;
-                    $arrayConfig['useObjectClass'] = $config['useObjectClass'];
-                    $slug = $this->makeUniqueSlug($ea, $object, $slug, false, $arrayConfig);
+                    $slug = $this->makeUniqueSlug($ea, $object, $slug, false, $options);
                 }
                 // notify slug handlers --> onSlugCompletion
                 if ($hasHandlers) {

tests/Gedmo/Mapping/Driver/Yaml/Mapping.Fixture.Yaml.Category.dcm.yml

@@ -21,17 +21,16 @@ Mapping\Fixture\Yaml\Category:
       length: 64
       gedmo:
         - translatable
-        sluggable:
-          position: 1
-          slugField: 'slug'
     slug:
       type: string
       length: 64
       gedmo:
         - translatable
         slug:
-          separator: _
+          separator: "_"
           style: camel
+          fields:
+            - title
     changed:
       type: date
       gedmo:

tests/Gedmo/Mapping/Fixture/Sluggable.php

@@ -18,13 +18,11 @@ class Sluggable
     private $id;
 
     /**
-     * @Gedmo\Sluggable
      * @ORM\Column(name="title", type="string", length=64)
      */
     private $title;
 
     /**
-     * @Gedmo\Sluggable
      * @ORM\Column(name="code", type="string", length=16)
      */
     private $code;
@@ -40,7 +38,7 @@ class Sluggable
      *          @Gedmo\SlugHandlerOption(name="relationSlugField", value="slug"),
      *          @Gedmo\SlugHandlerOption(name="separator", value="/")
      *      })
-     * }, separator="-", updatable=false)
+     * }, separator="-", updatable=false, fields={"title", "code"})
      * @ORM\Column(name="slug", type="string", length=64, unique=true)
      */
     private $slug;

tests/Gedmo/Mapping/SluggableMappingTest.php

@@ -63,21 +63,21 @@ class SluggableMappingTest extends \PHPUnit_Framework_TestCase
             'Gedmo\Sluggable'
         );
         $config = $this->em->getMetadataFactory()->getCacheDriver()->fetch($cacheId);
-        $this->assertArrayHasKey('slugFields', $config);
-        $this->assertEquals('slug', $config['slugFields']['slug']['slug']);
-        $this->assertArrayHasKey('fields', $config);
-        $this->assertEquals(1, count($config['fields']['slug']));
-        $this->assertEquals('title', $config['fields']['slug'][0]['field']);
-        $this->assertEquals('slug', $config['fields']['slug'][0]['slugField']);
-        $this->assertEquals(1, $config['fields']['slug'][0]['position']);
-        $this->assertArrayHasKey('style', $config['slugFields']['slug']);
-        $this->assertEquals('camel', $config['slugFields']['slug']['style']);
-        $this->assertArrayHasKey('separator', $config['slugFields']['slug']);
-        $this->assertEquals('_', $config['slugFields']['slug']['separator']);
-        $this->assertArrayHasKey('unique', $config['slugFields']['slug']);
-        $this->assertTrue($config['slugFields']['slug']['unique']);
-        $this->assertArrayHasKey('updatable', $config['slugFields']['slug']);
-        $this->assertTrue($config['slugFields']['slug']['updatable']);
+        $this->assertArrayHasKey('slugs', $config);
+        $this->assertArrayHasKey('slug', $config['slugs']);
+        $this->assertEquals('slug', $config['slugs']['slug']['slug']);
+        $this->assertArrayHasKey('fields', $config['slugs']['slug']);
+        $this->assertEquals(1, count($config['slugs']['slug']['fields']));
+        $this->assertEquals('title', $config['slugs']['slug']['fields'][0]);
+
+        $this->assertArrayHasKey('style', $config['slugs']['slug']);
+        $this->assertEquals('camel', $config['slugs']['slug']['style']);
+        $this->assertArrayHasKey('separator', $config['slugs']['slug']);
+        $this->assertEquals('_', $config['slugs']['slug']['separator']);
+        $this->assertArrayHasKey('unique', $config['slugs']['slug']);
+        $this->assertTrue($config['slugs']['slug']['unique']);
+        $this->assertArrayHasKey('updatable', $config['slugs']['slug']);
+        $this->assertTrue($config['slugs']['slug']['updatable']);
     }
 
     public function testSlugHandlerMapping()
@@ -89,8 +89,8 @@ class SluggableMappingTest extends \PHPUnit_Framework_TestCase
         );
         $config = $this->em->getMetadataFactory()->getCacheDriver()->fetch($cacheId);
 
-        $this->assertArrayHasKey('handlers', $config);
-        $handlers = $config['handlers'];
+        $this->assertArrayHasKey('handlers', $config['slugs']['slug']);
+        $handlers = $config['slugs']['slug']['handlers'];
         $this->assertEquals(2, count($handlers));
         $this->assertArrayHasKey('Gedmo\Sluggable\Handler\TreeSlugHandler', $handlers);
         $this->assertArrayHasKey('Gedmo\Sluggable\Handler\RelativeSlugHandler', $handlers);

tests/Gedmo/Sluggable/Fixture/Issue116/Mapping/Sluggable.Fixture.Issue116.Country.dcm.yml

@@ -14,7 +14,10 @@ Sluggable\Fixture\Issue116\Country:
       fixed: false
       nullable: false
       gedmo:
-        - slug
+        slug:
+          separator: "-"
+          fields:
+            - originalName
     languageCode:
       type: string(10)
       fixed: false
@@ -25,7 +28,4 @@ Sluggable\Fixture\Issue116\Country:
       fixed: false
       nullable: false
       column: original_name
-      gedmo:
-        sluggable:
-          slugField: 'alias'
   lifecycleCallbacks: {  }

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

@@ -14,21 +14,19 @@ class Article
     private $id;
 
     /**
-     * @Gedmo\Sluggable
      * @Gedmo\Translatable
      * @MongoODM\String
      */
     private $title;
 
     /**
-     * @Gedmo\Sluggable
      * @Gedmo\Translatable
      * @MongoODM\String
      */
     private $code;
 
     /**
-     * @Gedmo\Slug
+     * @Gedmo\Slug(fields={"title", "code"})
      * @Gedmo\Translatable
      * @MongoODM\String
      */

tests/Gedmo/Tree/Fixture/BehavioralCategory.php

@@ -20,7 +20,6 @@ class BehavioralCategory
 
     /**
      * @Gedmo\Translatable
-     * @Gedmo\Sluggable
      * @ORM\Column(name="title", type="string", length=64)
      */
     private $title;
@@ -53,7 +52,7 @@ class BehavioralCategory
 
     /**
      * @Gedmo\Translatable
-     * @Gedmo\Slug
+     * @Gedmo\Slug(fields={"title"})
      * @ORM\Column(name="slug", type="string", length=128, unique=true)
      */
     private $slug;

tests/Gedmo/Tree/Fixture/Node.php

@@ -12,14 +12,13 @@ class Node extends BaseNode
 {
     /**
      * @Gedmo\Translatable
-     * @Gedmo\Sluggable
      * @ORM\Column(name="title", type="string", length=64)
      */
     private $title;
 
     /**
      * @Gedmo\Translatable
-     * @Gedmo\Slug
+     * @Gedmo\Slug(fields={"title"})
      * @ORM\Column(name="slug", type="string", length=128)
      */
     private $slug;