symfony · joelwurtz · Feb 14, 2019 · Feb 14, 2019 · Feb 14, 2019 · Feb 14, 2019
diff --git a/composer.json b/composer.json
@@ -20,6 +20,7 @@
        "ext-xml": "*",
        "doctrine/event-manager": "~1.0",
        "doctrine/persistence": "^1.3",
+        "nikic/php-parser": "^4.0",
        "twig/twig": "^2.10|^3.0",
        "psr/cache": "~1.0",
        "psr/container": "^1.0",
@@ -40,6 +41,7 @@
    "replace": {
        "symfony/asset": "self.version",
        "symfony/amazon-mailer": "self.version",
+        "symfony/auto-mapper": "self.version",
        "symfony/browser-kit": "self.version",
        "symfony/cache": "self.version",
        "symfony/config": "self.version",

diff --git a/src/Symfony/Component/AutoMapper/.gitignore b/src/Symfony/Component/AutoMapper/.gitignore
@@ -0,0 +1,3 @@
+vendor/
+composer.lock
+phpunit.xml
diff --git a/src/Symfony/Component/AutoMapper/AutoMapper.php b/src/Symfony/Component/AutoMapper/AutoMapper.php
@@ -0,0 +1,257 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\AutoMapper;
+
+use Doctrine\Common\Annotations\AnnotationReader;
+use PhpParser\ParserFactory;
+use Symfony\Component\AutoMapper\Exception\NoMappingFoundException;
+use Symfony\Component\AutoMapper\Extractor\FromSourceMappingExtractor;
+use Symfony\Component\AutoMapper\Extractor\FromTargetMappingExtractor;
+use Symfony\Component\AutoMapper\Extractor\SourceTargetMappingExtractor;
+use Symfony\Component\AutoMapper\Generator\Generator;
+use Symfony\Component\AutoMapper\Loader\ClassLoaderInterface;
+use Symfony\Component\AutoMapper\Loader\EvalLoader;
+use Symfony\Component\AutoMapper\Transformer\ArrayTransformerFactory;
+use Symfony\Component\AutoMapper\Transformer\BuiltinTransformerFactory;
+use Symfony\Component\AutoMapper\Transformer\ChainTransformerFactory;
+use Symfony\Component\AutoMapper\Transformer\DateTimeTransformerFactory;
+use Symfony\Component\AutoMapper\Transformer\MultipleTransformerFactory;
+use Symfony\Component\AutoMapper\Transformer\NullableTransformerFactory;
+use Symfony\Component\AutoMapper\Transformer\ObjectTransformerFactory;
+use Symfony\Component\AutoMapper\Transformer\UniqueTypeTransformerFactory;
+use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
+use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
+use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
+use Symfony\Component\Serializer\Mapping\ClassDiscriminatorFromClassMetadata;
+use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
+use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
+use Symfony\Component\Serializer\NameConverter\AdvancedNameConverterInterface;
+
+/**
+ * Maps a source data structure (object or array) to a target one.
+ *
+ * @expiremental in 5.1
+ *
+ * @author Joel Wurtz <jwurtz@jolicode.com>
+ */
+final class AutoMapper implements AutoMapperInterface, AutoMapperRegistryInterface, MapperGeneratorMetadataRegistryInterface
+{
+    /** @var MapperGeneratorMetadataInterface[] */
+    private $metadata = [];
+
+    /** @var GeneratedMapper[] */
+    private $mapperRegistry = [];
+
+    private $classLoader;
+
+    private $mapperConfigurationFactory;
+
+    public function __construct(ClassLoaderInterface $classLoader, MapperGeneratorMetadataFactoryInterface $mapperConfigurationFactory = null)
+    {
+        $this->classLoader = $classLoader;
+        $this->mapperConfigurationFactory = $mapperConfigurationFactory;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function register(MapperGeneratorMetadataInterface $metadata): void
+    {
+        $this->metadata[$metadata->getSource()][$metadata->getTarget()] = $metadata;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMapper(string $source, string $target): MapperInterface
+    {
+        $metadata = $this->getMetadata($source, $target);
+
+        if (null === $metadata) {
+            throw new NoMappingFoundException('No mapping found for source '.$source.' and target '.$target);
+        }
+
+        $className = $metadata->getMapperClassName();
+
+        if (\array_key_exists($className, $this->mapperRegistry)) {
+            return $this->mapperRegistry[$className];
+        }
+
+        if (!class_exists($className)) {
+            $this->classLoader->loadClass($metadata);
+        }
+
+        $this->mapperRegistry[$className] = new $className();
+        $this->mapperRegistry[$className]->injectMappers($this);
+
+        foreach ($metadata->getCallbacks() as $property => $callback) {
+            $this->mapperRegistry[$className]->addCallback($property, $callback);
+        }
+
+        return $this->mapperRegistry[$className];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasMapper(string $source, string $target): bool
+    {
+        return null !== $this->getMetadata($source, $target);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function map($sourceData, $targetData, array $context = [])
+    {
+        $source = null;
+        $target = null;
+
+        if (null === $sourceData) {
+            return null;
+        }
+
+        if (\is_object($sourceData)) {
+            $source = \get_class($sourceData);
+        } elseif (\is_array($sourceData)) {
+            $source = 'array';
+        }
+
+        if (null === $source) {
+            throw new NoMappingFoundException('Cannot map this value, source is neither an object or an array.');
+        }
+
+        if (\is_object($targetData)) {
+            $target = \get_class($targetData);
+            $context[MapperContext::TARGET_TO_POPULATE] = $targetData;
+        } elseif (\is_array($targetData)) {
+            $target = 'array';
+            $context[MapperContext::TARGET_TO_POPULATE] = $targetData;
+        } elseif (\is_string($targetData)) {
+            $target = $targetData;
+        }
+
+        if (null === $target) {
+            throw new NoMappingFoundException('Cannot map this value, target is neither an object or an array.');
+        }
+
+        if ('array' === $source && 'array' === $target) {
+            throw new NoMappingFoundException('Cannot map this value, both source and target are array.');
+        }
+
+        return $this->getMapper($source, $target)->map($sourceData, $context);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getMetadata(string $source, string $target): ?MapperGeneratorMetadataInterface
+    {
+        if (!isset($this->metadata[$source][$target])) {
+            if (null === $this->mapperConfigurationFactory) {
+                return null;
+            }
+
+            $this->register($this->mapperConfigurationFactory->create($this, $source, $target));
+        }
+
+        return $this->metadata[$source][$target];
+    }
+
+    /**
+     * Create an automapper.
+     */
+    public static function create(
+        bool $private = true,
+        ClassLoaderInterface $loader = null,
+        AdvancedNameConverterInterface $nameConverter = null,
+        string $classPrefix = 'Mapper_',
+        bool $attributeChecking = true,
+        bool $autoRegister = true
+    ): self {
+        $classMetadataFactory = new ClassMetadataFactory(new AnnotationLoader(new AnnotationReader()));
+
+        if (null === $loader) {
+            $loader = new EvalLoader(new Generator(
+                (new ParserFactory())->create(ParserFactory::PREFER_PHP7),
+                new ClassDiscriminatorFromClassMetadata($classMetadataFactory)
+            ));
+        }
+
+        $flags = ReflectionExtractor::ALLOW_PUBLIC;
+
+        if ($private) {
+            $flags |= ReflectionExtractor::ALLOW_PROTECTED | ReflectionExtractor::ALLOW_PRIVATE;
+        }
+
+        $reflectionExtractor = new ReflectionExtractor(
+            null,
+            null,
+            null,
+            true,
+            $flags
+        );
+
+        $phpDocExtractor = new PhpDocExtractor();
+        $propertyInfoExtractor = new PropertyInfoExtractor(
+            [$reflectionExtractor],
+            [$phpDocExtractor, $reflectionExtractor],
+            [$reflectionExtractor],
+            [$reflectionExtractor]
+        );
+
+        $transformerFactory = new ChainTransformerFactory();
+        $sourceTargetMappingExtractor = new SourceTargetMappingExtractor(
+            $propertyInfoExtractor,
+            $reflectionExtractor,
+            $reflectionExtractor,
+            $transformerFactory,
+            $classMetadataFactory
+        );
+
+        $fromTargetMappingExtractor = new FromTargetMappingExtractor(
+            $propertyInfoExtractor,
+            $reflectionExtractor,
+            $reflectionExtractor,
+            $transformerFactory,
+            $classMetadataFactory,
+            $nameConverter
+        );
+
+        $fromSourceMappingExtractor = new FromSourceMappingExtractor(
+            $propertyInfoExtractor,
+            $reflectionExtractor,
+            $reflectionExtractor,
+            $transformerFactory,
+            $classMetadataFactory,
+            $nameConverter
+        );
+
+        $autoMapper = $autoRegister ? new self($loader, new MapperGeneratorMetadataFactory(
+            $sourceTargetMappingExtractor,
+            $fromSourceMappingExtractor,
+            $fromTargetMappingExtractor,
+            $classPrefix,
+            $attributeChecking
+        )) : new self($loader);
+
+        $transformerFactory->addTransformerFactory(new MultipleTransformerFactory($transformerFactory));
+        $transformerFactory->addTransformerFactory(new NullableTransformerFactory($transformerFactory));
+        $transformerFactory->addTransformerFactory(new UniqueTypeTransformerFactory($transformerFactory));
+        $transformerFactory->addTransformerFactory(new DateTimeTransformerFactory());
+        $transformerFactory->addTransformerFactory(new BuiltinTransformerFactory());
+        $transformerFactory->addTransformerFactory(new ArrayTransformerFactory($transformerFactory));
+        $transformerFactory->addTransformerFactory(new ObjectTransformerFactory($autoMapper));
+
+        return $autoMapper;
+    }
+}
diff --git a/src/Symfony/Component/AutoMapper/AutoMapperInterface.php b/src/Symfony/Component/AutoMapper/AutoMapperInterface.php
@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\AutoMapper;
+
+/**
+ * An auto mapper has the role of mapping a source to a target.
+ *
+ * @expiremental in 5.1
+ *
+ * @author Joel Wurtz <jwurtz@jolicode.com>
+ */
+interface AutoMapperInterface
+{
+    /**
+     * Maps data from a source to a target.
+     *
+     * @param array|object        $source  Any data object, which may be an object or an array
+     * @param string|array|object $target  To which type of data, or data, the source should be mapped
+     * @param array               $context Mapper context
+     *
+     * @return array|object The mapped object
+     */
+    public function map($source, $target, array $context = []);
+}