vendor/symfony/twig-bridge/TwigEngine.php line 113

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;
  14. @trigger_error('The '.TwigEngine::class.' class is deprecated since version 4.3 and will be removed in 5.0; use \Twig\Environment instead.', \E_USER_DEPRECATED);
  16. use Symfony\Component\Templating\EngineInterface;
  17. use Symfony\Component\Templating\StreamingEngineInterface;
  18. use Symfony\Component\Templating\TemplateNameParserInterface;
  19. use Symfony\Component\Templating\TemplateReferenceInterface;
  20. use Twig\Environment;
  21. use Twig\Error\Error;
  22. use Twig\Error\LoaderError;
  23. use Twig\Loader\ExistsLoaderInterface;
  24. use Twig\Loader\SourceContextLoaderInterface;
  25. use Twig\Template;
  27. /**
  28.  * This engine knows how to render Twig templates.
  29.  *
  30.  * @author Fabien Potencier <fabien@symfony.com>
  31.  *
  32.  * @deprecated since version 4.3, to be removed in 5.0; use Twig instead.
  33.  */
  34. class TwigEngine implements EngineInterface, StreamingEngineInterface
  35. {
  36.     protected $environment;
  37.     protected $parser;
  39.     public function __construct(Environment $environment, TemplateNameParserInterface $parser)
  40.     {
  41.         $this->environment = $environment;
  42.         $this->parser = $parser;
  43.     }
  45.     /**
  46.      * {@inheritdoc}
  47.      *
  48.      * It also supports Template as name parameter.
  49.      *
  50.      * @throws Error if something went wrong like a thrown exception while rendering the template
  51.      */
  52.     public function render($name, array $parameters = [])
  53.     {
  54.         return $this->load($name)->render($parameters);
  55.     }
  57.     /**
  58.      * {@inheritdoc}
  59.      *
  60.      * It also supports Template as name parameter.
  61.      *
  62.      * @throws Error if something went wrong like a thrown exception while rendering the template
  63.      */
  64.     public function stream($name, array $parameters = [])
  65.     {
  66.         $this->load($name)->display($parameters);
  67.     }
  69.     /**
  70.      * {@inheritdoc}
  71.      *
  72.      * It also supports Template as name parameter.
  73.      */
  74.     public function exists($name)
  75.     {
  76.         if ($name instanceof Template) {
  77.             return true;
  78.         }
  80.         $loader = $this->environment->getLoader();
  82.         if (1 === Environment::MAJOR_VERSION && !$loader instanceof ExistsLoaderInterface) {
  83.             try {
  84.                 // cast possible TemplateReferenceInterface to string because the
  85.                 // EngineInterface supports them but LoaderInterface does not
  86.                 if ($loader instanceof SourceContextLoaderInterface) {
  87.                     $loader->getSourceContext((string) $name);
  88.                 } else {
  89.                     $loader->getSource((string) $name);
  90.                 }
  92.                 return true;
  93.             } catch (LoaderError $e) {
  94.             }
  96.             return false;
  97.         }
  99.         return $loader->exists((string) $name);
  100.     }
  102.     /**
  103.      * {@inheritdoc}
  104.      *
  105.      * It also supports Template as name parameter.
  106.      */
  107.     public function supports($name)
  108.     {
  109.         if ($name instanceof Template) {
  110.             return true;
  111.         }
  113.         $template = $this->parser->parse($name);
  115.         return 'twig' === $template->get('engine');
  116.     }
  118.     /**
  119.      * Loads the given template.
  120.      *
  121.      * @param string|TemplateReferenceInterface|Template $name A template name or an instance of
  122.      *                                                         TemplateReferenceInterface or Template
  123.      *
  124.      * @return Template
  125.      *
  126.      * @throws \InvalidArgumentException if the template does not exist
  127.      */
  128.     protected function load($name)
  129.     {
  130.         if ($name instanceof Template) {
  131.             return $name;
  132.         }
  134.         try {
  135.             return $this->environment->load((string) $name)->unwrap();
  136.         } catch (LoaderError $e) {
  137.             throw new \InvalidArgumentException($e->getMessage(), $e->getCode(), $e);
  138.         }
  139.     }
  140. }