vendor/symfony/validator/Mapping/Loader/AnnotationLoader.php line 32

  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\Validator\Mapping\Loader;
  14. use Doctrine\Common\Annotations\Reader;
  15. use Symfony\Component\Validator\Constraint;
  16. use Symfony\Component\Validator\Constraints\Callback;
  17. use Symfony\Component\Validator\Constraints\GroupSequence;
  18. use Symfony\Component\Validator\Constraints\GroupSequenceProvider;
  19. use Symfony\Component\Validator\Exception\MappingException;
  20. use Symfony\Component\Validator\Mapping\ClassMetadata;
  22. /**
  23.  * Loads validation metadata using a Doctrine annotation {@link Reader} or using PHP 8 attributes.
  24.  *
  25.  * @author Bernhard Schussek <bschussek@gmail.com>
  26.  * @author Alexander M. Turek <me@derrabus.de>
  27.  */
  28. class AnnotationLoader implements LoaderInterface
  29. {
  30.     protected $reader;
  32.     public function __construct(Reader $reader = null)
  33.     {
  34.         $this->reader = $reader;
  35.     }
  37.     public function loadClassMetadata(ClassMetadata $metadata): bool
  38.     {
  39.         $reflClass = $metadata->getReflectionClass();
  40.         $className = $reflClass->name;
  41.         $success = false;
  43.         foreach ($this->getAnnotations($reflClass) as $constraint) {
  44.             if ($constraint instanceof GroupSequence) {
  45.                 $metadata->setGroupSequence($constraint->groups);
  46.             } elseif ($constraint instanceof GroupSequenceProvider) {
  47.                 $metadata->setGroupSequenceProvider(true);
  48.             } elseif ($constraint instanceof Constraint) {
  49.                 $metadata->addConstraint($constraint);
  50.             }
  52.             $success = true;
  53.         }
  55.         foreach ($reflClass->getProperties() as $property) {
  56.             if ($property->getDeclaringClass()->name === $className) {
  57.                 foreach ($this->getAnnotations($property) as $constraint) {
  58.                     if ($constraint instanceof Constraint) {
  59.                         $metadata->addPropertyConstraint($property->name, $constraint);
  60.                     }
  62.                     $success = true;
  63.                 }
  64.             }
  65.         }
  67.         foreach ($reflClass->getMethods() as $method) {
  68.             if ($method->getDeclaringClass()->name === $className) {
  69.                 foreach ($this->getAnnotations($method) as $constraint) {
  70.                     if ($constraint instanceof Callback) {
  71.                         $constraint->callback = $method->getName();
  73.                         $metadata->addConstraint($constraint);
  74.                     } elseif ($constraint instanceof Constraint) {
  75.                         if (preg_match('/^(get|is|has)(.+)$/i', $method->name, $matches)) {
  76.                             $metadata->addGetterMethodConstraint(lcfirst($matches[2]), $matches[0], $constraint);
  77.                         } else {
  78.                             throw new MappingException(sprintf('The constraint on "%s::%s()" cannot be added. Constraints can only be added on methods beginning with "get", "is" or "has".', $className, $method->name));
  79.                         }
  80.                     }
  82.                     $success = true;
  83.                 }
  84.             }
  85.         }
  87.         return $success;
  88.     }
  90.     /**
  91.      * @param \ReflectionClass|\ReflectionMethod|\ReflectionProperty $reflection
  92.      */
  93.     private function getAnnotations(object $reflection): iterable
  94.     {
  95.         foreach ($reflection->getAttributes(GroupSequence::class) as $attribute) {
  96.             yield $attribute->newInstance();
  97.         }
  98.         foreach ($reflection->getAttributes(GroupSequenceProvider::class) as $attribute) {
  99.             yield $attribute->newInstance();
  100.         }
  101.         foreach ($reflection->getAttributes(Constraint::class, \ReflectionAttribute::IS_INSTANCEOF) as $attribute) {
  102.             yield $attribute->newInstance();
  103.         }
  104.         if (!$this->reader) {
  105.             return;
  106.         }
  108.         if ($reflection instanceof \ReflectionClass) {
  109.             yield from $this->reader->getClassAnnotations($reflection);
  110.         }
  111.         if ($reflection instanceof \ReflectionMethod) {
  112.             yield from $this->reader->getMethodAnnotations($reflection);
  113.         }
  114.         if ($reflection instanceof \ReflectionProperty) {
  115.             yield from $this->reader->getPropertyAnnotations($reflection);
  116.         }
  117.     }
  118. }