vendor/symfony/validator/ValidatorBuilder.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;
  14. use Doctrine\Common\Annotations\AnnotationReader;
  15. use Doctrine\Common\Annotations\PsrCachedReader;
  16. use Doctrine\Common\Annotations\Reader;
  17. use Psr\Cache\CacheItemPoolInterface;
  18. use Symfony\Component\Cache\Adapter\ArrayAdapter;
  19. use Symfony\Component\Validator\Context\ExecutionContextFactory;
  20. use Symfony\Component\Validator\Exception\LogicException;
  21. use Symfony\Component\Validator\Exception\ValidatorException;
  22. use Symfony\Component\Validator\Mapping\Factory\LazyLoadingMetadataFactory;
  23. use Symfony\Component\Validator\Mapping\Factory\MetadataFactoryInterface;
  24. use Symfony\Component\Validator\Mapping\Loader\AnnotationLoader;
  25. use Symfony\Component\Validator\Mapping\Loader\LoaderChain;
  26. use Symfony\Component\Validator\Mapping\Loader\LoaderInterface;
  27. use Symfony\Component\Validator\Mapping\Loader\StaticMethodLoader;
  28. use Symfony\Component\Validator\Mapping\Loader\XmlFileLoader;
  29. use Symfony\Component\Validator\Mapping\Loader\YamlFileLoader;
  30. use Symfony\Component\Validator\Validator\RecursiveValidator;
  31. use Symfony\Component\Validator\Validator\ValidatorInterface;
  32. use Symfony\Contracts\Translation\LocaleAwareInterface;
  33. use Symfony\Contracts\Translation\TranslatorInterface;
  34. use Symfony\Contracts\Translation\TranslatorTrait;
  36. // Help opcache.preload discover always-needed symbols
  37. class_exists(TranslatorInterface::class);
  38. class_exists(LocaleAwareInterface::class);
  39. class_exists(TranslatorTrait::class);
  41. /**
  42.  * @author Bernhard Schussek <bschussek@gmail.com>
  43.  */
  44. class ValidatorBuilder
  45. {
  46.     private array $initializers = [];
  47.     private array $loaders = [];
  48.     private array $xmlMappings = [];
  49.     private array $yamlMappings = [];
  50.     private array $methodMappings = [];
  51.     private ?Reader $annotationReader = null;
  52.     private bool $enableAnnotationMapping = false;
  53.     private ?MetadataFactoryInterface $metadataFactory = null;
  54.     private ConstraintValidatorFactoryInterface $validatorFactory;
  55.     private ?CacheItemPoolInterface $mappingCache = null;
  56.     private ?TranslatorInterface $translator = null;
  57.     private ?string $translationDomain = null;
  59.     /**
  60.      * Adds an object initializer to the validator.
  61.      *
  62.      * @return $this
  63.      */
  64.     public function addObjectInitializer(ObjectInitializerInterface $initializer): static
  65.     {
  66.         $this->initializers[] = $initializer;
  68.         return $this;
  69.     }
  71.     /**
  72.      * Adds a list of object initializers to the validator.
  73.      *
  74.      * @param ObjectInitializerInterface[] $initializers
  75.      *
  76.      * @return $this
  77.      */
  78.     public function addObjectInitializers(array $initializers): static
  79.     {
  80.         $this->initializers = array_merge($this->initializers, $initializers);
  82.         return $this;
  83.     }
  85.     /**
  86.      * Adds an XML constraint mapping file to the validator.
  87.      *
  88.      * @return $this
  89.      */
  90.     public function addXmlMapping(string $path): static
  91.     {
  92.         if (null !== $this->metadataFactory) {
  93.             throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.');
  94.         }
  96.         $this->xmlMappings[] = $path;
  98.         return $this;
  99.     }
  101.     /**
  102.      * Adds a list of XML constraint mapping files to the validator.
  103.      *
  104.      * @param string[] $paths The paths to the mapping files
  105.      *
  106.      * @return $this
  107.      */
  108.     public function addXmlMappings(array $paths): static
  109.     {
  110.         if (null !== $this->metadataFactory) {
  111.             throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.');
  112.         }
  114.         $this->xmlMappings = array_merge($this->xmlMappings, $paths);
  116.         return $this;
  117.     }
  119.     /**
  120.      * Adds a YAML constraint mapping file to the validator.
  121.      *
  122.      * @param string $path The path to the mapping file
  123.      *
  124.      * @return $this
  125.      */
  126.     public function addYamlMapping(string $path): static
  127.     {
  128.         if (null !== $this->metadataFactory) {
  129.             throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.');
  130.         }
  132.         $this->yamlMappings[] = $path;
  134.         return $this;
  135.     }
  137.     /**
  138.      * Adds a list of YAML constraint mappings file to the validator.
  139.      *
  140.      * @param string[] $paths The paths to the mapping files
  141.      *
  142.      * @return $this
  143.      */
  144.     public function addYamlMappings(array $paths): static
  145.     {
  146.         if (null !== $this->metadataFactory) {
  147.             throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.');
  148.         }
  150.         $this->yamlMappings = array_merge($this->yamlMappings, $paths);
  152.         return $this;
  153.     }
  155.     /**
  156.      * Enables constraint mapping using the given static method.
  157.      *
  158.      * @return $this
  159.      */
  160.     public function addMethodMapping(string $methodName): static
  161.     {
  162.         if (null !== $this->metadataFactory) {
  163.             throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.');
  164.         }
  166.         $this->methodMappings[] = $methodName;
  168.         return $this;
  169.     }
  171.     /**
  172.      * Enables constraint mapping using the given static methods.
  173.      *
  174.      * @param string[] $methodNames The names of the methods
  175.      *
  176.      * @return $this
  177.      */
  178.     public function addMethodMappings(array $methodNames): static
  179.     {
  180.         if (null !== $this->metadataFactory) {
  181.             throw new ValidatorException('You cannot add custom mappings after setting a custom metadata factory. Configure your metadata factory instead.');
  182.         }
  184.         $this->methodMappings = array_merge($this->methodMappings, $methodNames);
  186.         return $this;
  187.     }
  189.     /**
  190.      * Enables annotation based constraint mapping.
  191.      *
  192.      * @return $this
  193.      */
  194.     public function enableAnnotationMapping(): static
  195.     {
  196.         if (null !== $this->metadataFactory) {
  197.             throw new ValidatorException('You cannot enable annotation mapping after setting a custom metadata factory. Configure your metadata factory instead.');
  198.         }
  200.         $this->enableAnnotationMapping = true;
  202.         return $this;
  203.     }
  205.     /**
  206.      * Disables annotation based constraint mapping.
  207.      *
  208.      * @return $this
  209.      */
  210.     public function disableAnnotationMapping(): static
  211.     {
  212.         $this->enableAnnotationMapping = false;
  213.         $this->annotationReader = null;
  215.         return $this;
  216.     }
  218.     /**
  219.      * @return $this
  220.      */
  221.     public function setDoctrineAnnotationReader(?Reader $reader): static
  222.     {
  223.         $this->annotationReader = $reader;
  225.         return $this;
  226.     }
  228.     /**
  229.      * @return $this
  230.      */
  231.     public function addDefaultDoctrineAnnotationReader(): static
  232.     {
  233.         $this->annotationReader = $this->createAnnotationReader();
  235.         return $this;
  236.     }
  238.     /**
  239.      * Sets the class metadata factory used by the validator.
  240.      *
  241.      * @return $this
  242.      */
  243.     public function setMetadataFactory(MetadataFactoryInterface $metadataFactory): static
  244.     {
  245.         if (\count($this->xmlMappings) > 0 || \count($this->yamlMappings) > 0 || \count($this->methodMappings) > 0 || $this->enableAnnotationMapping) {
  246.             throw new ValidatorException('You cannot set a custom metadata factory after adding custom mappings. You should do either of both.');
  247.         }
  249.         $this->metadataFactory = $metadataFactory;
  251.         return $this;
  252.     }
  254.     /**
  255.      * Sets the cache for caching class metadata.
  256.      *
  257.      * @return $this
  258.      */
  259.     public function setMappingCache(CacheItemPoolInterface $cache): static
  260.     {
  261.         if (null !== $this->metadataFactory) {
  262.             throw new ValidatorException('You cannot set a custom mapping cache after setting a custom metadata factory. Configure your metadata factory instead.');
  263.         }
  265.         $this->mappingCache = $cache;
  267.         return $this;
  268.     }
  270.     /**
  271.      * Sets the constraint validator factory used by the validator.
  272.      *
  273.      * @return $this
  274.      */
  275.     public function setConstraintValidatorFactory(ConstraintValidatorFactoryInterface $validatorFactory): static
  276.     {
  277.         $this->validatorFactory = $validatorFactory;
  279.         return $this;
  280.     }
  282.     /**
  283.      * Sets the translator used for translating violation messages.
  284.      *
  285.      * @return $this
  286.      */
  287.     public function setTranslator(TranslatorInterface $translator): static
  288.     {
  289.         $this->translator = $translator;
  291.         return $this;
  292.     }
  294.     /**
  295.      * Sets the default translation domain of violation messages.
  296.      *
  297.      * The same message can have different translations in different domains.
  298.      * Pass the domain that is used for violation messages by default to this
  299.      * method.
  300.      *
  301.      * @return $this
  302.      */
  303.     public function setTranslationDomain(?string $translationDomain): static
  304.     {
  305.         $this->translationDomain = $translationDomain;
  307.         return $this;
  308.     }
  310.     /**
  311.      * @return $this
  312.      */
  313.     public function addLoader(LoaderInterface $loader): static
  314.     {
  315.         $this->loaders[] = $loader;
  317.         return $this;
  318.     }
  320.     /**
  321.      * @return LoaderInterface[]
  322.      */
  323.     public function getLoaders(): array
  324.     {
  325.         $loaders = [];
  327.         foreach ($this->xmlMappings as $xmlMapping) {
  328.             $loaders[] = new XmlFileLoader($xmlMapping);
  329.         }
  331.         foreach ($this->yamlMappings as $yamlMappings) {
  332.             $loaders[] = new YamlFileLoader($yamlMappings);
  333.         }
  335.         foreach ($this->methodMappings as $methodName) {
  336.             $loaders[] = new StaticMethodLoader($methodName);
  337.         }
  339.         if ($this->enableAnnotationMapping) {
  340.             $loaders[] = new AnnotationLoader($this->annotationReader);
  341.         }
  343.         return array_merge($loaders, $this->loaders);
  344.     }
  346.     /**
  347.      * Builds and returns a new validator object.
  348.      */
  349.     public function getValidator(): ValidatorInterface
  350.     {
  351.         $metadataFactory = $this->metadataFactory;
  353.         if (!$metadataFactory) {
  354.             $loaders = $this->getLoaders();
  355.             $loader = null;
  357.             if (\count($loaders) > 1) {
  358.                 $loader = new LoaderChain($loaders);
  359.             } elseif (1 === \count($loaders)) {
  360.                 $loader = $loaders[0];
  361.             }
  363.             $metadataFactory = new LazyLoadingMetadataFactory($loader, $this->mappingCache);
  364.         }
  366.         $validatorFactory = $this->validatorFactory ?? new ConstraintValidatorFactory();
  367.         $translator = $this->translator;
  369.         if (null === $translator) {
  370.             $translator = new class() implements TranslatorInterface, LocaleAwareInterface {
  371.                 use TranslatorTrait;
  372.             };
  373.             // Force the locale to be 'en' when no translator is provided rather than relying on the Intl default locale
  374.             // This avoids depending on Intl or the stub implementation being available. It also ensures that Symfony
  375.             // validation messages are pluralized properly even when the default locale gets changed because they are in
  376.             // English.
  377.             $translator->setLocale('en');
  378.         }
  380.         $contextFactory = new ExecutionContextFactory($translator, $this->translationDomain);
  382.         return new RecursiveValidator($contextFactory, $metadataFactory, $validatorFactory, $this->initializers);
  383.     }
  385.     private function createAnnotationReader(): Reader
  386.     {
  387.         if (!class_exists(AnnotationReader::class)) {
  388.             throw new LogicException('Enabling annotation based constraint mapping requires the packages doctrine/annotations and symfony/cache to be installed.');
  389.         }
  391.         if (class_exists(ArrayAdapter::class)) {
  392.             return new PsrCachedReader(new AnnotationReader(), new ArrayAdapter());
  393.         }
  395.         throw new LogicException('Enabling annotation based constraint mapping requires the packages doctrine/annotations and symfony/cache to be installed.');
  396.     }
  397. }