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

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Sonata Project package.
  5.  *
  6.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  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 Sonata\CoreBundle\Form\Extension;
  14. use Symfony\Component\DependencyInjection\ContainerInterface;
  15. use Symfony\Component\Form\Exception\InvalidArgumentException;
  16. use Symfony\Component\Form\FormExtensionInterface;
  17. use Symfony\Component\Form\FormTypeGuesserChain;
  18. use Symfony\Component\Form\FormTypeGuesserInterface;
  19. use Symfony\Component\Form\FormTypeInterface;
  21. /**
  22.  * This proxy class help to keep BC code with < SF2.8 form behavior by restoring
  23.  * the type as a code and not as a class.
  24.  *
  25.  * @deprecated since 3.7, to be removed in 4.0, the form mapping feature should be disabled.
  26.  */
  27. class DependencyInjectionExtension implements FormExtensionInterface
  28. {
  29.     /**
  30.      * @var FormExtensionInterface
  31.      */
  32.     protected $extension;
  34.     /**
  35.      * @var array
  36.      */
  37.     protected $mappingTypes;
  39.     /**
  40.      * @var array
  41.      */
  42.     protected $extensionTypes;
  44.     /**
  45.      * @var ContainerInterface
  46.      */
  47.     private $container;
  49.     /**
  50.      * @var string[]
  51.      */
  52.     private $typeServiceIds;
  54.     /**
  55.      * @var string[]
  56.      */
  57.     private $typeExtensionServiceIds;
  59.     /**
  60.      * @var string[]
  61.      */
  62.     private $guesserServiceIds;
  64.     /**
  65.      * @var FormTypeGuesserInterface
  66.      */
  67.     private $guesser;
  69.     /**
  70.      * @var bool
  71.      */
  72.     private $guesserLoaded = false;
  74.     public function __construct(
  75.         ContainerInterface $container,
  76.         array $typeServiceIds,
  77.         array $typeExtensionServiceIds,
  78.         array $guesserServiceIds,
  79.         array $mappingTypes = [],
  80.         array $extensionTypes = []
  81.     ) {
  82.         $this->container = $container;
  83.         $this->typeServiceIds = $typeServiceIds;
  84.         $this->typeExtensionServiceIds = $typeExtensionServiceIds;
  85.         $this->guesserServiceIds = $guesserServiceIds;
  87.         $this->mappingTypes = $mappingTypes;
  88.         $this->mappingExtensionTypes = $extensionTypes;
  90.         $this->reverseMappingTypes = array_flip($mappingTypes);
  91.     }
  93.     public function getType($name)
  94.     {
  95.         // resolve code to FQCN
  96.         $name = self::findClass($this->mappingTypes, $name);
  98.         if (!isset($this->typeServiceIds[$name])) {
  99.             if (class_exists($name) && \in_array(FormTypeInterface::class, class_implements($name), true)) {
  100.                 return new $name();
  101.             }
  103.             throw new InvalidArgumentException(
  104.                 sprintf('The field type "%s" is not registered with the service container.', $name)
  105.             );
  106.         }
  108.         $type = $this->container->get($this->typeServiceIds[$name]);
  110.         if ($name !== \get_class($type) && (method_exists($type, 'getName') && $type->getName() !== $name)) {
  111.             throw new InvalidArgumentException(sprintf(
  112.                 'The type name specified for the service "%s" does not match the actual name.'
  113.                 .' Expected "%s", given "%s"',
  114.                 $this->typeServiceIds[$name],
  115.                 $name,
  116.                 \get_class($type)
  117.             ));
  118.         }
  120.         return $type;
  121.     }
  123.     public function hasType($name)
  124.     {
  125.         return isset($this->mappingTypes[$name]) || isset($this->typeServiceIds[$name]);
  126.     }
  128.     public function getTypeExtensions($name)
  129.     {
  130.         // lookup inside the extension mapping
  131.         $serviceIdx = [];
  133.         if (isset($this->reverseMappingTypes[$name])) {
  134.             $code = $this->reverseMappingTypes[$name];
  136.             if (isset($this->mappingExtensionTypes[$code])) {
  137.                 $serviceIdx = array_merge($serviceIdx, $this->mappingExtensionTypes[$code]);
  138.             }
  139.         }
  141.         $serviceIdx = array_unique(array_merge(isset($this->typeExtensionServiceIds[$name]) ? $this->typeExtensionServiceIds[$name] : [], $serviceIdx));
  143.         $extensions = [];
  144.         foreach ($serviceIdx as $serviceId) {
  145.             if ($this->container->has($serviceId)) {
  146.                 $extensions[] = $this->container->get($serviceId);
  147.             }
  148.         }
  150.         return $extensions;
  151.     }
  153.     public function hasTypeExtensions($name)
  154.     {
  155.         return isset($this->reverseMappingTypes[$name]) || isset($this->typeExtensionServiceIds[$name]);
  156.     }
  158.     public function getTypeGuesser()
  159.     {
  160.         if (!$this->guesserLoaded) {
  161.             $this->guesserLoaded = true;
  162.             $guessers = [];
  164.             foreach ($this->guesserServiceIds as $serviceId) {
  165.                 if ($this->container->has($serviceId)) {
  166.                     $guessers[] = $this->container->get($serviceId);
  167.                 }
  168.             }
  170.             if ($guessers) {
  171.                 $this->guesser = new FormTypeGuesserChain($guessers);
  172.             }
  173.         }
  175.         return $this->guesser;
  176.     }
  178.     /**
  179.      * @param string $type
  180.      *
  181.      * @return string
  182.      */
  183.     protected static function findClass($mapping, $type)
  184.     {
  185.         if (strpos($type, '\\')) {
  186.             return $type;
  187.         }
  189.         if (!isset($mapping[$type])) {
  190.             return $type;
  191.         }
  193.         return $mapping[$type];
  194.     }
  195. }