Actualización

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Driver/Annotation.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace Gedmo\References\Mapping\Driver;
+
+use Gedmo\Mapping\Driver\AnnotationDriverInterface;
+
+/**
+ * This is an annotation mapping driver for References
+ * behavioral extension.
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class Annotation implements AnnotationDriverInterface
+{
+    /**
+     * Annotation to mark field as reference to one
+     */
+    const REFERENCE_ONE = 'Gedmo\\Mapping\\Annotation\\ReferenceOne';
+
+    /**
+     * Annotation to mark field as reference to many
+     */
+    const REFERENCE_MANY = 'Gedmo\\Mapping\\Annotation\\ReferenceMany';
+
+    /**
+     * Annotation to mark field as reference to many
+     */
+    const REFERENCE_MANY_EMBED = 'Gedmo\\Mapping\\Annotation\\ReferenceManyEmbed';
+
+    private $annotations = array(
+        'referenceOne'  => self::REFERENCE_ONE,
+        'referenceMany' => self::REFERENCE_MANY,
+        'referenceManyEmbed' => self::REFERENCE_MANY_EMBED,
+    );
+
+    /**
+     * Annotation reader instance
+     *
+     * @var object
+     */
+    private $reader;
+
+    /**
+     * original driver if it is available
+     */
+    protected $_originalDriver = null;
+
+    /**
+     * {@inheritDoc}
+     */
+    public function setAnnotationReader($reader)
+    {
+        $this->reader = $reader;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function readExtendedMetadata($meta, array &$config)
+    {
+        $class = $meta->getReflectionClass();
+        foreach ($this->annotations as $key => $annotation) {
+            $config[$key] = array();
+            foreach ($class->getProperties() as $property) {
+                if ($meta->isMappedSuperclass && !$property->isPrivate() ||
+                    $meta->isInheritedField($property->name) ||
+                    isset($meta->associationMappings[$property->name]['inherited'])
+                ) {
+                    continue;
+                }
+
+                if ($reference = $this->reader->getPropertyAnnotation($property, $annotation)) {
+                    $config[$key][$property->getName()] = array(
+                        'field'      => $property->getName(),
+                        'type'       => $reference->type,
+                        'class'      => $reference->class,
+                        'identifier' => $reference->identifier,
+                        'mappedBy'   => $reference->mappedBy,
+                        'inversedBy' => $reference->inversedBy,
+                    );
+                }
+            }
+        }
+    }
+
+    /**
+     * Passes in the mapping read by original driver
+     *
+     * @param $driver
+     * @return void
+     */
+    public function setOriginalDriver($driver)
+    {
+        $this->_originalDriver = $driver;
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Driver/Xml.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace Gedmo\References\Mapping\Driver;
+
+use Gedmo\Mapping\Driver\Xml as BaseXml;
+use Gedmo\Exception\InvalidMappingException;
+
+/**
+ * This is a xml mapping driver for References
+ * behavioral extension. Used for extraction of extended
+ * metadata from xml specifically for References
+ * extension.
+ *
+ * @author Aram Alipoor <aram.alipoor@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+class Xml extends BaseXml
+{
+    /**
+     * @var array
+     */
+    private $validTypes = array(
+        'document',
+        'entity'
+    );
+
+    /**
+     * @var array
+     */
+    private $validReferences = array(
+        'referenceOne',
+        'referenceMany',
+        'referenceManyEmbed'
+    );
+
+    /**
+     * {@inheritDoc}
+     */
+    public function readExtendedMetadata($meta, array &$config)
+    {
+        /**
+         * @var \SimpleXmlElement $xml
+         */
+        $xml = $this->_getMapping($meta->name);
+        $xmlDoctrine = $xml;
+
+        $xml = $xml->children(self::GEDMO_NAMESPACE_URI);
+
+        if ($xmlDoctrine->getName() === 'entity' || $xmlDoctrine->getName() === 'document' || $xmlDoctrine->getName() === 'mapped-superclass') {
+            if (isset($xml->reference)) {
+                /**
+                 * @var \SimpleXMLElement $element
+                 */
+                foreach ($xml->reference as $element) {
+                    if (!$this->_isAttributeSet($element, 'type')) {
+                        throw new InvalidMappingException("Reference type (document or entity) is not set in class - {$meta->name}");
+                    }
+
+                    $type = $this->_getAttribute($element, 'type');
+                    if (!in_array($type, $this->validTypes)) {
+                        throw new InvalidMappingException(
+                            $type .
+                            ' is not a valid reference type, valid types are: ' .
+                            implode(', ', $this->validTypes)
+                        );
+                    }
+
+                    $reference = $this->_getAttribute($element, 'reference');
+                    if (!in_array($reference, $this->validReferences)) {
+                        throw new InvalidMappingException(
+                            $reference .
+                            ' is not a valid reference, valid references are: ' .
+                            implode(', ', $this->validReferences)
+                        );
+                    }
+
+                    if (!$this->_isAttributeSet($element, 'field')) {
+                        throw new InvalidMappingException("Reference field is not set in class - {$meta->name}");
+                    }
+                    $field = $this->_getAttribute($element, 'field');
+
+                    if (!$this->_isAttributeSet($element, 'class')) {
+                        throw new InvalidMappingException("Reference field is not set in class - {$meta->name}");
+                    }
+                    $class = $this->_getAttribute($element, 'class');
+
+                    if (!$this->_isAttributeSet($element, 'identifier')) {
+                        throw new InvalidMappingException("Reference identifier is not set in class - {$meta->name}");
+                    }
+                    $identifier = $this->_getAttribute($element, 'identifier');
+
+                    $config[$reference][$field] = array(
+                        'field' => $field,
+                        'type' => $type,
+                        'class' => $class,
+                        'identifier' => $identifier
+                    );
+
+                    if (!$this->_isAttributeSet($element, 'mappedBy')) {
+                        $config[$reference][$field]['mappedBy'] = $this->_getAttribute($element, 'mappedBy');
+                    }
+                    if (!$this->_isAttributeSet($element, 'inversedBy')) {
+                        $config[$reference][$field]['inversedBy'] = $this->_getAttribute($element, 'inversedBy');
+                    }
+                }
+            }
+        }
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Driver/Yaml.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace Gedmo\References\Mapping\Driver;
+
+use Gedmo\Mapping\Driver\File;
+use Gedmo\Mapping\Driver;
+use Gedmo\Exception\InvalidMappingException;
+
+/**
+ * @author Gonzalo Vilaseca <gonzalo.vilaseca@reiss.com>
+ */
+class Yaml extends File implements Driver
+{
+    /**
+     * File extension
+     * @var string
+     */
+    protected $_extension = '.dcm.yml';
+
+    private $validReferences = array(
+        'referenceOne'       => array(),
+        'referenceMany'      => array(),
+        'referenceManyEmbed' => array(),
+    );
+
+    /**
+     * {@inheritDoc}
+     */
+    public function readExtendedMetadata($meta, array &$config)
+    {
+        $mapping = $this->_getMapping($meta->name);
+
+        if (isset($mapping['gedmo']) && isset($mapping['gedmo']['reference'])) {
+
+            foreach ($mapping['gedmo']['reference'] as $field => $fieldMapping) {
+                $reference = $fieldMapping['reference'];
+
+                if (!in_array($reference, array_keys($this->validReferences))) {
+                    throw new InvalidMappingException(
+                        $reference .
+                        ' is not a valid reference, valid references are: ' .
+                        implode(', ', array_keys($this->validReferences))
+                    );
+                }
+
+                $config[$reference][$field] = array(
+                    'field' => $field,
+                    'type'  => $fieldMapping['type'],
+                    'class' => $fieldMapping['class'],
+                );
+
+                if (array_key_exists('mappedBy', $fieldMapping)) {
+                    $config[$reference][$field]['mappedBy'] = $fieldMapping['mappedBy'];
+
+                }
+
+                if (array_key_exists('identifier', $fieldMapping)) {
+                    $config[$reference][$field]['identifier'] = $fieldMapping['identifier'];
+
+                }
+
+                if (array_key_exists('inversedBy', $fieldMapping)) {
+                    $config[$reference][$field]['inversedBy'] = $fieldMapping['inversedBy'];
+                }
+            }
+        }
+        $config = array_merge($this->validReferences, $config);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected function _loadMappingFile($file)
+    {
+        return \Symfony\Component\Yaml\Yaml::parse($file);
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Event/Adapter/ODM.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Gedmo\References\Mapping\Event\Adapter;
+
+use Doctrine\ODM\MongoDB\DocumentManager;
+use Doctrine\ODM\MongoDB\Proxy\Proxy as MongoDBProxy;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Proxy\Proxy as ORMProxy;
+use Gedmo\Mapping\Event\Adapter\ODM as BaseAdapterODM;
+use Gedmo\References\Mapping\Event\ReferencesAdapter;
+
+/**
+ * Doctrine event adapter for ODM references behavior
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+final class ODM extends BaseAdapterODM implements ReferencesAdapter
+{
+    /**
+     * @inheritDoc
+     */
+    public function getIdentifier($om, $object, $single = true)
+    {
+        if ($om instanceof DocumentManager) {
+            return $this->extractIdentifier($om, $object, $single);
+        }
+
+        if ($om instanceof EntityManagerInterface) {
+            if ($object instanceof ORMProxy) {
+                $id = $om->getUnitOfWork()->getEntityIdentifier($object);
+            } else {
+                $meta = $om->getClassMetadata(get_class($object));
+                $id = array();
+                foreach ($meta->identifier as $name) {
+                    $id[$name] = $meta->getReflectionProperty($name)->getValue($object);
+                    // return null if one of identifiers is missing
+                    if (!$id[$name]) {
+                        return null;
+                    }
+                }
+            }
+
+            if ($single) {
+                $id = current($id);
+            }
+
+            return $id;
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getSingleReference($om, $class, $identifier)
+    {
+        $this->throwIfNotEntityManager($om);
+        $meta = $om->getClassMetadata($class);
+
+        if (!$meta->isInheritanceTypeNone()) {
+            return $om->find($class, $identifier);
+        }
+
+        return $om->getReference($class, $identifier);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function extractIdentifier($om, $object, $single = true)
+    {
+        $meta = $om->getClassMetadata(get_class($object));
+        if ($object instanceof MongoDBProxy) {
+            $id = $om->getUnitOfWork()->getDocumentIdentifier($object);
+        } else {
+            $id = $meta->getReflectionProperty($meta->identifier)->getValue($object);
+        }
+
+        if ($single || !$id) {
+            return $id;
+        } else {
+            return array($meta->identifier => $id);
+        }
+    }
+
+    /**
+     * Override so we don't get an exception. We want to allow this.
+     */
+    private function throwIfNotEntityManager(EntityManagerInterface $em)
+    {
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Event/Adapter/ORM.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Gedmo\References\Mapping\Event\Adapter;
+
+use Doctrine\ODM\MongoDB\DocumentManager as MongoDocumentManager;
+use Doctrine\ODM\MongoDB\Proxy\Proxy as MongoDBProxy;
+use Doctrine\ODM\PHPCR\DocumentManager as PhpcrDocumentManager;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Proxy\Proxy as ORMProxy;
+use Gedmo\Exception\InvalidArgumentException;
+use Gedmo\Mapping\Event\Adapter\ORM as BaseAdapterORM;
+use Gedmo\References\Mapping\Event\ReferencesAdapter;
+
+/**
+ * Doctrine event adapter for ORM references behavior
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+final class ORM extends BaseAdapterORM implements ReferencesAdapter
+{
+    /**
+     * @inheritDoc
+     */
+    public function getIdentifier($om, $object, $single = true)
+    {
+        if ($om instanceof EntityManagerInterface) {
+            return $this->extractIdentifier($om, $object, $single);
+        }
+
+        if ($om instanceof MongoDocumentManager) {
+            $meta = $om->getClassMetadata(get_class($object));
+            if ($object instanceof MongoDBProxy) {
+                $id = $om->getUnitOfWork()->getDocumentIdentifier($object);
+            } else {
+                $id = $meta->getReflectionProperty($meta->identifier)->getValue($object);
+            }
+
+            if ($single || !$id) {
+                return $id;
+            }
+
+            return array($meta->identifier => $id);
+        }
+
+        if ($om instanceof PhpcrDocumentManager) {
+            $meta = $om->getClassMetadata(get_class($object));
+            $id = $meta->getReflectionProperty($meta->identifier)->getValue($object);
+
+            if ($single || !$id) {
+                return $id;
+            }
+
+            return array($meta->identifier => $id);
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function getSingleReference($om, $class, $identifier)
+    {
+        $this->throwIfNotDocumentManager($om);
+        $meta = $om->getClassMetadata($class);
+
+        if ($om instanceof MongoDocumentManager) {
+            if (!$meta->isInheritanceTypeNone()) {
+                return $om->find($class, $identifier);
+            }
+        }
+
+        return $om->getReference($class, $identifier);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function extractIdentifier($om, $object, $single = true)
+    {
+        if ($object instanceof ORMProxy) {
+            $id = $om->getUnitOfWork()->getEntityIdentifier($object);
+        } else {
+            $meta = $om->getClassMetadata(get_class($object));
+            $id = array();
+            foreach ($meta->identifier as $name) {
+                $id[$name] = $meta->getReflectionProperty($name)->getValue($object);
+                // return null if one of identifiers is missing
+                if (!$id[$name]) {
+                    return null;
+                }
+            }
+        }
+
+        if ($single) {
+            $id = current($id);
+        }
+
+        return $id;
+    }
+
+    /**
+     * Override so we don't get an exception. We want to allow this.
+     */
+    private function throwIfNotDocumentManager($dm)
+    {
+        if (!($dm instanceof MongoDocumentManager) && !($dm instanceof PhpcrDocumentManager)) {
+            throw new InvalidArgumentException(
+                sprintf(
+                    'Expected a %s or %s instance but got "%s"',
+                    'Doctrine\ODM\MongoDB\DocumentManager',
+                    'Doctrine\ODM\PHPCR\DocumentManager',
+                    is_object($dm) ? get_class($dm) : gettype($dm)
+                )
+            );
+        }
+    }
+}

vendor/gedmo/doctrine-extensions/lib/Gedmo/References/Mapping/Event/ReferencesAdapter.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Gedmo\References\Mapping\Event;
+
+use Doctrine\Common\Persistence\ObjectManager;
+use Gedmo\Mapping\Event\AdapterInterface;
+
+/**
+ * Doctrine event adapter interface for References behavior
+ *
+ * @author Gediminas Morkevicius <gediminas.morkevicius@gmail.com>
+ * @author Bulat Shakirzyanov <mallluhuct@gmail.com>
+ * @author Jonathan H. Wage <jonwage@gmail.com>
+ * @license MIT License (http://www.opensource.org/licenses/mit-license.php)
+ */
+interface ReferencesAdapter extends AdapterInterface
+{
+    /**
+     * Gets the identifier of the given object using the passed ObjectManager.
+     *
+     * @param ObjectManager $om
+     * @param object        $object
+     * @param bool          $single
+     *
+     * @return array|string|int $id - array or single identifier
+     */
+    public function getIdentifier($om, $object, $single = true);
+
+    /**
+     * Gets a single reference for the given ObjectManager, class and identifier.
+     *
+     * @param ObjectManager    $om
+     * @param string           $class
+     * @param array|string|int $identifier
+     **/
+    public function getSingleReference($om, $class, $identifier);
+
+    /**
+     * Extracts identifiers from object or proxy.
+     *
+     * @param ObjectManager $om
+     * @param object        $object
+     * @param bool          $single
+     *
+     * @return array|string|int - array or single identifier
+     */
+    public function extractIdentifier($om, $object, $single = true);
+}