Actualización

vendor/gedmo/doctrine-extensions/lib/Gedmo/Sluggable/Handler/InversedRelativeSlugHandler.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Gedmo\Sluggable\Handler;
+
+use Doctrine\Common\Persistence\ObjectManager;
+use Gedmo\Sluggable\SluggableListener;
+use Gedmo\Sluggable\Mapping\Event\SluggableAdapter;
+use Gedmo\Tool\Wrapper\AbstractWrapper;
+use Gedmo\Exception\InvalidMappingException;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+
+/**
+* Sluggable handler which should be used for inversed relation mapping
+* used together with RelativeSlugHandler. Updates back related slug on
+* relation changes
+*
+* @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+*/
+class InversedRelativeSlugHandler implements SlugHandlerInterface
+{
+    /**
+     * @var ObjectManager
+     */
+    protected $om;
+
+    /**
+     * @var SluggableListener
+     */
+    protected $sluggable;
+
+    /**
+     * $options = array(
+     *     'relationClass' => 'objectclass',
+     *     'inverseSlugField' => 'slug',
+     *     'mappedBy' => 'relationField'
+     * )
+     * {@inheritDoc}
+     */
+    public function __construct(SluggableListener $sluggable)
+    {
+        $this->sluggable = $sluggable;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function onChangeDecision(SluggableAdapter $ea, array &$config, $object, &$slug, &$needToChangeSlug)
+    {
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function postSlugBuild(SluggableAdapter $ea, array &$config, $object, &$slug)
+    {
+    }
+
+    /**
+     * {@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}
+     */
+    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::wrap($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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handlesUrlization()
+    {
+        return false;
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Sluggable/Handler/RelativeSlugHandler.php

@@ -0,0 +1,151 @@
+<?php
+
+namespace Gedmo\Sluggable\Handler;
+
+use Doctrine\Common\Persistence\ObjectManager;
+use Gedmo\Sluggable\SluggableListener;
+use Gedmo\Sluggable\Mapping\Event\SluggableAdapter;
+use Gedmo\Tool\Wrapper\AbstractWrapper;
+use Gedmo\Exception\InvalidMappingException;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+
+/**
+* Sluggable handler which should be used in order to prefix
+* a slug of related object. For instance user may belong to a company
+* in this case user slug could look like 'company-name/user-firstname'
+* where path separator separates the relative slug
+*
+* @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+* @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+*/
+class RelativeSlugHandler implements SlugHandlerInterface
+{
+    const SEPARATOR = '/';
+
+    /**
+     * @var ObjectManager
+     */
+    protected $om;
+
+    /**
+     * @var SluggableListener
+     */
+    protected $sluggable;
+
+    /**
+     * Used options
+     *
+     * @var array
+     */
+    private $usedOptions;
+
+    /**
+     * Callable of original transliterator
+     * which is used by sluggable
+     *
+     * @var callable
+     */
+    private $originalTransliterator;
+
+    /**
+     * $options = array(
+     *     'separator' => '/',
+     *     'relationField' => 'something',
+     *     'relationSlugField' => 'slug'
+     * )
+     * {@inheritDoc}
+     */
+    public function __construct(SluggableListener $sluggable)
+    {
+        $this->sluggable = $sluggable;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function onChangeDecision(SluggableAdapter $ea, array &$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);
+            if (isset($changeSet[$this->usedOptions['relationField']])) {
+                $needToChangeSlug = true;
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function postSlugBuild(SluggableAdapter $ea, array &$config, $object, &$slug)
+    {
+        $this->originalTransliterator = $this->sluggable->getTransliterator();
+        $this->sluggable->setTransliterator(array($this, 'transliterate'));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public static function validate(array $options, ClassMetadata $meta)
+    {
+        if (!$meta->isSingleValuedAssociation($options['relationField'])) {
+            throw new InvalidMappingException("Unable to find slug relation through field - [{$options['relationField']}] in class - {$meta->name}");
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function onSlugCompletion(SluggableAdapter $ea, array &$config, $object, &$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::wrap($object, $this->om);
+        $relation = $wrapped->getPropertyValue($this->usedOptions['relationField']);
+        if ($relation) {
+            $wrappedRelation = AbstractWrapper::wrap($relation, $this->om);
+            $slug = $wrappedRelation->getPropertyValue($this->usedOptions['relationSlugField']);
+
+            if (isset($this->usedOptions['urilize']) && $this->usedOptions['urilize']) {
+                $slug = call_user_func_array(
+                    $this->originalTransliterator,
+                    array($slug, $separator, $object)
+                );
+            }
+
+            $result = $slug.$this->usedOptions['separator'].$result;
+        }
+        $this->sluggable->setTransliterator($this->originalTransliterator);
+
+        return $result;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handlesUrlization()
+    {
+        return true;
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Sluggable/Handler/SlugHandlerInterface.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace Gedmo\Sluggable\Handler;
+
+use Gedmo\Sluggable\SluggableListener;
+use Gedmo\Sluggable\Mapping\Event\SluggableAdapter;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+
+/**
+ * Sluggable handler interface is a common pattern for all
+ * slug handlers which can be attached to the sluggable listener.
+ * Usage is intended only for internal access of sluggable.
+ * Should not be used outside of sluggable extension
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+interface SlugHandlerInterface
+{
+    /**
+     * Construct the slug handler
+     *
+     * @param SluggableListener $sluggable
+     */
+    public function __construct(SluggableListener $sluggable);
+
+    /**
+     * Callback on slug handlers before the decision
+     * is made whether or not the slug needs to be
+     * recalculated
+     *
+     * @param SluggableAdapter $ea
+     * @param array            $config
+     * @param object           $object
+     * @param string           $slug
+     * @param boolean          $needToChangeSlug
+     *
+     * @return void
+     */
+    public function onChangeDecision(SluggableAdapter $ea, array &$config, $object, &$slug, &$needToChangeSlug);
+
+    /**
+     * Callback on slug handlers right after the slug is built
+     *
+     * @param SluggableAdapter $ea
+     * @param array            $config
+     * @param object           $object
+     * @param string           $slug
+     *
+     * @return void
+     */
+    public function postSlugBuild(SluggableAdapter $ea, array &$config, $object, &$slug);
+
+    /**
+     * Callback for slug handlers on slug completion
+     *
+     * @param SluggableAdapter $ea
+     * @param array            $config
+     * @param object           $object
+     * @param string           $slug
+     *
+     * @return void
+     */
+    public function onSlugCompletion(SluggableAdapter $ea, array &$config, $object, &$slug);
+
+    /**
+     * @return boolean whether or not this handler has already urlized the slug
+     */
+    public function handlesUrlization();
+
+    /**
+     * Validate handler options
+     *
+     * @param array         $options
+     * @param ClassMetadata $meta
+     */
+    public static function validate(array $options, ClassMetadata $meta);
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Sluggable/Handler/SlugHandlerWithUniqueCallbackInterface.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Gedmo\Sluggable\Handler;
+
+use Gedmo\Sluggable\Mapping\Event\SluggableAdapter;
+
+/**
+ * This adds the ability to a SlugHandler to change the slug just before its
+ * uniqueness is ensured. It is also called if the unique options is _not_
+ * set.
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+interface SlugHandlerWithUniqueCallbackInterface extends SlugHandlerInterface
+{
+    /**
+     * Callback for slug handlers before it is made unique
+     *
+     * @param SluggableAdapter $ea
+     * @param array            $config
+     * @param object           $object
+     * @param string           $slug
+     *
+     * @return void
+     */
+    public function beforeMakingUnique(SluggableAdapter $ea, array &$config, $object, &$slug);
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/Sluggable/Handler/TreeSlugHandler.php

@@ -0,0 +1,201 @@
+<?php
+
+namespace Gedmo\Sluggable\Handler;
+
+use Doctrine\Common\Persistence\ObjectManager;
+use Doctrine\Common\Persistence\Mapping\ClassMetadata;
+use Gedmo\Sluggable\SluggableListener;
+use Gedmo\Sluggable\Mapping\Event\SluggableAdapter;
+use Gedmo\Tool\Wrapper\AbstractWrapper;
+use Gedmo\Exception\InvalidMappingException;
+
+/**
+ * Sluggable handler which slugs all parent nodes
+ * recursively and synchronizes on updates. For instance
+ * category tree slug could look like "food/fruits/apples"
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class TreeSlugHandler implements SlugHandlerWithUniqueCallbackInterface
+{
+    const SEPARATOR = '/';
+
+    /**
+     * @var ObjectManager
+     */
+    protected $om;
+
+    /**
+     * @var SluggableListener
+     */
+    protected $sluggable;
+
+    /**
+     * @var string
+     */
+    private $prefix;
+
+    /**
+     * @var string
+     */
+    private $suffix;
+
+    /**
+     * True if node is being inserted
+     *
+     * @var boolean
+     */
+    private $isInsert = false;
+
+    /**
+     * Transliterated parent slug
+     *
+     * @var string
+     */
+    private $parentSlug;
+
+    /**
+     * Used path separator
+     *
+     * @var string
+     */
+    private $usedPathSeparator;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function __construct(SluggableListener $sluggable)
+    {
+        $this->sluggable = $sluggable;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function onChangeDecision(SluggableAdapter $ea, array &$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;
+        $this->prefix = isset($options['prefix']) ? $options['prefix'] : '';
+        $this->suffix = isset($options['suffix']) ? $options['suffix'] : '';
+
+        if (!$this->isInsert && !$needToChangeSlug) {
+            $changeSet = $ea->getObjectChangeSet($this->om->getUnitOfWork(), $object);
+            if (isset($changeSet[$options['parentRelationField']])) {
+                $needToChangeSlug = true;
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function postSlugBuild(SluggableAdapter $ea, array &$config, $object, &$slug)
+    {
+        $options = $config['handlers'][get_called_class()];
+        $this->parentSlug = '';
+
+        $wrapped = AbstractWrapper::wrap($object, $this->om);
+        if ($parent = $wrapped->getPropertyValue($options['parentRelationField'])) {
+            $parent = AbstractWrapper::wrap($parent, $this->om);
+            $this->parentSlug = $parent->getPropertyValue($config['slug']);
+
+            // if needed, remove suffix from parentSlug, so we can use it to prepend it to our slug
+            if (isset($options['suffix'])) {
+                $suffix = $options['suffix'];
+
+                if (substr($this->parentSlug, -strlen($suffix)) === $suffix) { //endsWith
+                    $this->parentSlug = substr_replace($this->parentSlug, '', -1 * strlen($suffix));
+                }
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public static function validate(array $options, ClassMetadata $meta)
+    {
+        if (!$meta->isSingleValuedAssociation($options['parentRelationField'])) {
+            throw new InvalidMappingException("Unable to find tree parent slug relation through field - [{$options['parentRelationField']}] in class - {$meta->name}");
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function beforeMakingUnique(SluggableAdapter $ea, array &$config, $object, &$slug)
+    {
+        $slug = $this->transliterate($slug, $config['separator'], $object);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function onSlugCompletion(SluggableAdapter $ea, array &$config, $object, &$slug)
+    {
+        if (!$this->isInsert) {
+            $wrapped = AbstractWrapper::wrap($object, $this->om);
+            $meta = $wrapped->getMetadata();
+            $target = $wrapped->getPropertyValue($config['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) {
+                // for inheritance mapped classes, only root is always in the identity map
+                if ($className !== $wrapped->getRootObjectName()) {
+                    continue;
+                }
+                foreach ($objects as $object) {
+                    if (property_exists($object, '__isInitialized__') && !$object->__isInitialized__) {
+                        continue;
+                    }
+                    $oid = spl_object_hash($object);
+                    $objectSlug = $meta->getReflectionProperty($config['slug'])->getValue($object);
+                    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);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 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 = $text . $this->suffix;
+
+        if (strlen($this->parentSlug)) {
+            $slug = $this->parentSlug.$this->usedPathSeparator.$slug;
+        } else {
+            // if no parentSlug, apply our prefix
+            $slug = $this->prefix.$slug;
+        }
+
+        return $slug;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function handlesUrlization()
+    {
+        return false;
+    }
+}