vendor/sonata-project/core-bundle/src/CoreBundle/Form/Extension/DependencyInjectionExtension.php line 110

Open in your IDE?
  1. <?php
  3. declare(strict_types=1);
  5. /*
  6.  * This file is part of the Sonata Project package.
  7.  *
  8.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Sonata\CoreBundle\Form\Extension;
  16. use Symfony\Component\DependencyInjection\ContainerInterface;
  17. use Symfony\Component\Form\Exception\InvalidArgumentException;
  18. use Symfony\Component\Form\FormExtensionInterface;
  19. use Symfony\Component\Form\FormTypeGuesserChain;
  20. use Symfony\Component\Form\FormTypeGuesserInterface;
  21. use Symfony\Component\Form\FormTypeInterface;
  23. /**
  24.  * This proxy class help to keep BC code with < SF2.8 form behavior by restoring
  25.  * the type as a code and not as a class.
  26.  *
  27.  * @deprecated since 3.7, to be removed in 4.0, the form mapping feature should be disabled.
  28.  */
  29. class DependencyInjectionExtension implements FormExtensionInterface
  30. {
  31.     /**
  32.      * @var FormExtensionInterface
  33.      */
  34.     protected $extension;
  36.     /**
  37.      * @var array
  38.      */
  39.     protected $mappingTypes;
  41.     /**
  42.      * @var array
  43.      */
  44.     protected $extensionTypes;
  46.     /**
  47.      * @var ContainerInterface
  48.      */
  49.     private $container;
  51.     /**
  52.      * @var string[]
  53.      */
  54.     private $typeServiceIds;
  56.     /**
  57.      * @var string[]
  58.      */
  59.     private $typeExtensionServiceIds;
  61.     /**
  62.      * @var string[]
  63.      */
  64.     private $guesserServiceIds;
  66.     /**
  67.      * @var FormTypeGuesserInterface
  68.      */
  69.     private $guesser;
  71.     /**
  72.      * @var bool
  73.      */
  74.     private $guesserLoaded = false;
  76.     public function __construct(
  77.         ContainerInterface $container,
  78.         array $typeServiceIds,
  79.         array $typeExtensionServiceIds,
  80.         array $guesserServiceIds,
  81.         array $mappingTypes = [],
  82.         array $extensionTypes = []
  83.     ) {
  84.         $this->container = $container;
  85.         $this->typeServiceIds = $typeServiceIds;
  86.         $this->typeExtensionServiceIds = $typeExtensionServiceIds;
  87.         $this->guesserServiceIds = $guesserServiceIds;
  89.         $this->mappingTypes = $mappingTypes;
  90.         $this->mappingExtensionTypes = $extensionTypes;
  92.         $this->reverseMappingTypes = array_flip($mappingTypes);
  93.     }
  95.     public function getType($name)
  96.     {
  97.         // resolve code to FQCN
  98.         $name = self::findClass($this->mappingTypes, $name);
  100.         if (!isset($this->typeServiceIds[$name])) {
  101.             if (class_exists($name) && \in_array(FormTypeInterface::class, class_implements($name), true)) {
  102.                 return new $name();
  103.             }
  105.             throw new InvalidArgumentException(
  106.                 sprintf('The field type "%s" is not registered with the service container.', $name)
  107.             );
  108.         }
  110.         $type = $this->container->get($this->typeServiceIds[$name]);
  112.         if ($name !== \get_class($type) && (method_exists($type, 'getName') && $type->getName() !== $name)) {
  113.             throw new InvalidArgumentException(sprintf(
  114.                 'The type name specified for the service "%s" does not match the actual name.'
  115.                 .' Expected "%s", given "%s"',
  116.                 $this->typeServiceIds[$name],
  117.                 $name,
  118.                 \get_class($type)
  119.             ));
  120.         }
  122.         return $type;
  123.     }
  125.     public function hasType($name)
  126.     {
  127.         return isset($this->mappingTypes[$name]) || isset($this->typeServiceIds[$name]);
  128.     }
  130.     public function getTypeExtensions($name)
  131.     {
  132.         // lookup inside the extension mapping
  133.         $serviceIdx = [];
  135.         if (isset($this->reverseMappingTypes[$name])) {
  136.             $code = $this->reverseMappingTypes[$name];
  138.             if (isset($this->mappingExtensionTypes[$code])) {
  139.                 $serviceIdx = array_merge($serviceIdx, $this->mappingExtensionTypes[$code]);
  140.             }
  141.         }
  143.         $serviceIdx = array_unique(array_merge(isset($this->typeExtensionServiceIds[$name]) ? $this->typeExtensionServiceIds[$name] : [], $serviceIdx));
  145.         $extensions = [];
  146.         foreach ($serviceIdx as $serviceId) {
  147.             if ($this->container->has($serviceId)) {
  148.                 $extensions[] = $this->container->get($serviceId);
  149.             }
  150.         }
  152.         return $extensions;
  153.     }
  155.     public function hasTypeExtensions($name)
  156.     {
  157.         return isset($this->reverseMappingTypes[$name]) || isset($this->typeExtensionServiceIds[$name]);
  158.     }
  160.     public function getTypeGuesser()
  161.     {
  162.         if (!$this->guesserLoaded) {
  163.             $this->guesserLoaded = true;
  164.             $guessers = [];
  166.             foreach ($this->guesserServiceIds as $serviceId) {
  167.                 if ($this->container->has($serviceId)) {
  168.                     $guessers[] = $this->container->get($serviceId);
  169.                 }
  170.             }
  172.             if ($guessers) {
  173.                 $this->guesser = new FormTypeGuesserChain($guessers);
  174.             }
  175.         }
  177.         return $this->guesser;
  178.     }
  180.     /**
  181.      * @param string $type
  182.      *
  183.      * @return string
  184.      */
  185.     protected static function findClass($mapping, $type)
  186.     {
  187.         if (strpos($type, '\\')) {
  188.             return $type;
  189.         }
  191.         if (!isset($mapping[$type])) {
  192.             return $type;
  193.         }
  195.         return $mapping[$type];
  196.     }
  197. }