vendor/twig/twig/src/Template.php line 430

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  7.  * (c) Armin Ronacher
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Twig;
  15. use Twig\Error\Error;
  16. use Twig\Error\LoaderError;
  17. use Twig\Error\RuntimeError;
  19. /**
  20.  * Default base class for compiled templates.
  21.  *
  22.  * This class is an implementation detail of how template compilation currently
  23.  * works, which might change. It should never be used directly. Use $twig->load()
  24.  * instead, which returns an instance of \Twig\TemplateWrapper.
  25.  *
  26.  * @author Fabien Potencier <fabien@symfony.com>
  27.  *
  28.  * @internal
  29.  */
  30. abstract class Template
  31. {
  32.     public const ANY_CALL = 'any';
  33.     public const ARRAY_CALL = 'array';
  34.     public const METHOD_CALL = 'method';
  36.     protected $parent;
  37.     protected $parents = [];
  38.     protected $env;
  39.     protected $blocks = [];
  40.     protected $traits = [];
  41.     protected $extensions = [];
  42.     protected $sandbox;
  44.     private $useYield;
  46.     public function __construct(Environment $env)
  47.     {
  48.         $this->env = $env;
  49.         $this->useYield = $env->useYield();
  50.         $this->extensions = $env->getExtensions();
  51.     }
  53.     /**
  54.      * Returns the template name.
  55.      *
  56.      * @return string The template name
  57.      */
  58.     abstract public function getTemplateName();
  60.     /**
  61.      * Returns debug information about the template.
  62.      *
  63.      * @return array Debug information
  64.      */
  65.     abstract public function getDebugInfo();
  67.     /**
  68.      * Returns information about the original template source code.
  69.      *
  70.      * @return Source
  71.      */
  72.     abstract public function getSourceContext();
  74.     /**
  75.      * Returns the parent template.
  76.      *
  77.      * This method is for internal use only and should never be called
  78.      * directly.
  79.      *
  80.      * @return self|TemplateWrapper|false The parent template or false if there is no parent
  81.      */
  82.     public function getParent(array $context)
  83.     {
  84.         if (null !== $this->parent) {
  85.             return $this->parent;
  86.         }
  88.         try {
  89.             if (!$parent = $this->doGetParent($context)) {
  90.                 return false;
  91.             }
  93.             if ($parent instanceof self || $parent instanceof TemplateWrapper) {
  94.                 return $this->parents[$parent->getSourceContext()->getName()] = $parent;
  95.             }
  97.             if (!isset($this->parents[$parent])) {
  98.                 $this->parents[$parent] = $this->loadTemplate($parent);
  99.             }
  100.         } catch (LoaderError $e) {
  101.             $e->setSourceContext(null);
  102.             $e->guess();
  104.             throw $e;
  105.         }
  107.         return $this->parents[$parent];
  108.     }
  110.     protected function doGetParent(array $context)
  111.     {
  112.         return false;
  113.     }
  115.     public function isTraitable()
  116.     {
  117.         return true;
  118.     }
  120.     /**
  121.      * Displays a parent block.
  122.      *
  123.      * This method is for internal use only and should never be called
  124.      * directly.
  125.      *
  126.      * @param string $name    The block name to display from the parent
  127.      * @param array  $context The context
  128.      * @param array  $blocks  The current set of blocks
  129.      */
  130.     public function displayParentBlock($name, array $context, array $blocks = [])
  131.     {
  132.         foreach ($this->yieldParentBlock($name, $context, $blocks) as $data) {
  133.             echo $data;
  134.         }
  135.     }
  137.     /**
  138.      * Displays a block.
  139.      *
  140.      * This method is for internal use only and should never be called
  141.      * directly.
  142.      *
  143.      * @param string $name      The block name to display
  144.      * @param array  $context   The context
  145.      * @param array  $blocks    The current set of blocks
  146.      * @param bool   $useBlocks Whether to use the current set of blocks
  147.      */
  148.     public function displayBlock($name, array $context, array $blocks = [], $useBlocks = true, ?self $templateContext = null)
  149.     {
  150.         foreach ($this->yieldBlock($name, $context, $blocks, $useBlocks, $templateContext) as $data) {
  151.             echo $data;
  152.         }
  153.     }
  155.     /**
  156.      * Renders a parent block.
  157.      *
  158.      * This method is for internal use only and should never be called
  159.      * directly.
  160.      *
  161.      * @param string $name    The block name to render from the parent
  162.      * @param array  $context The context
  163.      * @param array  $blocks  The current set of blocks
  164.      *
  165.      * @return string The rendered block
  166.      */
  167.     public function renderParentBlock($name, array $context, array $blocks = [])
  168.     {
  169.         $content = '';
  170.         foreach ($this->yieldParentBlock($name, $context, $blocks) as $data) {
  171.             $content .= $data;
  172.         }
  174.         return $content;
  175.     }
  177.     /**
  178.      * Renders a block.
  179.      *
  180.      * This method is for internal use only and should never be called
  181.      * directly.
  182.      *
  183.      * @param string $name      The block name to render
  184.      * @param array  $context   The context
  185.      * @param array  $blocks    The current set of blocks
  186.      * @param bool   $useBlocks Whether to use the current set of blocks
  187.      *
  188.      * @return string The rendered block
  189.      */
  190.     public function renderBlock($name, array $context, array $blocks = [], $useBlocks = true)
  191.     {
  192.         $content = '';
  193.         foreach ($this->yieldBlock($name, $context, $blocks, $useBlocks) as $data) {
  194.             $content .= $data;
  195.         }
  197.         return $content;
  198.     }
  200.     /**
  201.      * Returns whether a block exists or not in the current context of the template.
  202.      *
  203.      * This method checks blocks defined in the current template
  204.      * or defined in "used" traits or defined in parent templates.
  205.      *
  206.      * @param string $name    The block name
  207.      * @param array  $context The context
  208.      * @param array  $blocks  The current set of blocks
  209.      *
  210.      * @return bool true if the block exists, false otherwise
  211.      */
  212.     public function hasBlock($name, array $context, array $blocks = [])
  213.     {
  214.         if (isset($blocks[$name])) {
  215.             return $blocks[$name][0] instanceof self;
  216.         }
  218.         if (isset($this->blocks[$name])) {
  219.             return true;
  220.         }
  222.         if ($parent = $this->getParent($context)) {
  223.             return $parent->hasBlock($name, $context);
  224.         }
  226.         return false;
  227.     }
  229.     /**
  230.      * Returns all block names in the current context of the template.
  231.      *
  232.      * This method checks blocks defined in the current template
  233.      * or defined in "used" traits or defined in parent templates.
  234.      *
  235.      * @param array $context The context
  236.      * @param array $blocks  The current set of blocks
  237.      *
  238.      * @return array An array of block names
  239.      */
  240.     public function getBlockNames(array $context, array $blocks = [])
  241.     {
  242.         $names = array_merge(array_keys($blocks), array_keys($this->blocks));
  244.         if ($parent = $this->getParent($context)) {
  245.             $names = array_merge($names, $parent->getBlockNames($context));
  246.         }
  248.         return array_unique($names);
  249.     }
  251.     /**
  252.      * @param string|TemplateWrapper|array<string|TemplateWrapper> $template
  253.      *
  254.      * @return self|TemplateWrapper
  255.      */
  256.     protected function loadTemplate($template, $templateName = null, $line = null, $index = null)
  257.     {
  258.         try {
  259.             if (\is_array($template)) {
  260.                 return $this->env->resolveTemplate($template);
  261.             }
  263.             if ($template instanceof TemplateWrapper) {
  264.                 return $template;
  265.             }
  267.             if ($template instanceof self) {
  268.                 trigger_deprecation('twig/twig', '3.9', 'Passing a "%s" instance to "%s" is deprecated.', self::class, __METHOD__);
  270.                 return $template;
  271.             }
  273.             if ($template === $this->getTemplateName()) {
  274.                 $class = static::class;
  275.                 if (false !== $pos = strrpos($class, '___', -1)) {
  276.                     $class = substr($class, 0, $pos);
  277.                 }
  278.             } else {
  279.                 $class = $this->env->getTemplateClass($template);
  280.             }
  282.             return $this->env->loadTemplate($class, $template, $index);
  283.         } catch (Error $e) {
  284.             if (!$e->getSourceContext()) {
  285.                 $e->setSourceContext($templateName ? new Source('', $templateName) : $this->getSourceContext());
  286.             }
  288.             if ($e->getTemplateLine() > 0) {
  289.                 throw $e;
  290.             }
  292.             if (!$line) {
  293.                 $e->guess();
  294.             } else {
  295.                 $e->setTemplateLine($line);
  296.             }
  298.             throw $e;
  299.         }
  300.     }
  302.     /**
  303.      * @internal
  304.      *
  305.      * @return self
  306.      */
  307.     public function unwrap()
  308.     {
  309.         return $this;
  310.     }
  312.     /**
  313.      * Returns all blocks.
  314.      *
  315.      * This method is for internal use only and should never be called
  316.      * directly.
  317.      *
  318.      * @return array An array of blocks
  319.      */
  320.     public function getBlocks()
  321.     {
  322.         return $this->blocks;
  323.     }
  325.     public function display(array $context, array $blocks = []): void
  326.     {
  327.         foreach ($this->yield($context, $blocks) as $data) {
  328.             echo $data;
  329.         }
  330.     }
  332.     public function render(array $context): string
  333.     {
  334.         $content = '';
  335.         foreach ($this->yield($context) as $data) {
  336.             $content .= $data;
  337.         }
  339.         return $content;
  340.     }
  342.     /**
  343.      * @return iterable<string>
  344.      */
  345.     public function yield(array $context, array $blocks = []): iterable
  346.     {
  347.         $context = $this->env->mergeGlobals($context);
  348.         $blocks = array_merge($this->blocks, $blocks);
  350.         try {
  351.             if ($this->useYield) {
  352.                 yield from $this->doDisplay($context, $blocks);
  354.                 return;
  355.             }
  357.             $level = ob_get_level();
  358.             ob_start();
  360.             foreach ($this->doDisplay($context, $blocks) as $data) {
  361.                 if (ob_get_length()) {
  362.                     $data = ob_get_clean().$data;
  363.                     ob_start();
  364.                 }
  366.                 yield $data;
  367.             }
  369.             if (ob_get_length()) {
  370.                 yield ob_get_clean();
  371.             }
  372.         } catch (Error $e) {
  373.             if (!$e->getSourceContext()) {
  374.                 $e->setSourceContext($this->getSourceContext());
  375.             }
  377.             // this is mostly useful for \Twig\Error\LoaderError exceptions
  378.             // see \Twig\Error\LoaderError
  379.             if (-1 === $e->getTemplateLine()) {
  380.                 $e->guess();
  381.             }
  383.             throw $e;
  384.         } catch (\Throwable $e) {
  385.             $e = new RuntimeError(\sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $this->getSourceContext(), $e);
  386.             $e->guess();
  388.             throw $e;
  389.         } finally {
  390.             if (!$this->useYield) {
  391.                 while (ob_get_level() > $level) {
  392.                     ob_end_clean();
  393.                 }
  394.             }
  395.         }
  396.     }
  398.     /**
  399.      * @return iterable<string>
  400.      */
  401.     public function yieldBlock($name, array $context, array $blocks = [], $useBlocks = true, ?self $templateContext = null)
  402.     {
  403.         if ($useBlocks && isset($blocks[$name])) {
  404.             $template = $blocks[$name][0];
  405.             $block = $blocks[$name][1];
  406.         } elseif (isset($this->blocks[$name])) {
  407.             $template = $this->blocks[$name][0];
  408.             $block = $this->blocks[$name][1];
  409.         } else {
  410.             $template = null;
  411.             $block = null;
  412.         }
  414.         // avoid RCEs when sandbox is enabled
  415.         if (null !== $template && !$template instanceof self) {
  416.             throw new \LogicException('A block must be a method on a \Twig\Template instance.');
  417.         }
  419.         if (null !== $template) {
  420.             try {
  421.                 if ($this->useYield) {
  422.                     yield from $template->$block($context, $blocks);
  424.                     return;
  425.                 }
  427.                 $level = ob_get_level();
  428.                 ob_start();
  430.                 foreach ($template->$block($context, $blocks) as $data) {
  431.                     if (ob_get_length()) {
  432.                         $data = ob_get_clean().$data;
  433.                         ob_start();
  434.                     }
  436.                     yield $data;
  437.                 }
  439.                 if (ob_get_length()) {
  440.                     yield ob_get_clean();
  441.                 }
  442.             } catch (Error $e) {
  443.                 if (!$e->getSourceContext()) {
  444.                     $e->setSourceContext($template->getSourceContext());
  445.                 }
  447.                 // this is mostly useful for \Twig\Error\LoaderError exceptions
  448.                 // see \Twig\Error\LoaderError
  449.                 if (-1 === $e->getTemplateLine()) {
  450.                     $e->guess();
  451.                 }
  453.                 throw $e;
  454.             } catch (\Throwable $e) {
  455.                 $e = new RuntimeError(\sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $template->getSourceContext(), $e);
  456.                 $e->guess();
  458.                 throw $e;
  459.             } finally {
  460.                 if (!$this->useYield) {
  461.                     while (ob_get_level() > $level) {
  462.                         ob_end_clean();
  463.                     }
  464.                 }
  465.             }
  466.         } elseif ($parent = $this->getParent($context)) {
  467.             yield from $parent->unwrap()->yieldBlock($name, $context, array_merge($this->blocks, $blocks), false, $templateContext ?? $this);
  468.         } elseif (isset($blocks[$name])) {
  469.             throw new RuntimeError(\sprintf('Block "%s" should not call parent() in "%s" as the block does not exist in the parent template "%s".', $name, $blocks[$name][0]->getTemplateName(), $this->getTemplateName()), -1, $blocks[$name][0]->getSourceContext());
  470.         } else {
  471.             throw new RuntimeError(\sprintf('Block "%s" on template "%s" does not exist.', $name, $this->getTemplateName()), -1, ($templateContext ?? $this)->getSourceContext());
  472.         }
  473.     }
  475.     /**
  476.      * Yields a parent block.
  477.      *
  478.      * This method is for internal use only and should never be called
  479.      * directly.
  480.      *
  481.      * @param string $name    The block name to display from the parent
  482.      * @param array  $context The context
  483.      * @param array  $blocks  The current set of blocks
  484.      *
  485.      * @return iterable<string>
  486.      */
  487.     public function yieldParentBlock($name, array $context, array $blocks = [])
  488.     {
  489.         if (isset($this->traits[$name])) {
  490.             yield from $this->traits[$name][0]->yieldBlock($name, $context, $blocks, false);
  491.         } elseif ($parent = $this->getParent($context)) {
  492.             yield from $parent->unwrap()->yieldBlock($name, $context, $blocks, false);
  493.         } else {
  494.             throw new RuntimeError(\sprintf('The template has no parent and no traits defining the "%s" block.', $name), -1, $this->getSourceContext());
  495.         }
  496.     }
  498.     /**
  499.      * Auto-generated method to display the template with the given context.
  500.      *
  501.      * @param array $context An array of parameters to pass to the template
  502.      * @param array $blocks  An array of blocks to pass to the template
  503.      */
  504.     abstract protected function doDisplay(array $context, array $blocks = []);
  505. }