vendor/symfony/form/Extension/Validator/ValidatorTypeGuesser.php line 67

  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\Form\Extension\Validator;
  14. use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
  15. use Symfony\Component\Form\Extension\Core\Type\CollectionType;
  16. use Symfony\Component\Form\Extension\Core\Type\CountryType;
  17. use Symfony\Component\Form\Extension\Core\Type\CurrencyType;
  18. use Symfony\Component\Form\Extension\Core\Type\DateTimeType;
  19. use Symfony\Component\Form\Extension\Core\Type\DateType;
  20. use Symfony\Component\Form\Extension\Core\Type\EmailType;
  21. use Symfony\Component\Form\Extension\Core\Type\FileType;
  22. use Symfony\Component\Form\Extension\Core\Type\IntegerType;
  23. use Symfony\Component\Form\Extension\Core\Type\LanguageType;
  24. use Symfony\Component\Form\Extension\Core\Type\LocaleType;
  25. use Symfony\Component\Form\Extension\Core\Type\NumberType;
  26. use Symfony\Component\Form\Extension\Core\Type\TextType;
  27. use Symfony\Component\Form\Extension\Core\Type\TimeType;
  28. use Symfony\Component\Form\Extension\Core\Type\UrlType;
  29. use Symfony\Component\Form\FormTypeGuesserInterface;
  30. use Symfony\Component\Form\Guess\Guess;
  31. use Symfony\Component\Form\Guess\TypeGuess;
  32. use Symfony\Component\Form\Guess\ValueGuess;
  33. use Symfony\Component\Validator\Constraint;
  34. use Symfony\Component\Validator\Constraints\Count;
  35. use Symfony\Component\Validator\Constraints\Country;
  36. use Symfony\Component\Validator\Constraints\Currency;
  37. use Symfony\Component\Validator\Constraints\Date;
  38. use Symfony\Component\Validator\Constraints\DateTime;
  39. use Symfony\Component\Validator\Constraints\Email;
  40. use Symfony\Component\Validator\Constraints\File;
  41. use Symfony\Component\Validator\Constraints\Image;
  42. use Symfony\Component\Validator\Constraints\Ip;
  43. use Symfony\Component\Validator\Constraints\IsFalse;
  44. use Symfony\Component\Validator\Constraints\IsTrue;
  45. use Symfony\Component\Validator\Constraints\Language;
  46. use Symfony\Component\Validator\Constraints\Length;
  47. use Symfony\Component\Validator\Constraints\Locale;
  48. use Symfony\Component\Validator\Constraints\NotBlank;
  49. use Symfony\Component\Validator\Constraints\NotNull;
  50. use Symfony\Component\Validator\Constraints\Range;
  51. use Symfony\Component\Validator\Constraints\Regex;
  52. use Symfony\Component\Validator\Constraints\Time;
  53. use Symfony\Component\Validator\Constraints\Type;
  54. use Symfony\Component\Validator\Constraints\Url;
  55. use Symfony\Component\Validator\Mapping\ClassMetadataInterface;
  56. use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface;
  58. class ValidatorTypeGuesser implements FormTypeGuesserInterface
  59. {
  60.     private MetadataFactoryInterface $metadataFactory;
  62.     public function __construct(MetadataFactoryInterface $metadataFactory)
  63.     {
  64.         $this->metadataFactory = $metadataFactory;
  65.     }
  67.     public function guessType(string $class, string $property): ?TypeGuess
  68.     {
  69.         return $this->guess($class, $property, function (Constraint $constraint) {
  70.             return $this->guessTypeForConstraint($constraint);
  71.         });
  72.     }
  74.     public function guessRequired(string $class, string $property): ?ValueGuess
  75.     {
  76.         return $this->guess($class, $property, function (Constraint $constraint) {
  77.             return $this->guessRequiredForConstraint($constraint);
  78.         // If we don't find any constraint telling otherwise, we can assume
  79.         // that a field is not required (with LOW_CONFIDENCE)
  80.         }, false);
  81.     }
  83.     public function guessMaxLength(string $class, string $property): ?ValueGuess
  84.     {
  85.         return $this->guess($class, $property, function (Constraint $constraint) {
  86.             return $this->guessMaxLengthForConstraint($constraint);
  87.         });
  88.     }
  90.     public function guessPattern(string $class, string $property): ?ValueGuess
  91.     {
  92.         return $this->guess($class, $property, function (Constraint $constraint) {
  93.             return $this->guessPatternForConstraint($constraint);
  94.         });
  95.     }
  97.     /**
  98.      * Guesses a field class name for a given constraint.
  99.      */
  100.     public function guessTypeForConstraint(Constraint $constraint): ?TypeGuess
  101.     {
  102.         switch ($constraint::class) {
  103.             case Type::class:
  104.                 switch ($constraint->type) {
  105.                     case 'array':
  106.                         return new TypeGuess(CollectionType::class, [], Guess::MEDIUM_CONFIDENCE);
  107.                     case 'boolean':
  108.                     case 'bool':
  109.                         return new TypeGuess(CheckboxType::class, [], Guess::MEDIUM_CONFIDENCE);
  111.                     case 'double':
  112.                     case 'float':
  113.                     case 'numeric':
  114.                     case 'real':
  115.                         return new TypeGuess(NumberType::class, [], Guess::MEDIUM_CONFIDENCE);
  117.                     case 'integer':
  118.                     case 'int':
  119.                     case 'long':
  120.                         return new TypeGuess(IntegerType::class, [], Guess::MEDIUM_CONFIDENCE);
  122.                     case \DateTime::class:
  123.                     case '\DateTime':
  124.                         return new TypeGuess(DateType::class, [], Guess::MEDIUM_CONFIDENCE);
  126.                     case 'string':
  127.                         return new TypeGuess(TextType::class, [], Guess::LOW_CONFIDENCE);
  128.                 }
  129.                 break;
  131.             case Country::class:
  132.                 return new TypeGuess(CountryType::class, [], Guess::HIGH_CONFIDENCE);
  134.             case Currency::class:
  135.                 return new TypeGuess(CurrencyType::class, [], Guess::HIGH_CONFIDENCE);
  137.             case Date::class:
  138.                 return new TypeGuess(DateType::class, ['input' => 'string'], Guess::HIGH_CONFIDENCE);
  140.             case DateTime::class:
  141.                 return new TypeGuess(DateTimeType::class, ['input' => 'string'], Guess::HIGH_CONFIDENCE);
  143.             case Email::class:
  144.                 return new TypeGuess(EmailType::class, [], Guess::HIGH_CONFIDENCE);
  146.             case File::class:
  147.             case Image::class:
  148.                 $options = [];
  149.                 if ($constraint->mimeTypes) {
  150.                     $options = ['attr' => ['accept' => implode(',', (array) $constraint->mimeTypes)]];
  151.                 }
  153.                 return new TypeGuess(FileType::class, $options, Guess::HIGH_CONFIDENCE);
  155.             case Language::class:
  156.                 return new TypeGuess(LanguageType::class, [], Guess::HIGH_CONFIDENCE);
  158.             case Locale::class:
  159.                 return new TypeGuess(LocaleType::class, [], Guess::HIGH_CONFIDENCE);
  161.             case Time::class:
  162.                 return new TypeGuess(TimeType::class, ['input' => 'string'], Guess::HIGH_CONFIDENCE);
  164.             case Url::class:
  165.                 return new TypeGuess(UrlType::class, [], Guess::HIGH_CONFIDENCE);
  167.             case Ip::class:
  168.                 return new TypeGuess(TextType::class, [], Guess::MEDIUM_CONFIDENCE);
  170.             case Length::class:
  171.             case Regex::class:
  172.                 return new TypeGuess(TextType::class, [], Guess::LOW_CONFIDENCE);
  174.             case Range::class:
  175.                 return new TypeGuess(NumberType::class, [], Guess::LOW_CONFIDENCE);
  177.             case Count::class:
  178.                 return new TypeGuess(CollectionType::class, [], Guess::LOW_CONFIDENCE);
  180.             case IsTrue::class:
  181.             case IsFalse::class:
  182.                 return new TypeGuess(CheckboxType::class, [], Guess::MEDIUM_CONFIDENCE);
  183.         }
  185.         return null;
  186.     }
  188.     /**
  189.      * Guesses whether a field is required based on the given constraint.
  190.      */
  191.     public function guessRequiredForConstraint(Constraint $constraint): ?ValueGuess
  192.     {
  193.         return match ($constraint::class) {
  194.             NotNull::class,
  195.             NotBlank::class,
  196.             IsTrue::class => new ValueGuess(true, Guess::HIGH_CONFIDENCE),
  197.             default => null,
  198.         };
  199.     }
  201.     /**
  202.      * Guesses a field's maximum length based on the given constraint.
  203.      */
  204.     public function guessMaxLengthForConstraint(Constraint $constraint): ?ValueGuess
  205.     {
  206.         switch ($constraint::class) {
  207.             case Length::class:
  208.                 if (is_numeric($constraint->max)) {
  209.                     return new ValueGuess($constraint->max, Guess::HIGH_CONFIDENCE);
  210.                 }
  211.                 break;
  213.             case Type::class:
  214.                 if (\in_array($constraint->type, ['double', 'float', 'numeric', 'real'])) {
  215.                     return new ValueGuess(null, Guess::MEDIUM_CONFIDENCE);
  216.                 }
  217.                 break;
  219.             case Range::class:
  220.                 if (is_numeric($constraint->max)) {
  221.                     return new ValueGuess(\strlen((string) $constraint->max), Guess::LOW_CONFIDENCE);
  222.                 }
  223.                 break;
  224.         }
  226.         return null;
  227.     }
  229.     /**
  230.      * Guesses a field's pattern based on the given constraint.
  231.      */
  232.     public function guessPatternForConstraint(Constraint $constraint): ?ValueGuess
  233.     {
  234.         switch ($constraint::class) {
  235.             case Length::class:
  236.                 if (is_numeric($constraint->min)) {
  237.                     return new ValueGuess(sprintf('.{%s,}', (string) $constraint->min), Guess::LOW_CONFIDENCE);
  238.                 }
  239.                 break;
  241.             case Regex::class:
  242.                 $htmlPattern = $constraint->getHtmlPattern();
  244.                 if (null !== $htmlPattern) {
  245.                     return new ValueGuess($htmlPattern, Guess::HIGH_CONFIDENCE);
  246.                 }
  247.                 break;
  249.             case Range::class:
  250.                 if (is_numeric($constraint->min)) {
  251.                     return new ValueGuess(sprintf('.{%s,}', \strlen((string) $constraint->min)), Guess::LOW_CONFIDENCE);
  252.                 }
  253.                 break;
  255.             case Type::class:
  256.                 if (\in_array($constraint->type, ['double', 'float', 'numeric', 'real'])) {
  257.                     return new ValueGuess(null, Guess::MEDIUM_CONFIDENCE);
  258.                 }
  259.                 break;
  260.         }
  262.         return null;
  263.     }
  265.     /**
  266.      * Iterates over the constraints of a property, executes a constraints on
  267.      * them and returns the best guess.
  268.      *
  269.      * @param \Closure $closure      The closure that returns a guess
  270.      *                               for a given constraint
  271.      * @param mixed    $defaultValue The default value assumed if no other value
  272.      *                               can be guessed
  273.      */
  274.     protected function guess(string $class, string $property, \Closure $closure, mixed $defaultValue = null): ?Guess
  275.     {
  276.         $guesses = [];
  277.         $classMetadata = $this->metadataFactory->getMetadataFor($class);
  279.         if ($classMetadata instanceof ClassMetadataInterface && $classMetadata->hasPropertyMetadata($property)) {
  280.             foreach ($classMetadata->getPropertyMetadata($property) as $memberMetadata) {
  281.                 foreach ($memberMetadata->getConstraints() as $constraint) {
  282.                     if ($guess = $closure($constraint)) {
  283.                         $guesses[] = $guess;
  284.                     }
  285.                 }
  286.             }
  287.         }
  289.         if (null !== $defaultValue) {
  290.             $guesses[] = new ValueGuess($defaultValue, Guess::LOW_CONFIDENCE);
  291.         }
  293.         return Guess::getBestGuess($guesses);
  294.     }
  295. }