[Serializer] Enabled mapping configuration via attributes.

Author: derrabus

.github/patch-types.php

@@ -35,6 +35,7 @@
         case false !== strpos($file, '/src/Symfony/Component/PropertyInfo/Tests/Fixtures/Php80Dummy.php'):
         case false !== strpos($file, '/src/Symfony/Component/Routing/Tests/Fixtures/AttributeFixtures'):
         case false !== strpos($file, '/src/Symfony/Component/Serializer/Tests/Normalizer/Features/ObjectOuter.php'):
+        case false !== strpos($file, '/src/Symfony/Component/Serializer/Tests/Fixtures/Attributes/'):
         case false !== strpos($file, '/src/Symfony/Component/VarDumper/Tests/Fixtures/LotsOfAttributes.php'):
         case false !== strpos($file, '/src/Symfony/Component/Validator/Tests/Fixtures/Attribute/'):
         case false !== strpos($file, '/src/Symfony/Component/VarDumper/Tests/Fixtures/MyAttribute.php'):

src/Symfony/Component/Serializer/Annotation/DiscriminatorMap.php

@@ -21,6 +21,7 @@
  *
  * @author Samuel Roze <[email protected]>
  */
+#[\Attribute(\Attribute::TARGET_CLASS)]
 class DiscriminatorMap
 {
     /**
@@ -34,20 +35,29 @@ class DiscriminatorMap
     private $mapping;
 
     /**
+     * @param string|array $typeProperty
+     *
      * @throws InvalidArgumentException
      */
-    public function __construct(array $data)
+    public function __construct($typeProperty, array $mapping = null)
     {
-        if (empty($data['typeProperty'])) {
+        if (\is_array($typeProperty)) {
+            $mapping = $typeProperty['mapping'] ?? null;
+            $typeProperty = $typeProperty['typeProperty'] ?? null;
+        } elseif (!\is_string($typeProperty)) {
+            throw new \TypeError(sprintf('"%s": Argument $typeProperty was expected to be a string or array, got "%s".', __METHOD__, get_debug_type($typeProperty)));
+        }
+
+        if (empty($typeProperty)) {
             throw new InvalidArgumentException(sprintf('Parameter "typeProperty" of annotation "%s" cannot be empty.', static::class));
         }
 
-        if (empty($data['mapping'])) {
+        if (empty($mapping)) {
             throw new InvalidArgumentException(sprintf('Parameter "mapping" of annotation "%s" cannot be empty.', static::class));
         }
 
-        $this->typeProperty = $data['typeProperty'];
-        $this->mapping = $data['mapping'];
+        $this->typeProperty = $typeProperty;
+        $this->mapping = $mapping;
     }
 
     public function getTypeProperty(): string

src/Symfony/Component/Serializer/Annotation/Groups.php

@@ -21,6 +21,7 @@
  *
  * @author Kévin Dunglas <[email protected]>
  */
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
 class Groups
 {
     /**
@@ -31,20 +32,22 @@ class Groups
     /**
      * @throws InvalidArgumentException
      */
-    public function __construct(array $data)
+    public function __construct(array $groups)
     {
-        if (!isset($data['value']) || !$data['value']) {
+        if (isset($groups['value'])) {
+            $groups = (array) $groups['value'];
+        }
+        if (empty($groups)) {
             throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" cannot be empty.', static::class));
         }
 
-        $value = (array) $data['value'];
-        foreach ($value as $group) {
+        foreach ($groups as $group) {
             if (!\is_string($group)) {
                 throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" must be a string or an array of strings.', static::class));
             }
         }
 
-        $this->groups = $value;
+        $this->groups = $groups;
     }
 
     /**

src/Symfony/Component/Serializer/Annotation/Ignore.php

@@ -19,6 +19,7 @@
  *
  * @author Kévin Dunglas <[email protected]>
  */
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
 final class Ignore
 {
 }

src/Symfony/Component/Serializer/Annotation/MaxDepth.php

@@ -21,24 +21,31 @@
  *
  * @author Kévin Dunglas <[email protected]>
  */
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
 class MaxDepth
 {
     /**
      * @var int
      */
     private $maxDepth;
 
-    public function __construct(array $data)
+    /**
+     * @param int|array $maxDepth
+     */
+    public function __construct($maxDepth)
     {
-        if (!isset($data['value'])) {
-            throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" should be set.', static::class));
+        if (\is_array($maxDepth)) {
+            if (!isset($maxDepth['value'])) {
+                throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" should be set.', static::class));
+            }
+            $maxDepth = $maxDepth['value'];
         }
 
-        if (!\is_int($data['value']) || $data['value'] <= 0) {
+        if (!\is_int($maxDepth) || $maxDepth <= 0) {
             throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" must be a positive integer.', static::class));
         }
 
-        $this->maxDepth = $data['value'];
+        $this->maxDepth = $maxDepth;
     }
 
     public function getMaxDepth()

src/Symfony/Component/Serializer/Annotation/SerializedName.php

@@ -21,24 +21,31 @@
  *
  * @author Fabien Bourigault <[email protected]>
  */
+#[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
 final class SerializedName
 {
     /**
      * @var string
      */
     private $serializedName;
 
-    public function __construct(array $data)
+    /**
+     * @param string|array $serializedName
+     */
+    public function __construct($serializedName)
     {
-        if (!isset($data['value'])) {
-            throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" should be set.', static::class));
+        if (\is_array($serializedName)) {
+            if (!isset($serializedName['value'])) {
+                throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" should be set.', static::class));
+            }
+            $serializedName = $serializedName['value'];
         }
 
-        if (!\is_string($data['value']) || empty($data['value'])) {
+        if (!\is_string($serializedName) || empty($serializedName)) {
             throw new InvalidArgumentException(sprintf('Parameter of annotation "%s" must be a non-empty string.', static::class));
         }
 
-        $this->serializedName = $data['value'];
+        $this->serializedName = $serializedName;
     }
 
     public function getSerializedName(): string

src/Symfony/Component/Serializer/CHANGELOG.md

@@ -8,6 +8,7 @@ CHANGELOG
  * added `UidNormalizer`
  * added `FormErrorNormalizer`
  * added `MimeMessageNormalizer`
+ * serializer mapping can be configured using php attributes
 
 5.1.0
 -----

src/Symfony/Component/Serializer/Mapping/Loader/AnnotationLoader.php

@@ -26,12 +26,21 @@
  * Annotation loader.
  *
  * @author Kévin Dunglas <[email protected]>
+ * @author Alexander M. Turek <[email protected]>
  */
 class AnnotationLoader implements LoaderInterface
 {
+    private const KNOWN_ANNOTATIONS = [
+        DiscriminatorMap::class => true,
+        Groups::class => true,
+        Ignore:: class => true,
+        MaxDepth::class => true,
+        SerializedName::class => true,
+    ];
+
     private $reader;
 
-    public function __construct(Reader $reader)
+    public function __construct(Reader $reader = null)
     {
         $this->reader = $reader;
     }
@@ -47,7 +56,7 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata)
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
 
-        foreach ($this->reader->getClassAnnotations($reflectionClass) as $annotation) {
+        foreach ($this->loadAnnotations($reflectionClass) as $annotation) {
             if ($annotation instanceof DiscriminatorMap) {
                 $classMetadata->setClassDiscriminatorMapping(new ClassDiscriminatorMapping(
                     $annotation->getTypeProperty(),
@@ -63,7 +72,7 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata)
             }
 
             if ($property->getDeclaringClass()->name === $className) {
-                foreach ($this->reader->getPropertyAnnotations($property) as $annotation) {
+                foreach ($this->loadAnnotations($property) as $annotation) {
                     if ($annotation instanceof Groups) {
                         foreach ($annotation->getGroups() as $group) {
                             $attributesMetadata[$property->name]->addGroup($group);
@@ -98,7 +107,7 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata)
                 }
             }
 
-            foreach ($this->reader->getMethodAnnotations($method) as $annotation) {
+            foreach ($this->loadAnnotations($method) as $annotation) {
                 if ($annotation instanceof Groups) {
                     if (!$accessorOrMutator) {
                         throw new MappingException(sprintf('Groups on "%s::%s" cannot be added. Groups can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
@@ -129,4 +138,32 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata)
 
         return $loaded;
     }
+
+    /**
+     * @param \ReflectionClass|\ReflectionMethod|\ReflectionProperty $reflector
+     */
+    public function loadAnnotations(object $reflector): iterable
+    {
+        if (\PHP_VERSION_ID >= 80000) {
+            foreach ($reflector->getAttributes() as $attribute) {
+                if (self::KNOWN_ANNOTATIONS[$attribute->getName()] ?? false) {
+                    yield $attribute->newInstance();
+                }
+            }
+        }
+
+        if (null === $this->reader) {
+            return;
+        }
+
+        if ($reflector instanceof \ReflectionClass) {
+            yield from $this->reader->getClassAnnotations($reflector);
+        }
+        if ($reflector instanceof \ReflectionMethod) {
+            yield from $this->reader->getMethodAnnotations($reflector);
+        }
+        if ($reflector instanceof \ReflectionProperty) {
+            yield from $this->reader->getPropertyAnnotations($reflector);
+        }
+    }
 }

src/Symfony/Component/Serializer/Tests/Fixtures/AbstractDummy.php renamed to src/Symfony/Component/Serializer/Tests/Fixtures/Annotations/AbstractDummy.php

@@ -9,15 +9,15 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Fixtures;
+namespace Symfony\Component\Serializer\Tests\Fixtures\Annotations;
 
 use Symfony\Component\Serializer\Annotation\DiscriminatorMap;
 
 /**
  * @DiscriminatorMap(typeProperty="type", mapping={
- *    "first"="Symfony\Component\Serializer\Tests\Fixtures\AbstractDummyFirstChild",
- *    "second"="Symfony\Component\Serializer\Tests\Fixtures\AbstractDummySecondChild",
- *    "third"="Symfony\Component\Serializer\Tests\Fixtures\AbstractDummyThirdChild",
+ *    "first"="Symfony\Component\Serializer\Tests\Fixtures\Annotations\AbstractDummyFirstChild",
+ *    "second"="Symfony\Component\Serializer\Tests\Fixtures\Annotations\AbstractDummySecondChild",
+ *    "third"="Symfony\Component\Serializer\Tests\Fixtures\Annotations\AbstractDummyThirdChild",
  * })
  */
 abstract class AbstractDummy

src/Symfony/Component/Serializer/Tests/Fixtures/Annotations/AbstractDummyFirstChild.php

@@ -0,0 +1,39 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <[email protected]>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Serializer\Tests\Fixtures\Annotations;
+
+use Symfony\Component\Serializer\Tests\Fixtures\DummyFirstChildQuux;
+
+class AbstractDummyFirstChild extends AbstractDummy
+{
+    public $bar;
+
+    /** @var DummyFirstChildQuux|null */
+    public $quux;
+
+    public function __construct($foo = null, $bar = null)
+    {
+        parent::__construct($foo);
+
+        $this->bar = $bar;
+    }
+
+    public function getQuux(): ?DummyFirstChildQuux
+    {
+        return $this->quux;
+    }
+
+    public function setQuux(DummyFirstChildQuux $quux): void
+    {
+        $this->quux = $quux;
+    }
+}