vendor/twig/twig/src/Environment.php line 318

  1. <?php
  3. /*
  4.  * This file is part of Twig.
  5.  *
  6.  * (c) Fabien Potencier
  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 Twig;
  14. use Twig\Cache\CacheInterface;
  15. use Twig\Cache\FilesystemCache;
  16. use Twig\Cache\NullCache;
  17. use Twig\Error\Error;
  18. use Twig\Error\LoaderError;
  19. use Twig\Error\RuntimeError;
  20. use Twig\Error\SyntaxError;
  21. use Twig\Extension\CoreExtension;
  22. use Twig\Extension\EscaperExtension;
  23. use Twig\Extension\ExtensionInterface;
  24. use Twig\Extension\OptimizerExtension;
  25. use Twig\Loader\ArrayLoader;
  26. use Twig\Loader\ChainLoader;
  27. use Twig\Loader\LoaderInterface;
  28. use Twig\Node\ModuleNode;
  29. use Twig\Node\Node;
  30. use Twig\NodeVisitor\NodeVisitorInterface;
  31. use Twig\RuntimeLoader\RuntimeLoaderInterface;
  32. use Twig\TokenParser\TokenParserInterface;
  34. /**
  35.  * Stores the Twig configuration and renders templates.
  36.  *
  37.  * @author Fabien Potencier <fabien@symfony.com>
  38.  */
  39. class Environment
  40. {
  41.     public const VERSION = '2.16.1';
  42.     public const VERSION_ID = 21601;
  43.     public const MAJOR_VERSION = 2;
  44.     public const MINOR_VERSION = 16;
  45.     public const RELEASE_VERSION = 1;
  46.     public const EXTRA_VERSION = '';
  48.     private $charset;
  49.     private $loader;
  50.     private $debug;
  51.     private $autoReload;
  52.     private $cache;
  53.     private $lexer;
  54.     private $parser;
  55.     private $compiler;
  56.     private $baseTemplateClass;
  57.     private $globals = [];
  58.     private $resolvedGlobals;
  59.     private $loadedTemplates;
  60.     private $strictVariables;
  61.     private $templateClassPrefix = '__TwigTemplate_';
  62.     private $originalCache;
  63.     private $extensionSet;
  64.     private $runtimeLoaders = [];
  65.     private $runtimes = [];
  66.     private $optionsHash;
  68.     /**
  69.      * Constructor.
  70.      *
  71.      * Available options:
  72.      *
  73.      *  * debug: When set to true, it automatically set "auto_reload" to true as
  74.      *           well (default to false).
  75.      *
  76.      *  * charset: The charset used by the templates (default to UTF-8).
  77.      *
  78.      *  * base_template_class: The base template class to use for generated
  79.      *                         templates (default to \Twig\Template).
  80.      *
  81.      *  * cache: An absolute path where to store the compiled templates,
  82.      *           a \Twig\Cache\CacheInterface implementation,
  83.      *           or false to disable compilation cache (default).
  84.      *
  85.      *  * auto_reload: Whether to reload the template if the original source changed.
  86.      *                 If you don't provide the auto_reload option, it will be
  87.      *                 determined automatically based on the debug value.
  88.      *
  89.      *  * strict_variables: Whether to ignore invalid variables in templates
  90.      *                      (default to false).
  91.      *
  92.      *  * autoescape: Whether to enable auto-escaping (default to html):
  93.      *                  * false: disable auto-escaping
  94.      *                  * html, js: set the autoescaping to one of the supported strategies
  95.      *                  * name: set the autoescaping strategy based on the template name extension
  96.      *                  * PHP callback: a PHP callback that returns an escaping strategy based on the template "name"
  97.      *
  98.      *  * optimizations: A flag that indicates which optimizations to apply
  99.      *                   (default to -1 which means that all optimizations are enabled;
  100.      *                   set it to 0 to disable).
  101.      */
  102.     public function __construct(LoaderInterface $loader, $options = [])
  103.     {
  104.         $this->setLoader($loader);
  106.         $options = array_merge([
  107.             'debug' => false,
  108.             'charset' => 'UTF-8',
  109.             'base_template_class' => Template::class,
  110.             'strict_variables' => false,
  111.             'autoescape' => 'html',
  112.             'cache' => false,
  113.             'auto_reload' => null,
  114.             'optimizations' => -1,
  115.         ], $options);
  117.         $this->debug = (bool) $options['debug'];
  118.         $this->setCharset($options['charset']);
  119.         $this->baseTemplateClass = '\\'.ltrim($options['base_template_class'], '\\');
  120.         if ('\\'.Template::class !== $this->baseTemplateClass && '\Twig_Template' !== $this->baseTemplateClass) {
  121.             @trigger_error('The "base_template_class" option on '.__CLASS__.' is deprecated since Twig 2.7.0.', \E_USER_DEPRECATED);
  122.         }
  123.         $this->autoReload = null === $options['auto_reload'] ? $this->debug : (bool) $options['auto_reload'];
  124.         $this->strictVariables = (bool) $options['strict_variables'];
  125.         $this->setCache($options['cache']);
  126.         $this->extensionSet = new ExtensionSet();
  128.         $this->addExtension(new CoreExtension());
  129.         $this->addExtension(new EscaperExtension($options['autoescape']));
  130.         $this->addExtension(new OptimizerExtension($options['optimizations']));
  131.     }
  133.     /**
  134.      * Gets the base template class for compiled templates.
  135.      *
  136.      * @return string The base template class name
  137.      */
  138.     public function getBaseTemplateClass()
  139.     {
  140.         if (1 > \func_num_args() || \func_get_arg(0)) {
  141.             @trigger_error('The '.__METHOD__.' is deprecated since Twig 2.7.0.', \E_USER_DEPRECATED);
  142.         }
  144.         return $this->baseTemplateClass;
  145.     }
  147.     /**
  148.      * Sets the base template class for compiled templates.
  149.      *
  150.      * @param string $class The base template class name
  151.      */
  152.     public function setBaseTemplateClass($class)
  153.     {
  154.         @trigger_error('The '.__METHOD__.' is deprecated since Twig 2.7.0.', \E_USER_DEPRECATED);
  156.         $this->baseTemplateClass = $class;
  157.         $this->updateOptionsHash();
  158.     }
  160.     /**
  161.      * Enables debugging mode.
  162.      */
  163.     public function enableDebug()
  164.     {
  165.         $this->debug = true;
  166.         $this->updateOptionsHash();
  167.     }
  169.     /**
  170.      * Disables debugging mode.
  171.      */
  172.     public function disableDebug()
  173.     {
  174.         $this->debug = false;
  175.         $this->updateOptionsHash();
  176.     }
  178.     /**
  179.      * Checks if debug mode is enabled.
  180.      *
  181.      * @return bool true if debug mode is enabled, false otherwise
  182.      */
  183.     public function isDebug()
  184.     {
  185.         return $this->debug;
  186.     }
  188.     /**
  189.      * Enables the auto_reload option.
  190.      */
  191.     public function enableAutoReload()
  192.     {
  193.         $this->autoReload = true;
  194.     }
  196.     /**
  197.      * Disables the auto_reload option.
  198.      */
  199.     public function disableAutoReload()
  200.     {
  201.         $this->autoReload = false;
  202.     }
  204.     /**
  205.      * Checks if the auto_reload option is enabled.
  206.      *
  207.      * @return bool true if auto_reload is enabled, false otherwise
  208.      */
  209.     public function isAutoReload()
  210.     {
  211.         return $this->autoReload;
  212.     }
  214.     /**
  215.      * Enables the strict_variables option.
  216.      */
  217.     public function enableStrictVariables()
  218.     {
  219.         $this->strictVariables = true;
  220.         $this->updateOptionsHash();
  221.     }
  223.     /**
  224.      * Disables the strict_variables option.
  225.      */
  226.     public function disableStrictVariables()
  227.     {
  228.         $this->strictVariables = false;
  229.         $this->updateOptionsHash();
  230.     }
  232.     /**
  233.      * Checks if the strict_variables option is enabled.
  234.      *
  235.      * @return bool true if strict_variables is enabled, false otherwise
  236.      */
  237.     public function isStrictVariables()
  238.     {
  239.         return $this->strictVariables;
  240.     }
  242.     /**
  243.      * Gets the current cache implementation.
  244.      *
  245.      * @param bool $original Whether to return the original cache option or the real cache instance
  246.      *
  247.      * @return CacheInterface|string|false A Twig\Cache\CacheInterface implementation,
  248.      *                                     an absolute path to the compiled templates,
  249.      *                                     or false to disable cache
  250.      */
  251.     public function getCache($original = true)
  252.     {
  253.         return $original ? $this->originalCache : $this->cache;
  254.     }
  256.     /**
  257.      * Sets the current cache implementation.
  258.      *
  259.      * @param CacheInterface|string|false $cache A Twig\Cache\CacheInterface implementation,
  260.      *                                           an absolute path to the compiled templates,
  261.      *                                           or false to disable cache
  262.      */
  263.     public function setCache($cache)
  264.     {
  265.         if (\is_string($cache)) {
  266.             $this->originalCache = $cache;
  267.             $this->cache = new FilesystemCache($cache, $this->autoReload ? FilesystemCache::FORCE_BYTECODE_INVALIDATION : 0);
  268.         } elseif (false === $cache) {
  269.             $this->originalCache = $cache;
  270.             $this->cache = new NullCache();
  271.         } elseif ($cache instanceof CacheInterface) {
  272.             $this->originalCache = $this->cache = $cache;
  273.         } else {
  274.             throw new \LogicException('Cache can only be a string, false, or a \Twig\Cache\CacheInterface implementation.');
  275.         }
  276.     }
  278.     /**
  279.      * Gets the template class associated with the given string.
  280.      *
  281.      * The generated template class is based on the following parameters:
  282.      *
  283.      *  * The cache key for the given template;
  284.      *  * The currently enabled extensions;
  285.      *  * Whether the Twig C extension is available or not;
  286.      *  * PHP version;
  287.      *  * Twig version;
  288.      *  * Options with what environment was created.
  289.      *
  290.      * @param string   $name  The name for which to calculate the template class name
  291.      * @param int|null $index The index if it is an embedded template
  292.      *
  293.      * @return string The template class name
  294.      *
  295.      * @internal
  296.      */
  297.     public function getTemplateClass($name, $index = null)
  298.     {
  299.         $key = $this->getLoader()->getCacheKey($name).$this->optionsHash;
  301.         return $this->templateClassPrefix.hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $key).(null === $index ? '' : '___'.$index);
  302.     }
  304.     /**
  305.      * Renders a template.
  306.      *
  307.      * @param string|TemplateWrapper $name    The template name
  308.      * @param array                  $context An array of parameters to pass to the template
  309.      *
  310.      * @return string The rendered template
  311.      *
  312.      * @throws LoaderError  When the template cannot be found
  313.      * @throws SyntaxError  When an error occurred during compilation
  314.      * @throws RuntimeError When an error occurred during rendering
  315.      */
  316.     public function render($name, array $context = [])
  317.     {
  318.         return $this->load($name)->render($context);
  319.     }
  321.     /**
  322.      * Displays a template.
  323.      *
  324.      * @param string|TemplateWrapper $name    The template name
  325.      * @param array                  $context An array of parameters to pass to the template
  326.      *
  327.      * @throws LoaderError  When the template cannot be found
  328.      * @throws SyntaxError  When an error occurred during compilation
  329.      * @throws RuntimeError When an error occurred during rendering
  330.      */
  331.     public function display($name, array $context = [])
  332.     {
  333.         $this->load($name)->display($context);
  334.     }
  336.     /**
  337.      * Loads a template.
  338.      *
  339.      * @param string|TemplateWrapper $name The template name
  340.      *
  341.      * @throws LoaderError  When the template cannot be found
  342.      * @throws RuntimeError When a previously generated cache is corrupted
  343.      * @throws SyntaxError  When an error occurred during compilation
  344.      *
  345.      * @return TemplateWrapper
  346.      */
  347.     public function load($name)
  348.     {
  349.         if ($name instanceof TemplateWrapper) {
  350.             return $name;
  351.         }
  353.         if ($name instanceof Template) {
  354.             @trigger_error('Passing a \Twig\Template instance to '.__METHOD__.' is deprecated since Twig 2.7.0, use \Twig\TemplateWrapper instead.', \E_USER_DEPRECATED);
  356.             return new TemplateWrapper($this, $name);
  357.         }
  359.         return new TemplateWrapper($this, $this->loadTemplate($name));
  360.     }
  362.     /**
  363.      * Loads a template internal representation.
  364.      *
  365.      * This method is for internal use only and should never be called
  366.      * directly.
  367.      *
  368.      * @param string $name  The template name
  369.      * @param int    $index The index if it is an embedded template
  370.      *
  371.      * @return Template A template instance representing the given template name
  372.      *
  373.      * @throws LoaderError  When the template cannot be found
  374.      * @throws RuntimeError When a previously generated cache is corrupted
  375.      * @throws SyntaxError  When an error occurred during compilation
  376.      *
  377.      * @internal
  378.      */
  379.     public function loadTemplate($name, $index = null)
  380.     {
  381.         return $this->loadClass($this->getTemplateClass($name), $name, $index);
  382.     }
  384.     /**
  385.      * @internal
  386.      */
  387.     public function loadClass($cls, $name, $index = null)
  388.     {
  389.         $mainCls = $cls;
  390.         if (null !== $index) {
  391.             $cls .= '___'.$index;
  392.         }
  394.         if (isset($this->loadedTemplates[$cls])) {
  395.             return $this->loadedTemplates[$cls];
  396.         }
  398.         if (!class_exists($cls, false)) {
  399.             $key = $this->cache->generateKey($name, $mainCls);
  401.             if (!$this->isAutoReload() || $this->isTemplateFresh($name, $this->cache->getTimestamp($key))) {
  402.                 $this->cache->load($key);
  403.             }
  405.             $source = null;
  406.             if (!class_exists($cls, false)) {
  407.                 $source = $this->getLoader()->getSourceContext($name);
  408.                 $content = $this->compileSource($source);
  409.                 $this->cache->write($key, $content);
  410.                 $this->cache->load($key);
  412.                 if (!class_exists($mainCls, false)) {
  413.                     /* Last line of defense if either $this->bcWriteCacheFile was used,
  414.                      * $this->cache is implemented as a no-op or we have a race condition
  415.                      * where the cache was cleared between the above calls to write to and load from
  416.                      * the cache.
  417.                      */
  418.                     eval('?>'.$content);
  419.                 }
  421.                 if (!class_exists($cls, false)) {
  422.                     throw new RuntimeError(sprintf('Failed to load Twig template "%s", index "%s": cache might be corrupted.', $name, $index), -1, $source);
  423.                 }
  424.             }
  425.         }
  427.         // to be removed in 3.0
  428.         $this->extensionSet->initRuntime($this);
  430.         return $this->loadedTemplates[$cls] = new $cls($this);
  431.     }
  433.     /**
  434.      * Creates a template from source.
  435.      *
  436.      * This method should not be used as a generic way to load templates.
  437.      *
  438.      * @param string $template The template source
  439.      * @param string $name     An optional name of the template to be used in error messages
  440.      *
  441.      * @return TemplateWrapper A template instance representing the given template name
  442.      *
  443.      * @throws LoaderError When the template cannot be found
  444.      * @throws SyntaxError When an error occurred during compilation
  445.      */
  446.     public function createTemplate($template, string $name = null)
  447.     {
  448.         $hash = hash(\PHP_VERSION_ID < 80100 ? 'sha256' : 'xxh128', $template, false);
  449.         if (null !== $name) {
  450.             $name = sprintf('%s (string template %s)', $name, $hash);
  451.         } else {
  452.             $name = sprintf('__string_template__%s', $hash);
  453.         }
  455.         $loader = new ChainLoader([
  456.             new ArrayLoader([$name => $template]),
  457.             $current = $this->getLoader(),
  458.         ]);
  460.         $this->setLoader($loader);
  461.         try {
  462.             return new TemplateWrapper($this, $this->loadTemplate($name));
  463.         } finally {
  464.             $this->setLoader($current);
  465.         }
  466.     }
  468.     /**
  469.      * Returns true if the template is still fresh.
  470.      *
  471.      * Besides checking the loader for freshness information,
  472.      * this method also checks if the enabled extensions have
  473.      * not changed.
  474.      *
  475.      * @param string $name The template name
  476.      * @param int    $time The last modification time of the cached template
  477.      *
  478.      * @return bool true if the template is fresh, false otherwise
  479.      */
  480.     public function isTemplateFresh($name, $time)
  481.     {
  482.         return $this->extensionSet->getLastModified() <= $time && $this->getLoader()->isFresh($name, $time);
  483.     }
  485.     /**
  486.      * Tries to load a template consecutively from an array.
  487.      *
  488.      * Similar to load() but it also accepts instances of \Twig\Template and
  489.      * \Twig\TemplateWrapper, and an array of templates where each is tried to be loaded.
  490.      *
  491.      * @param string|TemplateWrapper|array $names A template or an array of templates to try consecutively
  492.      *
  493.      * @return TemplateWrapper|Template
  494.      *
  495.      * @throws LoaderError When none of the templates can be found
  496.      * @throws SyntaxError When an error occurred during compilation
  497.      */
  498.     public function resolveTemplate($names)
  499.     {
  500.         if (!\is_array($names)) {
  501.             $names = [$names];
  502.         }
  504.         $count = \count($names);
  505.         foreach ($names as $name) {
  506.             if ($name instanceof Template) {
  507.                 return $name;
  508.             }
  509.             if ($name instanceof TemplateWrapper) {
  510.                 return $name;
  511.             }
  513.             if (1 !== $count && !$this->getLoader()->exists($name)) {
  514.                 continue;
  515.             }
  517.             return $this->loadTemplate($name);
  518.         }
  520.         throw new LoaderError(sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
  521.     }
  523.     public function setLexer(Lexer $lexer)
  524.     {
  525.         $this->lexer = $lexer;
  526.     }
  528.     /**
  529.      * Tokenizes a source code.
  530.      *
  531.      * @return TokenStream
  532.      *
  533.      * @throws SyntaxError When the code is syntactically wrong
  534.      */
  535.     public function tokenize(Source $source)
  536.     {
  537.         if (null === $this->lexer) {
  538.             $this->lexer = new Lexer($this);
  539.         }
  541.         return $this->lexer->tokenize($source);
  542.     }
  544.     public function setParser(Parser $parser)
  545.     {
  546.         $this->parser = $parser;
  547.     }
  549.     /**
  550.      * Converts a token stream to a node tree.
  551.      *
  552.      * @return ModuleNode
  553.      *
  554.      * @throws SyntaxError When the token stream is syntactically or semantically wrong
  555.      */
  556.     public function parse(TokenStream $stream)
  557.     {
  558.         if (null === $this->parser) {
  559.             $this->parser = new Parser($this);
  560.         }
  562.         return $this->parser->parse($stream);
  563.     }
  565.     public function setCompiler(Compiler $compiler)
  566.     {
  567.         $this->compiler = $compiler;
  568.     }
  570.     /**
  571.      * Compiles a node and returns the PHP code.
  572.      *
  573.      * @return string The compiled PHP source code
  574.      */
  575.     public function compile(Node $node)
  576.     {
  577.         if (null === $this->compiler) {
  578.             $this->compiler = new Compiler($this);
  579.         }
  581.         return $this->compiler->compile($node)->getSource();
  582.     }
  584.     /**
  585.      * Compiles a template source code.
  586.      *
  587.      * @return string The compiled PHP source code
  588.      *
  589.      * @throws SyntaxError When there was an error during tokenizing, parsing or compiling
  590.      */
  591.     public function compileSource(Source $source)
  592.     {
  593.         try {
  594.             return $this->compile($this->parse($this->tokenize($source)));
  595.         } catch (Error $e) {
  596.             $e->setSourceContext($source);
  597.             throw $e;
  598.         } catch (\Exception $e) {
  599.             throw new SyntaxError(sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $source, $e);
  600.         }
  601.     }
  603.     public function setLoader(LoaderInterface $loader)
  604.     {
  605.         $this->loader = $loader;
  606.     }
  608.     /**
  609.      * Gets the Loader instance.
  610.      *
  611.      * @return LoaderInterface
  612.      */
  613.     public function getLoader()
  614.     {
  615.         return $this->loader;
  616.     }
  618.     /**
  619.      * Sets the default template charset.
  620.      *
  621.      * @param string $charset The default charset
  622.      */
  623.     public function setCharset($charset)
  624.     {
  625.         if ('UTF8' === $charset = null === $charset ? null : strtoupper($charset)) {
  626.             // iconv on Windows requires "UTF-8" instead of "UTF8"
  627.             $charset = 'UTF-8';
  628.         }
  630.         $this->charset = $charset;
  631.     }
  633.     /**
  634.      * Gets the default template charset.
  635.      *
  636.      * @return string The default charset
  637.      */
  638.     public function getCharset()
  639.     {
  640.         return $this->charset;
  641.     }
  643.     /**
  644.      * Returns true if the given extension is registered.
  645.      *
  646.      * @param string $class The extension class name
  647.      *
  648.      * @return bool Whether the extension is registered or not
  649.      */
  650.     public function hasExtension($class)
  651.     {
  652.         return $this->extensionSet->hasExtension($class);
  653.     }
  655.     /**
  656.      * Adds a runtime loader.
  657.      */
  658.     public function addRuntimeLoader(RuntimeLoaderInterface $loader)
  659.     {
  660.         $this->runtimeLoaders[] = $loader;
  661.     }
  663.     /**
  664.      * Gets an extension by class name.
  665.      *
  666.      * @param string $class The extension class name
  667.      *
  668.      * @return ExtensionInterface
  669.      */
  670.     public function getExtension($class)
  671.     {
  672.         return $this->extensionSet->getExtension($class);
  673.     }
  675.     /**
  676.      * Returns the runtime implementation of a Twig element (filter/function/test).
  677.      *
  678.      * @param string $class A runtime class name
  679.      *
  680.      * @return object The runtime implementation
  681.      *
  682.      * @throws RuntimeError When the template cannot be found
  683.      */
  684.     public function getRuntime($class)
  685.     {
  686.         if (isset($this->runtimes[$class])) {
  687.             return $this->runtimes[$class];
  688.         }
  690.         foreach ($this->runtimeLoaders as $loader) {
  691.             if (null !== $runtime = $loader->load($class)) {
  692.                 return $this->runtimes[$class] = $runtime;
  693.             }
  694.         }
  696.         throw new RuntimeError(sprintf('Unable to load the "%s" runtime.', $class));
  697.     }
  699.     public function addExtension(ExtensionInterface $extension)
  700.     {
  701.         $this->extensionSet->addExtension($extension);
  702.         $this->updateOptionsHash();
  703.     }
  705.     /**
  706.      * Registers an array of extensions.
  707.      *
  708.      * @param array $extensions An array of extensions
  709.      */
  710.     public function setExtensions(array $extensions)
  711.     {
  712.         $this->extensionSet->setExtensions($extensions);
  713.         $this->updateOptionsHash();
  714.     }
  716.     /**
  717.      * Returns all registered extensions.
  718.      *
  719.      * @return ExtensionInterface[] An array of extensions (keys are for internal usage only and should not be relied on)
  720.      */
  721.     public function getExtensions()
  722.     {
  723.         return $this->extensionSet->getExtensions();
  724.     }
  726.     public function addTokenParser(TokenParserInterface $parser)
  727.     {
  728.         $this->extensionSet->addTokenParser($parser);
  729.     }
  731.     /**
  732.      * Gets the registered Token Parsers.
  733.      *
  734.      * @return TokenParserInterface[]
  735.      *
  736.      * @internal
  737.      */
  738.     public function getTokenParsers()
  739.     {
  740.         return $this->extensionSet->getTokenParsers();
  741.     }
  743.     /**
  744.      * Gets registered tags.
  745.      *
  746.      * @return TokenParserInterface[]
  747.      *
  748.      * @internal
  749.      */
  750.     public function getTags()
  751.     {
  752.         $tags = [];
  753.         foreach ($this->getTokenParsers() as $parser) {
  754.             $tags[$parser->getTag()] = $parser;
  755.         }
  757.         return $tags;
  758.     }
  760.     public function addNodeVisitor(NodeVisitorInterface $visitor)
  761.     {
  762.         $this->extensionSet->addNodeVisitor($visitor);
  763.     }
  765.     /**
  766.      * Gets the registered Node Visitors.
  767.      *
  768.      * @return NodeVisitorInterface[]
  769.      *
  770.      * @internal
  771.      */
  772.     public function getNodeVisitors()
  773.     {
  774.         return $this->extensionSet->getNodeVisitors();
  775.     }
  777.     public function addFilter(TwigFilter $filter)
  778.     {
  779.         $this->extensionSet->addFilter($filter);
  780.     }
  782.     /**
  783.      * Get a filter by name.
  784.      *
  785.      * Subclasses may override this method and load filters differently;
  786.      * so no list of filters is available.
  787.      *
  788.      * @param string $name The filter name
  789.      *
  790.      * @return TwigFilter|false
  791.      *
  792.      * @internal
  793.      */
  794.     public function getFilter($name)
  795.     {
  796.         return $this->extensionSet->getFilter($name);
  797.     }
  799.     public function registerUndefinedFilterCallback(callable $callable)
  800.     {
  801.         $this->extensionSet->registerUndefinedFilterCallback($callable);
  802.     }
  804.     /**
  805.      * Gets the registered Filters.
  806.      *
  807.      * Be warned that this method cannot return filters defined with registerUndefinedFilterCallback.
  808.      *
  809.      * @return TwigFilter[]
  810.      *
  811.      * @see registerUndefinedFilterCallback
  812.      *
  813.      * @internal
  814.      */
  815.     public function getFilters()
  816.     {
  817.         return $this->extensionSet->getFilters();
  818.     }
  820.     public function addTest(TwigTest $test)
  821.     {
  822.         $this->extensionSet->addTest($test);
  823.     }
  825.     /**
  826.      * Gets the registered Tests.
  827.      *
  828.      * @return TwigTest[]
  829.      *
  830.      * @internal
  831.      */
  832.     public function getTests()
  833.     {
  834.         return $this->extensionSet->getTests();
  835.     }
  837.     /**
  838.      * Gets a test by name.
  839.      *
  840.      * @param string $name The test name
  841.      *
  842.      * @return TwigTest|false
  843.      *
  844.      * @internal
  845.      */
  846.     public function getTest($name)
  847.     {
  848.         return $this->extensionSet->getTest($name);
  849.     }
  851.     public function addFunction(TwigFunction $function)
  852.     {
  853.         $this->extensionSet->addFunction($function);
  854.     }
  856.     /**
  857.      * Get a function by name.
  858.      *
  859.      * Subclasses may override this method and load functions differently;
  860.      * so no list of functions is available.
  861.      *
  862.      * @param string $name function name
  863.      *
  864.      * @return TwigFunction|false
  865.      *
  866.      * @internal
  867.      */
  868.     public function getFunction($name)
  869.     {
  870.         return $this->extensionSet->getFunction($name);
  871.     }
  873.     public function registerUndefinedFunctionCallback(callable $callable)
  874.     {
  875.         $this->extensionSet->registerUndefinedFunctionCallback($callable);
  876.     }
  878.     /**
  879.      * Gets registered functions.
  880.      *
  881.      * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
  882.      *
  883.      * @return TwigFunction[]
  884.      *
  885.      * @see registerUndefinedFunctionCallback
  886.      *
  887.      * @internal
  888.      */
  889.     public function getFunctions()
  890.     {
  891.         return $this->extensionSet->getFunctions();
  892.     }
  894.     /**
  895.      * Registers a Global.
  896.      *
  897.      * New globals can be added before compiling or rendering a template;
  898.      * but after, you can only update existing globals.
  899.      *
  900.      * @param string $name  The global name
  901.      * @param mixed  $value The global value
  902.      */
  903.     public function addGlobal($name, $value)
  904.     {
  905.         if ($this->extensionSet->isInitialized() && !\array_key_exists($name, $this->getGlobals())) {
  906.             throw new \LogicException(sprintf('Unable to add global "%s" as the runtime or the extensions have already been initialized.', $name));
  907.         }
  909.         if (null !== $this->resolvedGlobals) {
  910.             $this->resolvedGlobals[$name] = $value;
  911.         } else {
  912.             $this->globals[$name] = $value;
  913.         }
  914.     }
  916.     /**
  917.      * Gets the registered Globals.
  918.      *
  919.      * @return array An array of globals
  920.      *
  921.      * @internal
  922.      */
  923.     public function getGlobals()
  924.     {
  925.         if ($this->extensionSet->isInitialized()) {
  926.             if (null === $this->resolvedGlobals) {
  927.                 $this->resolvedGlobals = array_merge($this->extensionSet->getGlobals(), $this->globals);
  928.             }
  930.             return $this->resolvedGlobals;
  931.         }
  933.         return array_merge($this->extensionSet->getGlobals(), $this->globals);
  934.     }
  936.     /**
  937.      * Merges a context with the defined globals.
  938.      *
  939.      * @param array $context An array representing the context
  940.      *
  941.      * @return array The context merged with the globals
  942.      */
  943.     public function mergeGlobals(array $context)
  944.     {
  945.         // we don't use array_merge as the context being generally
  946.         // bigger than globals, this code is faster.
  947.         foreach ($this->getGlobals() as $key => $value) {
  948.             if (!\array_key_exists($key, $context)) {
  949.                 $context[$key] = $value;
  950.             }
  951.         }
  953.         return $context;
  954.     }
  956.     /**
  957.      * Gets the registered unary Operators.
  958.      *
  959.      * @return array An array of unary operators
  960.      *
  961.      * @internal
  962.      */
  963.     public function getUnaryOperators()
  964.     {
  965.         return $this->extensionSet->getUnaryOperators();
  966.     }
  968.     /**
  969.      * Gets the registered binary Operators.
  970.      *
  971.      * @return array An array of binary operators
  972.      *
  973.      * @internal
  974.      */
  975.     public function getBinaryOperators()
  976.     {
  977.         return $this->extensionSet->getBinaryOperators();
  978.     }
  980.     private function updateOptionsHash()
  981.     {
  982.         $this->optionsHash = implode(':', [
  983.             $this->extensionSet->getSignature(),
  984.             \PHP_MAJOR_VERSION,
  985.             \PHP_MINOR_VERSION,
  986.             self::VERSION,
  987.             (int) $this->debug,
  988.             $this->baseTemplateClass,
  989.             (int) $this->strictVariables,
  990.         ]);
  991.     }
  992. }
  994. class_alias('Twig\Environment', 'Twig_Environment');