vendor/symfony/validator/Mapping/Loader/PropertyInfoLoader.php line 39

  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 Symfony\Component\PropertyInfo\PropertyAccessExtractorInterface;
  15. use Symfony\Component\PropertyInfo\PropertyListExtractorInterface;
  16. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  17. use Symfony\Component\PropertyInfo\Type as PropertyInfoType;
  18. use Symfony\Component\Validator\Constraints\All;
  19. use Symfony\Component\Validator\Constraints\NotBlank;
  20. use Symfony\Component\Validator\Constraints\NotNull;
  21. use Symfony\Component\Validator\Constraints\Type;
  22. use Symfony\Component\Validator\Mapping\AutoMappingStrategy;
  23. use Symfony\Component\Validator\Mapping\ClassMetadata;
  25. /**
  26.  * Guesses and loads the appropriate constraints using PropertyInfo.
  27.  *
  28.  * @author Kévin Dunglas <dunglas@gmail.com>
  29.  */
  30. final class PropertyInfoLoader implements LoaderInterface
  31. {
  32.     use AutoMappingTrait;
  34.     private PropertyListExtractorInterface $listExtractor;
  35.     private PropertyTypeExtractorInterface $typeExtractor;
  36.     private PropertyAccessExtractorInterface $accessExtractor;
  37.     private ?string $classValidatorRegexp;
  39.     public function __construct(PropertyListExtractorInterface $listExtractor, PropertyTypeExtractorInterface $typeExtractor, PropertyAccessExtractorInterface $accessExtractor, string $classValidatorRegexp = null)
  40.     {
  41.         $this->listExtractor = $listExtractor;
  42.         $this->typeExtractor = $typeExtractor;
  43.         $this->accessExtractor = $accessExtractor;
  44.         $this->classValidatorRegexp = $classValidatorRegexp;
  45.     }
  47.     public function loadClassMetadata(ClassMetadata $metadata): bool
  48.     {
  49.         $className = $metadata->getClassName();
  50.         if (!$properties = $this->listExtractor->getProperties($className)) {
  51.             return false;
  52.         }
  54.         $loaded = false;
  55.         $enabledForClass = $this->isAutoMappingEnabledForClass($metadata, $this->classValidatorRegexp);
  56.         foreach ($properties as $property) {
  57.             if (false === $this->accessExtractor->isWritable($className, $property)) {
  58.                 continue;
  59.             }
  61.             if (!property_exists($className, $property)) {
  62.                 continue;
  63.             }
  65.             $types = $this->typeExtractor->getTypes($className, $property);
  66.             if (null === $types) {
  67.                 continue;
  68.             }
  70.             $enabledForProperty = $enabledForClass;
  71.             $hasTypeConstraint = false;
  72.             $hasNotNullConstraint = false;
  73.             $hasNotBlankConstraint = false;
  74.             $allConstraint = null;
  75.             foreach ($metadata->getPropertyMetadata($property) as $propertyMetadata) {
  76.                 // Enabling or disabling auto-mapping explicitly always takes precedence
  77.                 if (AutoMappingStrategy::DISABLED === $propertyMetadata->getAutoMappingStrategy()) {
  78.                     continue 2;
  79.                 }
  81.                 if (AutoMappingStrategy::ENABLED === $propertyMetadata->getAutoMappingStrategy()) {
  82.                     $enabledForProperty = true;
  83.                 }
  85.                 foreach ($propertyMetadata->getConstraints() as $constraint) {
  86.                     if ($constraint instanceof Type) {
  87.                         $hasTypeConstraint = true;
  88.                     } elseif ($constraint instanceof NotNull) {
  89.                         $hasNotNullConstraint = true;
  90.                     } elseif ($constraint instanceof NotBlank) {
  91.                         $hasNotBlankConstraint = true;
  92.                     } elseif ($constraint instanceof All) {
  93.                         $allConstraint = $constraint;
  94.                     }
  95.                 }
  96.             }
  98.             if (!$enabledForProperty) {
  99.                 continue;
  100.             }
  102.             $loaded = true;
  103.             $builtinTypes = [];
  104.             $nullable = false;
  105.             $scalar = true;
  106.             foreach ($types as $type) {
  107.                 $builtinTypes[] = $type->getBuiltinType();
  109.                 if ($scalar && !\in_array($type->getBuiltinType(), [PropertyInfoType::BUILTIN_TYPE_INT, PropertyInfoType::BUILTIN_TYPE_FLOAT, PropertyInfoType::BUILTIN_TYPE_STRING, PropertyInfoType::BUILTIN_TYPE_BOOL], true)) {
  110.                     $scalar = false;
  111.                 }
  113.                 if (!$nullable && $type->isNullable()) {
  114.                     $nullable = true;
  115.                 }
  116.             }
  117.             if (!$hasTypeConstraint) {
  118.                 if (1 === \count($builtinTypes)) {
  119.                     if ($types[0]->isCollection() && \count($collectionValueType = $types[0]->getCollectionValueTypes()) > 0) {
  120.                         [$collectionValueType] = $collectionValueType;
  121.                         $this->handleAllConstraint($property, $allConstraint, $collectionValueType, $metadata);
  122.                     }
  124.                     $metadata->addPropertyConstraint($property, $this->getTypeConstraint($builtinTypes[0], $types[0]));
  125.                 } elseif ($scalar) {
  126.                     $metadata->addPropertyConstraint($property, new Type(['type' => 'scalar']));
  127.                 }
  128.             }
  130.             if (!$nullable && !$hasNotBlankConstraint && !$hasNotNullConstraint) {
  131.                 $metadata->addPropertyConstraint($property, new NotNull());
  132.             }
  133.         }
  135.         return $loaded;
  136.     }
  138.     private function getTypeConstraint(string $builtinType, PropertyInfoType $type): Type
  139.     {
  140.         if (PropertyInfoType::BUILTIN_TYPE_OBJECT === $builtinType && null !== $className = $type->getClassName()) {
  141.             return new Type(['type' => $className]);
  142.         }
  144.         return new Type(['type' => $builtinType]);
  145.     }
  147.     private function handleAllConstraint(string $property, ?All $allConstraint, PropertyInfoType $propertyInfoType, ClassMetadata $metadata)
  148.     {
  149.         $containsTypeConstraint = false;
  150.         $containsNotNullConstraint = false;
  151.         if (null !== $allConstraint) {
  152.             foreach ($allConstraint->constraints as $constraint) {
  153.                 if ($constraint instanceof Type) {
  154.                     $containsTypeConstraint = true;
  155.                 } elseif ($constraint instanceof NotNull) {
  156.                     $containsNotNullConstraint = true;
  157.                 }
  158.             }
  159.         }
  161.         $constraints = [];
  162.         if (!$containsNotNullConstraint && !$propertyInfoType->isNullable()) {
  163.             $constraints[] = new NotNull();
  164.         }
  166.         if (!$containsTypeConstraint) {
  167.             $constraints[] = $this->getTypeConstraint($propertyInfoType->getBuiltinType(), $propertyInfoType);
  168.         }
  170.         if (null === $allConstraint) {
  171.             $metadata->addPropertyConstraint($property, new All(['constraints' => $constraints]));
  172.         } else {
  173.             $allConstraint->constraints = array_merge($allConstraint->constraints, $constraints);
  174.         }
  175.     }
  176. }