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

  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.     public function __construct(Environment $env)
  45.     {
  46.         $this->env = $env;
  47.         $this->extensions = $env->getExtensions();
  48.     }
  50.     /**
  51.      * Returns the template name.
  52.      *
  53.      * @return string The template name
  54.      */
  55.     abstract public function getTemplateName();
  57.     /**
  58.      * Returns debug information about the template.
  59.      *
  60.      * @return array Debug information
  61.      */
  62.     abstract public function getDebugInfo();
  64.     /**
  65.      * Returns information about the original template source code.
  66.      *
  67.      * @return Source
  68.      */
  69.     abstract public function getSourceContext();
  71.     /**
  72.      * Returns the parent template.
  73.      *
  74.      * This method is for internal use only and should never be called
  75.      * directly.
  76.      *
  77.      * @return Template|TemplateWrapper|false The parent template or false if there is no parent
  78.      */
  79.     public function getParent(array $context)
  80.     {
  81.         if (null !== $this->parent) {
  82.             return $this->parent;
  83.         }
  85.         try {
  86.             $parent = $this->doGetParent($context);
  88.             if (false === $parent) {
  89.                 return false;
  90.             }
  92.             if ($parent instanceof self || $parent instanceof TemplateWrapper) {
  93.                 return $this->parents[$parent->getSourceContext()->getName()] = $parent;
  94.             }
  96.             if (!isset($this->parents[$parent])) {
  97.                 $this->parents[$parent] = $this->loadTemplate($parent);
  98.             }
  99.         } catch (LoaderError $e) {
  100.             $e->setSourceContext(null);
  101.             $e->guess();
  103.             throw $e;
  104.         }
  106.         return $this->parents[$parent];
  107.     }
  109.     protected function doGetParent(array $context)
  110.     {
  111.         return false;
  112.     }
  114.     public function isTraitable()
  115.     {
  116.         return true;
  117.     }
  119.     /**
  120.      * Displays a parent block.
  121.      *
  122.      * This method is for internal use only and should never be called
  123.      * directly.
  124.      *
  125.      * @param string $name    The block name to display from the parent
  126.      * @param array  $context The context
  127.      * @param array  $blocks  The current set of blocks
  128.      */
  129.     public function displayParentBlock($name, array $context, array $blocks = [])
  130.     {
  131.         if (isset($this->traits[$name])) {
  132.             $this->traits[$name][0]->displayBlock($name, $context, $blocks, false);
  133.         } elseif (false !== $parent = $this->getParent($context)) {
  134.             $parent->displayBlock($name, $context, $blocks, false);
  135.         } else {
  136.             throw new RuntimeError(sprintf('The template has no parent and no traits defining the "%s" block.', $name), -1, $this->getSourceContext());
  137.         }
  138.     }
  140.     /**
  141.      * Displays a block.
  142.      *
  143.      * This method is for internal use only and should never be called
  144.      * directly.
  145.      *
  146.      * @param string $name      The block name to display
  147.      * @param array  $context   The context
  148.      * @param array  $blocks    The current set of blocks
  149.      * @param bool   $useBlocks Whether to use the current set of blocks
  150.      */
  151.     public function displayBlock($name, array $context, array $blocks = [], $useBlocks = true, self $templateContext = null)
  152.     {
  153.         if ($useBlocks && isset($blocks[$name])) {
  154.             $template = $blocks[$name][0];
  155.             $block = $blocks[$name][1];
  156.         } elseif (isset($this->blocks[$name])) {
  157.             $template = $this->blocks[$name][0];
  158.             $block = $this->blocks[$name][1];
  159.         } else {
  160.             $template = null;
  161.             $block = null;
  162.         }
  164.         // avoid RCEs when sandbox is enabled
  165.         if (null !== $template && !$template instanceof self) {
  166.             throw new \LogicException('A block must be a method on a \Twig\Template instance.');
  167.         }
  169.         if (null !== $template) {
  170.             try {
  171.                 $template->$block($context, $blocks);
  172.             } catch (Error $e) {
  173.                 if (!$e->getSourceContext()) {
  174.                     $e->setSourceContext($template->getSourceContext());
  175.                 }
  177.                 // this is mostly useful for \Twig\Error\LoaderError exceptions
  178.                 // see \Twig\Error\LoaderError
  179.                 if (-1 === $e->getTemplateLine()) {
  180.                     $e->guess();
  181.                 }
  183.                 throw $e;
  184.             } catch (\Exception $e) {
  185.                 $e = new RuntimeError(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $template->getSourceContext(), $e);
  186.                 $e->guess();
  188.                 throw $e;
  189.             }
  190.         } elseif (false !== $parent = $this->getParent($context)) {
  191.             $parent->displayBlock($name, $context, array_merge($this->blocks, $blocks), false, $templateContext ?? $this);
  192.         } elseif (isset($blocks[$name])) {
  193.             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());
  194.         } else {
  195.             throw new RuntimeError(sprintf('Block "%s" on template "%s" does not exist.', $name, $this->getTemplateName()), -1, ($templateContext ?? $this)->getSourceContext());
  196.         }
  197.     }
  199.     /**
  200.      * Renders a parent block.
  201.      *
  202.      * This method is for internal use only and should never be called
  203.      * directly.
  204.      *
  205.      * @param string $name    The block name to render from the parent
  206.      * @param array  $context The context
  207.      * @param array  $blocks  The current set of blocks
  208.      *
  209.      * @return string The rendered block
  210.      */
  211.     public function renderParentBlock($name, array $context, array $blocks = [])
  212.     {
  213.         if ($this->env->isDebug()) {
  214.             ob_start();
  215.         } else {
  216.             ob_start(function () { return ''; });
  217.         }
  218.         $this->displayParentBlock($name, $context, $blocks);
  220.         return ob_get_clean();
  221.     }
  223.     /**
  224.      * Renders a block.
  225.      *
  226.      * This method is for internal use only and should never be called
  227.      * directly.
  228.      *
  229.      * @param string $name      The block name to render
  230.      * @param array  $context   The context
  231.      * @param array  $blocks    The current set of blocks
  232.      * @param bool   $useBlocks Whether to use the current set of blocks
  233.      *
  234.      * @return string The rendered block
  235.      */
  236.     public function renderBlock($name, array $context, array $blocks = [], $useBlocks = true)
  237.     {
  238.         if ($this->env->isDebug()) {
  239.             ob_start();
  240.         } else {
  241.             ob_start(function () { return ''; });
  242.         }
  243.         $this->displayBlock($name, $context, $blocks, $useBlocks);
  245.         return ob_get_clean();
  246.     }
  248.     /**
  249.      * Returns whether a block exists or not in the current context of the template.
  250.      *
  251.      * This method checks blocks defined in the current template
  252.      * or defined in "used" traits or defined in parent templates.
  253.      *
  254.      * @param string $name    The block name
  255.      * @param array  $context The context
  256.      * @param array  $blocks  The current set of blocks
  257.      *
  258.      * @return bool true if the block exists, false otherwise
  259.      */
  260.     public function hasBlock($name, array $context, array $blocks = [])
  261.     {
  262.         if (isset($blocks[$name])) {
  263.             return $blocks[$name][0] instanceof self;
  264.         }
  266.         if (isset($this->blocks[$name])) {
  267.             return true;
  268.         }
  270.         if (false !== $parent = $this->getParent($context)) {
  271.             return $parent->hasBlock($name, $context);
  272.         }
  274.         return false;
  275.     }
  277.     /**
  278.      * Returns all block names in the current context of the template.
  279.      *
  280.      * This method checks blocks defined in the current template
  281.      * or defined in "used" traits or defined in parent templates.
  282.      *
  283.      * @param array $context The context
  284.      * @param array $blocks  The current set of blocks
  285.      *
  286.      * @return array An array of block names
  287.      */
  288.     public function getBlockNames(array $context, array $blocks = [])
  289.     {
  290.         $names = array_merge(array_keys($blocks), array_keys($this->blocks));
  292.         if (false !== $parent = $this->getParent($context)) {
  293.             $names = array_merge($names, $parent->getBlockNames($context));
  294.         }
  296.         return array_unique($names);
  297.     }
  299.     /**
  300.      * @return Template|TemplateWrapper
  301.      */
  302.     protected function loadTemplate($template, $templateName = null, $line = null, $index = null)
  303.     {
  304.         try {
  305.             if (\is_array($template)) {
  306.                 return $this->env->resolveTemplate($template);
  307.             }
  309.             if ($template instanceof self || $template instanceof TemplateWrapper) {
  310.                 return $template;
  311.             }
  313.             if ($template === $this->getTemplateName()) {
  314.                 $class = static::class;
  315.                 if (false !== $pos = strrpos($class, '___', -1)) {
  316.                     $class = substr($class, 0, $pos);
  317.                 }
  318.             } else {
  319.                 $class = $this->env->getTemplateClass($template);
  320.             }
  322.             return $this->env->loadTemplate($class, $template, $index);
  323.         } catch (Error $e) {
  324.             if (!$e->getSourceContext()) {
  325.                 $e->setSourceContext($templateName ? new Source('', $templateName) : $this->getSourceContext());
  326.             }
  328.             if ($e->getTemplateLine() > 0) {
  329.                 throw $e;
  330.             }
  332.             if (!$line) {
  333.                 $e->guess();
  334.             } else {
  335.                 $e->setTemplateLine($line);
  336.             }
  338.             throw $e;
  339.         }
  340.     }
  342.     /**
  343.      * @internal
  344.      *
  345.      * @return Template
  346.      */
  347.     public function unwrap()
  348.     {
  349.         return $this;
  350.     }
  352.     /**
  353.      * Returns all blocks.
  354.      *
  355.      * This method is for internal use only and should never be called
  356.      * directly.
  357.      *
  358.      * @return array An array of blocks
  359.      */
  360.     public function getBlocks()
  361.     {
  362.         return $this->blocks;
  363.     }
  365.     public function display(array $context, array $blocks = [])
  366.     {
  367.         $this->displayWithErrorHandling($this->env->mergeGlobals($context), array_merge($this->blocks, $blocks));
  368.     }
  370.     public function render(array $context)
  371.     {
  372.         $level = ob_get_level();
  373.         if ($this->env->isDebug()) {
  374.             ob_start();
  375.         } else {
  376.             ob_start(function () { return ''; });
  377.         }
  378.         try {
  379.             $this->display($context);
  380.         } catch (\Throwable $e) {
  381.             while (ob_get_level() > $level) {
  382.                 ob_end_clean();
  383.             }
  385.             throw $e;
  386.         }
  388.         return ob_get_clean();
  389.     }
  391.     protected function displayWithErrorHandling(array $context, array $blocks = [])
  392.     {
  393.         try {
  394.             $this->doDisplay($context, $blocks);
  395.         } catch (Error $e) {
  396.             if (!$e->getSourceContext()) {
  397.                 $e->setSourceContext($this->getSourceContext());
  398.             }
  400.             // this is mostly useful for \Twig\Error\LoaderError exceptions
  401.             // see \Twig\Error\LoaderError
  402.             if (-1 === $e->getTemplateLine()) {
  403.                 $e->guess();
  404.             }
  406.             throw $e;
  407.         } catch (\Exception $e) {
  408.             $e = new RuntimeError(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, $this->getSourceContext(), $e);
  409.             $e->guess();
  411.             throw $e;
  412.         }
  413.     }
  415.     /**
  416.      * Auto-generated method to display the template with the given context.
  417.      *
  418.      * @param array $context An array of parameters to pass to the template
  419.      * @param array $blocks  An array of blocks to pass to the template
  420.      */
  421.     abstract protected function doDisplay(array $context, array $blocks = []);
  422. }