vendor/symfony/form/FormRenderer.php line 59

  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;
  14. use Symfony\Component\Form\Exception\BadMethodCallException;
  15. use Symfony\Component\Form\Exception\LogicException;
  16. use Symfony\Component\Security\Csrf\CsrfTokenManagerInterface;
  17. use Twig\Environment;
  19. /**
  20.  * Renders a form into HTML using a rendering engine.
  21.  *
  22.  * @author Bernhard Schussek <bschussek@gmail.com>
  23.  */
  24. class FormRenderer implements FormRendererInterface
  25. {
  26.     public const CACHE_KEY_VAR = 'unique_block_prefix';
  28.     private FormRendererEngineInterface $engine;
  29.     private ?CsrfTokenManagerInterface $csrfTokenManager;
  30.     private array $blockNameHierarchyMap = [];
  31.     private array $hierarchyLevelMap = [];
  32.     private array $variableStack = [];
  34.     public function __construct(FormRendererEngineInterface $engine, CsrfTokenManagerInterface $csrfTokenManager = null)
  35.     {
  36.         $this->engine = $engine;
  37.         $this->csrfTokenManager = $csrfTokenManager;
  38.     }
  40.     public function getEngine(): FormRendererEngineInterface
  41.     {
  42.         return $this->engine;
  43.     }
  45.     public function setTheme(FormView $view, mixed $themes, bool $useDefaultThemes = true)
  46.     {
  47.         $this->engine->setTheme($view, $themes, $useDefaultThemes);
  48.     }
  50.     public function renderCsrfToken(string $tokenId): string
  51.     {
  52.         if (null === $this->csrfTokenManager) {
  53.             throw new BadMethodCallException('CSRF tokens can only be generated if a CsrfTokenManagerInterface is injected in FormRenderer::__construct(). Try running "composer require symfony/security-csrf".');
  54.         }
  56.         return $this->csrfTokenManager->getToken($tokenId)->getValue();
  57.     }
  59.     public function renderBlock(FormView $view, string $blockName, array $variables = []): string
  60.     {
  61.         $resource = $this->engine->getResourceForBlockName($view, $blockName);
  63.         if (!$resource) {
  64.             throw new LogicException(sprintf('No block "%s" found while rendering the form.', $blockName));
  65.         }
  67.         $viewCacheKey = $view->vars[self::CACHE_KEY_VAR];
  69.         // The variables are cached globally for a view (instead of for the
  70.         // current suffix)
  71.         if (!isset($this->variableStack[$viewCacheKey])) {
  72.             $this->variableStack[$viewCacheKey] = [];
  74.             // The default variable scope contains all view variables, merged with
  75.             // the variables passed explicitly to the helper
  76.             $scopeVariables = $view->vars;
  78.             $varInit = true;
  79.         } else {
  80.             // Reuse the current scope and merge it with the explicitly passed variables
  81.             $scopeVariables = end($this->variableStack[$viewCacheKey]);
  83.             $varInit = false;
  84.         }
  86.         // Merge the passed with the existing attributes
  87.         if (isset($variables['attr']) && isset($scopeVariables['attr'])) {
  88.             $variables['attr'] = array_replace($scopeVariables['attr'], $variables['attr']);
  89.         }
  91.         // Merge the passed with the exist *label* attributes
  92.         if (isset($variables['label_attr']) && isset($scopeVariables['label_attr'])) {
  93.             $variables['label_attr'] = array_replace($scopeVariables['label_attr'], $variables['label_attr']);
  94.         }
  96.         // Do not use array_replace_recursive(), otherwise array variables
  97.         // cannot be overwritten
  98.         $variables = array_replace($scopeVariables, $variables);
  100.         $this->variableStack[$viewCacheKey][] = $variables;
  102.         // Do the rendering
  103.         $html = $this->engine->renderBlock($view, $resource, $blockName, $variables);
  105.         // Clear the stack
  106.         array_pop($this->variableStack[$viewCacheKey]);
  108.         if ($varInit) {
  109.             unset($this->variableStack[$viewCacheKey]);
  110.         }
  112.         return $html;
  113.     }
  115.     public function searchAndRenderBlock(FormView $view, string $blockNameSuffix, array $variables = []): string
  116.     {
  117.         $renderOnlyOnce = 'row' === $blockNameSuffix || 'widget' === $blockNameSuffix;
  119.         if ($renderOnlyOnce && $view->isRendered()) {
  120.             // This is not allowed, because it would result in rendering same IDs multiple times, which is not valid.
  121.             throw new BadMethodCallException(sprintf('Field "%s" has already been rendered, save the result of previous render call to a variable and output that instead.', $view->vars['name']));
  122.         }
  124.         // The cache key for storing the variables and types
  125.         $viewCacheKey = $view->vars[self::CACHE_KEY_VAR];
  126.         $viewAndSuffixCacheKey = $viewCacheKey.$blockNameSuffix;
  128.         // In templates, we have to deal with two kinds of block hierarchies:
  129.         //
  130.         //   +---------+          +---------+
  131.         //   | Theme B | -------> | Theme A |
  132.         //   +---------+          +---------+
  133.         //
  134.         //   form_widget -------> form_widget
  135.         //       ^
  136.         //       |
  137.         //  choice_widget -----> choice_widget
  138.         //
  139.         // The first kind of hierarchy is the theme hierarchy. This allows to
  140.         // override the block "choice_widget" from Theme A in the extending
  141.         // Theme B. This kind of inheritance needs to be supported by the
  142.         // template engine and, for example, offers "parent()" or similar
  143.         // functions to fall back from the custom to the parent implementation.
  144.         //
  145.         // The second kind of hierarchy is the form type hierarchy. This allows
  146.         // to implement a custom "choice_widget" block (no matter in which theme),
  147.         // or to fallback to the block of the parent type, which would be
  148.         // "form_widget" in this example (again, no matter in which theme).
  149.         // If the designer wants to explicitly fallback to "form_widget" in their
  150.         // custom "choice_widget", for example because they only want to wrap
  151.         // a <div> around the original implementation, they can call the
  152.         // widget() function again to render the block for the parent type.
  153.         //
  154.         // The second kind is implemented in the following blocks.
  155.         if (!isset($this->blockNameHierarchyMap[$viewAndSuffixCacheKey])) {
  156.             // INITIAL CALL
  157.             // Calculate the hierarchy of template blocks and start on
  158.             // the bottom level of the hierarchy (= "_<id>_<section>" block)
  159.             $blockNameHierarchy = [];
  160.             foreach ($view->vars['block_prefixes'] as $blockNamePrefix) {
  161.                 $blockNameHierarchy[] = $blockNamePrefix.'_'.$blockNameSuffix;
  162.             }
  163.             $hierarchyLevel = \count($blockNameHierarchy) - 1;
  165.             $hierarchyInit = true;
  166.         } else {
  167.             // RECURSIVE CALL
  168.             // If a block recursively calls searchAndRenderBlock() again, resume rendering
  169.             // using the parent type in the hierarchy.
  170.             $blockNameHierarchy = $this->blockNameHierarchyMap[$viewAndSuffixCacheKey];
  171.             $hierarchyLevel = $this->hierarchyLevelMap[$viewAndSuffixCacheKey] - 1;
  173.             $hierarchyInit = false;
  174.         }
  176.         // The variables are cached globally for a view (instead of for the
  177.         // current suffix)
  178.         if (!isset($this->variableStack[$viewCacheKey])) {
  179.             $this->variableStack[$viewCacheKey] = [];
  181.             // The default variable scope contains all view variables, merged with
  182.             // the variables passed explicitly to the helper
  183.             $scopeVariables = $view->vars;
  185.             $varInit = true;
  186.         } else {
  187.             // Reuse the current scope and merge it with the explicitly passed variables
  188.             $scopeVariables = end($this->variableStack[$viewCacheKey]);
  190.             $varInit = false;
  191.         }
  193.         // Load the resource where this block can be found
  194.         $resource = $this->engine->getResourceForBlockNameHierarchy($view, $blockNameHierarchy, $hierarchyLevel);
  196.         // Update the current hierarchy level to the one at which the resource was
  197.         // found. For example, if looking for "choice_widget", but only a resource
  198.         // is found for its parent "form_widget", then the level is updated here
  199.         // to the parent level.
  200.         $hierarchyLevel = $this->engine->getResourceHierarchyLevel($view, $blockNameHierarchy, $hierarchyLevel);
  202.         // The actually existing block name in $resource
  203.         $blockName = $blockNameHierarchy[$hierarchyLevel];
  205.         // Escape if no resource exists for this block
  206.         if (!$resource) {
  207.             if (\count($blockNameHierarchy) !== \count(array_unique($blockNameHierarchy))) {
  208.                 throw new LogicException(sprintf('Unable to render the form because the block names array contains duplicates: "%s".', implode('", "', array_reverse($blockNameHierarchy))));
  209.             }
  211.             throw new LogicException(sprintf('Unable to render the form as none of the following blocks exist: "%s".', implode('", "', array_reverse($blockNameHierarchy))));
  212.         }
  214.         // Merge the passed with the existing attributes
  215.         if (isset($variables['attr']) && isset($scopeVariables['attr'])) {
  216.             $variables['attr'] = array_replace($scopeVariables['attr'], $variables['attr']);
  217.         }
  219.         // Merge the passed with the exist *label* attributes
  220.         if (isset($variables['label_attr']) && isset($scopeVariables['label_attr'])) {
  221.             $variables['label_attr'] = array_replace($scopeVariables['label_attr'], $variables['label_attr']);
  222.         }
  224.         // Do not use array_replace_recursive(), otherwise array variables
  225.         // cannot be overwritten
  226.         $variables = array_replace($scopeVariables, $variables);
  228.         // In order to make recursive calls possible, we need to store the block hierarchy,
  229.         // the current level of the hierarchy and the variables so that this method can
  230.         // resume rendering one level higher of the hierarchy when it is called recursively.
  231.         //
  232.         // We need to store these values in maps (associative arrays) because within a
  233.         // call to widget() another call to widget() can be made, but for a different view
  234.         // object. These nested calls should not override each other.
  235.         $this->blockNameHierarchyMap[$viewAndSuffixCacheKey] = $blockNameHierarchy;
  236.         $this->hierarchyLevelMap[$viewAndSuffixCacheKey] = $hierarchyLevel;
  238.         // We also need to store the variables for the view so that we can render other
  239.         // blocks for the same view using the same variables as in the outer block.
  240.         $this->variableStack[$viewCacheKey][] = $variables;
  242.         // Do the rendering
  243.         $html = $this->engine->renderBlock($view, $resource, $blockName, $variables);
  245.         // Clear the stack
  246.         array_pop($this->variableStack[$viewCacheKey]);
  248.         // Clear the caches if they were filled for the first time within
  249.         // this function call
  250.         if ($hierarchyInit) {
  251.             unset($this->blockNameHierarchyMap[$viewAndSuffixCacheKey], $this->hierarchyLevelMap[$viewAndSuffixCacheKey]);
  252.         }
  254.         if ($varInit) {
  255.             unset($this->variableStack[$viewCacheKey]);
  256.         }
  258.         if ($renderOnlyOnce) {
  259.             $view->setRendered();
  260.         }
  262.         return $html;
  263.     }
  265.     public function humanize(string $text): string
  266.     {
  267.         return ucfirst(strtolower(trim(preg_replace(['/([A-Z])/', '/[_\s]+/'], ['_$1', ' '], $text))));
  268.     }
  270.     /**
  271.      * @internal
  272.      */
  273.     public function encodeCurrency(Environment $environment, string $text, string $widget = ''): string
  274.     {
  275.         if ('UTF-8' === $charset = $environment->getCharset()) {
  276.             $text = htmlspecialchars($text, \ENT_QUOTES | \ENT_SUBSTITUTE, 'UTF-8');
  277.         } else {
  278.             $text = htmlentities($text, \ENT_QUOTES | \ENT_SUBSTITUTE, 'UTF-8');
  279.             $text = iconv('UTF-8', $charset, $text);
  280.             $widget = iconv('UTF-8', $charset, $widget);
  281.         }
  283.         return str_replace('{{ widget }}', $widget, $text);
  284.     }
  285. }