vendor/symfony/serializer/Mapping/Loader/AnnotationLoader.php line 72

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\Serializer\Mapping\Loader;
  14. use Doctrine\Common\Annotations\Reader;
  15. use Symfony\Component\Serializer\Annotation\Context;
  16. use Symfony\Component\Serializer\Annotation\DiscriminatorMap;
  17. use Symfony\Component\Serializer\Annotation\Groups;
  18. use Symfony\Component\Serializer\Annotation\Ignore;
  19. use Symfony\Component\Serializer\Annotation\MaxDepth;
  20. use Symfony\Component\Serializer\Annotation\SerializedName;
  21. use Symfony\Component\Serializer\Annotation\SerializedPath;
  22. use Symfony\Component\Serializer\Exception\MappingException;
  23. use Symfony\Component\Serializer\Mapping\AttributeMetadata;
  24. use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
  25. use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping;
  26. use Symfony\Component\Serializer\Mapping\ClassMetadataInterface;
  28. /**
  29.  * Loader for Doctrine annotations and PHP 8 attributes.
  30.  *
  31.  * @author Kévin Dunglas <dunglas@gmail.com>
  32.  * @author Alexander M. Turek <me@derrabus.de>
  33.  */
  34. class AnnotationLoader implements LoaderInterface
  35. {
  36.     private const KNOWN_ANNOTATIONS = [
  37.         DiscriminatorMap::class,
  38.         Groups::class,
  39.         Ignore::class,
  40.         MaxDepth::class,
  41.         SerializedName::class,
  42.         SerializedPath::class,
  43.         Context::class,
  44.     ];
  46.     private $reader;
  48.     public function __construct(Reader $reader = null)
  49.     {
  50.         $this->reader = $reader;
  51.     }
  53.     public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
  54.     {
  55.         $reflectionClass = $classMetadata->getReflectionClass();
  56.         $className = $reflectionClass->name;
  57.         $loaded = false;
  59.         $attributesMetadata = $classMetadata->getAttributesMetadata();
  61.         foreach ($this->loadAnnotations($reflectionClass) as $annotation) {
  62.             if ($annotation instanceof DiscriminatorMap) {
  63.                 $classMetadata->setClassDiscriminatorMapping(new ClassDiscriminatorMapping(
  64.                     $annotation->getTypeProperty(),
  65.                     $annotation->getMapping()
  66.                 ));
  67.             }
  68.         }
  70.         foreach ($reflectionClass->getProperties() as $property) {
  71.             if (!isset($attributesMetadata[$property->name])) {
  72.                 $attributesMetadata[$property->name] = new AttributeMetadata($property->name);
  73.                 $classMetadata->addAttributeMetadata($attributesMetadata[$property->name]);
  74.             }
  76.             if ($property->getDeclaringClass()->name === $className) {
  77.                 foreach ($this->loadAnnotations($property) as $annotation) {
  78.                     if ($annotation instanceof Groups) {
  79.                         foreach ($annotation->getGroups() as $group) {
  80.                             $attributesMetadata[$property->name]->addGroup($group);
  81.                         }
  82.                     } elseif ($annotation instanceof MaxDepth) {
  83.                         $attributesMetadata[$property->name]->setMaxDepth($annotation->getMaxDepth());
  84.                     } elseif ($annotation instanceof SerializedName) {
  85.                         $attributesMetadata[$property->name]->setSerializedName($annotation->getSerializedName());
  86.                     } elseif ($annotation instanceof SerializedPath) {
  87.                         $attributesMetadata[$property->name]->setSerializedPath($annotation->getSerializedPath());
  88.                     } elseif ($annotation instanceof Ignore) {
  89.                         $attributesMetadata[$property->name]->setIgnore(true);
  90.                     } elseif ($annotation instanceof Context) {
  91.                         $this->setAttributeContextsForGroups($annotation, $attributesMetadata[$property->name]);
  92.                     }
  94.                     $loaded = true;
  95.                 }
  96.             }
  97.         }
  99.         foreach ($reflectionClass->getMethods() as $method) {
  100.             if ($method->getDeclaringClass()->name !== $className) {
  101.                 continue;
  102.             }
  104.             if (0 === stripos($method->name, 'get') && $method->getNumberOfRequiredParameters()) {
  105.                 continue; /*  matches the BC behavior in `Symfony\Component\Serializer\Normalizer\ObjectNormalizer::extractAttributes` */
  106.             }
  108.             $accessorOrMutator = preg_match('/^(get|is|has|set)(.+)$/i', $method->name, $matches);
  109.             if ($accessorOrMutator) {
  110.                 $attributeName = lcfirst($matches[2]);
  112.                 if (isset($attributesMetadata[$attributeName])) {
  113.                     $attributeMetadata = $attributesMetadata[$attributeName];
  114.                 } else {
  115.                     $attributesMetadata[$attributeName] = $attributeMetadata = new AttributeMetadata($attributeName);
  116.                     $classMetadata->addAttributeMetadata($attributeMetadata);
  117.                 }
  118.             }
  120.             foreach ($this->loadAnnotations($method) as $annotation) {
  121.                 if ($annotation instanceof Groups) {
  122.                     if (!$accessorOrMutator) {
  123.                         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));
  124.                     }
  126.                     foreach ($annotation->getGroups() as $group) {
  127.                         $attributeMetadata->addGroup($group);
  128.                     }
  129.                 } elseif ($annotation instanceof MaxDepth) {
  130.                     if (!$accessorOrMutator) {
  131.                         throw new MappingException(sprintf('MaxDepth on "%s::%s()" cannot be added. MaxDepth can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
  132.                     }
  134.                     $attributeMetadata->setMaxDepth($annotation->getMaxDepth());
  135.                 } elseif ($annotation instanceof SerializedName) {
  136.                     if (!$accessorOrMutator) {
  137.                         throw new MappingException(sprintf('SerializedName on "%s::%s()" cannot be added. SerializedName can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
  138.                     }
  140.                     $attributeMetadata->setSerializedName($annotation->getSerializedName());
  141.                 } elseif ($annotation instanceof SerializedPath) {
  142.                     if (!$accessorOrMutator) {
  143.                         throw new MappingException(sprintf('SerializedPath on "%s::%s()" cannot be added. SerializedPath can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
  144.                     }
  146.                     $attributeMetadata->setSerializedPath($annotation->getSerializedPath());
  147.                 } elseif ($annotation instanceof Ignore) {
  148.                     if (!$accessorOrMutator) {
  149.                         throw new MappingException(sprintf('Ignore on "%s::%s()" cannot be added. Ignore can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
  150.                     }
  152.                     $attributeMetadata->setIgnore(true);
  153.                 } elseif ($annotation instanceof Context) {
  154.                     if (!$accessorOrMutator) {
  155.                         throw new MappingException(sprintf('Context on "%s::%s()" cannot be added. Context can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
  156.                     }
  158.                     $this->setAttributeContextsForGroups($annotation, $attributeMetadata);
  159.                 }
  161.                 $loaded = true;
  162.             }
  163.         }
  165.         return $loaded;
  166.     }
  168.     /**
  169.      * @param \ReflectionClass|\ReflectionMethod|\ReflectionProperty $reflector
  170.      */
  171.     public function loadAnnotations(object $reflector): iterable
  172.     {
  173.         foreach ($reflector->getAttributes() as $attribute) {
  174.             if ($this->isKnownAttribute($attribute->getName())) {
  175.                 try {
  176.                     yield $attribute->newInstance();
  177.                 } catch (\Error $e) {
  178.                     if (\Error::class !== $e::class) {
  179.                         throw $e;
  180.                     }
  181.                     $on = match (true) {
  182.                         $reflector instanceof \ReflectionClass => ' on class '.$reflector->name,
  183.                         $reflector instanceof \ReflectionMethod => sprintf(' on "%s::%s()"', $reflector->getDeclaringClass()->name, $reflector->name),
  184.                         $reflector instanceof \ReflectionProperty => sprintf(' on "%s::$%s"', $reflector->getDeclaringClass()->name, $reflector->name),
  185.                         default => '',
  186.                     };
  188.                     throw new MappingException(sprintf('Could not instantiate attribute "%s"%s.', $attribute->getName(), $on), 0, $e);
  189.                 }
  190.             }
  191.         }
  193.         if (null === $this->reader) {
  194.             return;
  195.         }
  197.         if ($reflector instanceof \ReflectionClass) {
  198.             yield from $this->reader->getClassAnnotations($reflector);
  199.         }
  200.         if ($reflector instanceof \ReflectionMethod) {
  201.             yield from $this->reader->getMethodAnnotations($reflector);
  202.         }
  203.         if ($reflector instanceof \ReflectionProperty) {
  204.             yield from $this->reader->getPropertyAnnotations($reflector);
  205.         }
  206.     }
  208.     private function setAttributeContextsForGroups(Context $annotation, AttributeMetadataInterface $attributeMetadata): void
  209.     {
  210.         if ($annotation->getContext()) {
  211.             $attributeMetadata->setNormalizationContextForGroups($annotation->getContext(), $annotation->getGroups());
  212.             $attributeMetadata->setDenormalizationContextForGroups($annotation->getContext(), $annotation->getGroups());
  213.         }
  215.         if ($annotation->getNormalizationContext()) {
  216.             $attributeMetadata->setNormalizationContextForGroups($annotation->getNormalizationContext(), $annotation->getGroups());
  217.         }
  219.         if ($annotation->getDenormalizationContext()) {
  220.             $attributeMetadata->setDenormalizationContextForGroups($annotation->getDenormalizationContext(), $annotation->getGroups());
  221.         }
  222.     }
  224.     private function isKnownAttribute(string $attributeName): bool
  225.     {
  226.         foreach (self::KNOWN_ANNOTATIONS as $knownAnnotation) {
  227.             if (is_a($attributeName, $knownAnnotation, true)) {
  228.                 return true;
  229.             }
  230.         }
  232.         return false;
  233.     }
  234. }