vendor/symfony/twig-bridge/Form/TwigRendererEngine.php line 43

Open in your IDE?
  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\Bridge\Twig\Form;
  14. use Symfony\Component\Form\AbstractRendererEngine;
  15. use Symfony\Component\Form\FormView;
  16. use Twig\Environment;
  17. use Twig\Template;
  19. /**
  20.  * @author Bernhard Schussek <bschussek@gmail.com>
  21.  */
  22. class TwigRendererEngine extends AbstractRendererEngine
  23. {
  24.     /**
  25.      * @var Environment
  26.      */
  27.     private $environment;
  29.     /**
  30.      * @var Template
  31.      */
  32.     private $template;
  34.     public function __construct(array $defaultThemes, Environment $environment)
  35.     {
  36.         parent::__construct($defaultThemes);
  37.         $this->environment = $environment;
  38.     }
  40.     /**
  41.      * {@inheritdoc}
  42.      */
  43.     public function renderBlock(FormView $view, $resource, $blockName, array $variables = [])
  44.     {
  45.         $cacheKey = $view->vars[self::CACHE_KEY_VAR];
  47.         $context = $this->environment->mergeGlobals($variables);
  49.         ob_start();
  51.         // By contract,This method can only be called after getting the resource
  52.         // (which is passed to the method). Getting a resource for the first time
  53.         // (with an empty cache) is guaranteed to invoke loadResourcesFromTheme(),
  54.         // where the property $template is initialized.
  56.         // We do not call renderBlock here to avoid too many nested level calls
  57.         // (XDebug limits the level to 100 by default)
  58.         $this->template->displayBlock($blockName, $context, $this->resources[$cacheKey]);
  60.         return ob_get_clean();
  61.     }
  63.     /**
  64.      * Loads the cache with the resource for a given block name.
  65.      *
  66.      * This implementation eagerly loads all blocks of the themes assigned to the given view
  67.      * and all of its ancestors views. This is necessary, because Twig receives the
  68.      * list of blocks later. At that point, all blocks must already be loaded, for the
  69.      * case that the function "block()" is used in the Twig template.
  70.      *
  71.      * @see getResourceForBlock()
  72.      *
  73.      * @param string   $cacheKey  The cache key of the form view
  74.      * @param FormView $view      The form view for finding the applying themes
  75.      * @param string   $blockName The name of the block to load
  76.      *
  77.      * @return bool True if the resource could be loaded, false otherwise
  78.      */
  79.     protected function loadResourceForBlockName($cacheKey, FormView $view, $blockName)
  80.     {
  81.         // The caller guarantees that $this->resources[$cacheKey][$block] is
  82.         // not set, but it doesn't have to check whether $this->resources[$cacheKey]
  83.         // is set. If $this->resources[$cacheKey] is set, all themes for this
  84.         // $cacheKey are already loaded (due to the eager population, see doc comment).
  85.         if (isset($this->resources[$cacheKey])) {
  86.             // As said in the previous, the caller guarantees that
  87.             // $this->resources[$cacheKey][$block] is not set. Since the themes are
  88.             // already loaded, it can only be a non-existing block.
  89.             $this->resources[$cacheKey][$blockName] = false;
  91.             return false;
  92.         }
  94.         // Recursively try to find the block in the themes assigned to $view,
  95.         // then of its parent view, then of the parent view of the parent and so on.
  96.         // When the root view is reached in this recursion, also the default
  97.         // themes are taken into account.
  99.         // Check each theme whether it contains the searched block
  100.         if (isset($this->themes[$cacheKey])) {
  101.             for ($i = \count($this->themes[$cacheKey]) - 1; $i >= 0; --$i) {
  102.                 $this->loadResourcesFromTheme($cacheKey, $this->themes[$cacheKey][$i]);
  103.                 // CONTINUE LOADING (see doc comment)
  104.             }
  105.         }
  107.         // Check the default themes once we reach the root view without success
  108.         if (!$view->parent) {
  109.             if (!isset($this->useDefaultThemes[$cacheKey]) || $this->useDefaultThemes[$cacheKey]) {
  110.                 for ($i = \count($this->defaultThemes) - 1; $i >= 0; --$i) {
  111.                     $this->loadResourcesFromTheme($cacheKey, $this->defaultThemes[$i]);
  112.                     // CONTINUE LOADING (see doc comment)
  113.                 }
  114.             }
  115.         }
  117.         // Proceed with the themes of the parent view
  118.         if ($view->parent) {
  119.             $parentCacheKey = $view->parent->vars[self::CACHE_KEY_VAR];
  121.             if (!isset($this->resources[$parentCacheKey])) {
  122.                 $this->loadResourceForBlockName($parentCacheKey, $view->parent, $blockName);
  123.             }
  125.             // EAGER CACHE POPULATION (see doc comment)
  126.             foreach ($this->resources[$parentCacheKey] as $nestedBlockName => $resource) {
  127.                 if (!isset($this->resources[$cacheKey][$nestedBlockName])) {
  128.                     $this->resources[$cacheKey][$nestedBlockName] = $resource;
  129.                 }
  130.             }
  131.         }
  133.         // Even though we loaded the themes, it can happen that none of them
  134.         // contains the searched block
  135.         if (!isset($this->resources[$cacheKey][$blockName])) {
  136.             // Cache that we didn't find anything to speed up further accesses
  137.             $this->resources[$cacheKey][$blockName] = false;
  138.         }
  140.         return false !== $this->resources[$cacheKey][$blockName];
  141.     }
  143.     /**
  144.      * Loads the resources for all blocks in a theme.
  145.      *
  146.      * @param string $cacheKey The cache key for storing the resource
  147.      * @param mixed  $theme    The theme to load the block from. This parameter
  148.      *                         is passed by reference, because it might be necessary
  149.      *                         to initialize the theme first. Any changes made to
  150.      *                         this variable will be kept and be available upon
  151.      *                         further calls to this method using the same theme.
  152.      */
  153.     protected function loadResourcesFromTheme($cacheKey, &$theme)
  154.     {
  155.         if (!$theme instanceof Template) {
  156.             /* @var Template $theme */
  157.             $theme = $this->environment->load($theme)->unwrap();
  158.         }
  160.         if (null === $this->template) {
  161.             // Store the first Template instance that we find so that
  162.             // we can call displayBlock() later on. It doesn't matter *which*
  163.             // template we use for that, since we pass the used blocks manually
  164.             // anyway.
  165.             $this->template = $theme;
  166.         }
  168.         // Use a separate variable for the inheritance traversal, because
  169.         // theme is a reference and we don't want to change it.
  170.         $currentTheme = $theme;
  172.         $context = $this->environment->mergeGlobals([]);
  174.         // The do loop takes care of template inheritance.
  175.         // Add blocks from all templates in the inheritance tree, but avoid
  176.         // overriding blocks already set.
  177.         do {
  178.             foreach ($currentTheme->getBlocks() as $block => $blockData) {
  179.                 if (!isset($this->resources[$cacheKey][$block])) {
  180.                     // The resource given back is the key to the bucket that
  181.                     // contains this block.
  182.                     $this->resources[$cacheKey][$block] = $blockData;
  183.                 }
  184.             }
  185.         } while (false !== $currentTheme = $currentTheme->getParent($context));
  186.     }
  187. }