upgrade

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);
+    }
+}