vendor/twig/twig/lib/Twig/Environment.php

   1 <?php
   2
   3 /*
   4  * This file is part of Twig.
   5  *
   6  * (c) 2009 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  */
  11
  12 /**
  13  * Stores the Twig configuration.
  14  *
  15  * @author Fabien Potencier <fabien@symfony.com>
  16  */
  17 class Twig_Environment
  18 {
  19     const VERSION = '1.13.2';
  20
  21     protected $charset;
  22     protected $loader;
  23     protected $debug;
  24     protected $autoReload;
  25     protected $cache;
  26     protected $lexer;
  27     protected $parser;
  28     protected $compiler;
  29     protected $baseTemplateClass;
  30     protected $extensions;
  31     protected $parsers;
  32     protected $visitors;
  33     protected $filters;
  34     protected $tests;
  35     protected $functions;
  36     protected $globals;
  37     protected $runtimeInitialized;
  38     protected $extensionInitialized;
  39     protected $loadedTemplates;
  40     protected $strictVariables;
  41     protected $unaryOperators;
  42     protected $binaryOperators;
  43     protected $templateClassPrefix = '__TwigTemplate_';
  44     protected $functionCallbacks;
  45     protected $filterCallbacks;
  46     protected $staging;
  47
  48     /**
  49      * Constructor.
  50      *
  51      * Available options:
  52      *
  53      *  * debug: When set to true, it automatically set "auto_reload" to true as
  54      *           well (default to false).
  55      *
  56      *  * charset: The charset used by the templates (default to UTF-8).
  57      *
  58      *  * base_template_class: The base template class to use for generated
  59      *                         templates (default to Twig_Template).
  60      *
  61      *  * cache: An absolute path where to store the compiled templates, or
  62      *           false to disable compilation cache (default).
  63      *
  64      *  * auto_reload: Whether to reload the template is the original source changed.
  65      *                 If you don't provide the auto_reload option, it will be
  66      *                 determined automatically base on the debug value.
  67      *
  68      *  * strict_variables: Whether to ignore invalid variables in templates
  69      *                      (default to false).
  70      *
  71      *  * autoescape: Whether to enable auto-escaping (default to html):
  72      *                  * false: disable auto-escaping
  73      *                  * true: equivalent to html
  74      *                  * html, js: set the autoescaping to one of the supported strategies
  75      *                  * PHP callback: a PHP callback that returns an escaping strategy based on the template "filename"
  76      *
  77      *  * optimizations: A flag that indicates which optimizations to apply
  78      *                   (default to -1 which means that all optimizations are enabled;
  79      *                   set it to 0 to disable).
  80      *
  81      * @param Twig_LoaderInterface $loader  A Twig_LoaderInterface instance
  82      * @param array                $options An array of options
  83      */
  84     public function __construct(Twig_LoaderInterface $loader = null, $options = array())
  85     {
  86         if (null !== $loader) {
  87             $this->setLoader($loader);
  88         }
  89
  90         $options = array_merge(array(
  91             'debug'               => false,
  92             'charset'             => 'UTF-8',
  93             'base_template_class' => 'Twig_Template',
  94             'strict_variables'    => false,
  95             'autoescape'          => 'html',
  96             'cache'               => false,
  97             'auto_reload'         => null,
  98             'optimizations'       => -1,
  99         ), $options);
 100
 101         $this->debug              = (bool) $options['debug'];
 102         $this->charset            = strtoupper($options['charset']);
 103         $this->baseTemplateClass  = $options['base_template_class'];
 104         $this->autoReload         = null === $options['auto_reload'] ? $this->debug : (bool) $options['auto_reload'];
 105         $this->strictVariables    = (bool) $options['strict_variables'];
 106         $this->runtimeInitialized = false;
 107         $this->setCache($options['cache']);
 108         $this->functionCallbacks = array();
 109         $this->filterCallbacks = array();
 110
 111         $this->addExtension(new Twig_Extension_Core());
 112         $this->addExtension(new Twig_Extension_Escaper($options['autoescape']));
 113         $this->addExtension(new Twig_Extension_Optimizer($options['optimizations']));
 114         $this->extensionInitialized = false;
 115         $this->staging = new Twig_Extension_Staging();
 116     }
 117
 118     /**
 119      * Gets the base template class for compiled templates.
 120      *
 121      * @return string The base template class name
 122      */
 123     public function getBaseTemplateClass()
 124     {
 125         return $this->baseTemplateClass;
 126     }
 127
 128     /**
 129      * Sets the base template class for compiled templates.
 130      *
 131      * @param string $class The base template class name
 132      */
 133     public function setBaseTemplateClass($class)
 134     {
 135         $this->baseTemplateClass = $class;
 136     }
 137
 138     /**
 139      * Enables debugging mode.
 140      */
 141     public function enableDebug()
 142     {
 143         $this->debug = true;
 144     }
 145
 146     /**
 147      * Disables debugging mode.
 148      */
 149     public function disableDebug()
 150     {
 151         $this->debug = false;
 152     }
 153
 154     /**
 155      * Checks if debug mode is enabled.
 156      *
 157      * @return Boolean true if debug mode is enabled, false otherwise
 158      */
 159     public function isDebug()
 160     {
 161         return $this->debug;
 162     }
 163
 164     /**
 165      * Enables the auto_reload option.
 166      */
 167     public function enableAutoReload()
 168     {
 169         $this->autoReload = true;
 170     }
 171
 172     /**
 173      * Disables the auto_reload option.
 174      */
 175     public function disableAutoReload()
 176     {
 177         $this->autoReload = false;
 178     }
 179
 180     /**
 181      * Checks if the auto_reload option is enabled.
 182      *
 183      * @return Boolean true if auto_reload is enabled, false otherwise
 184      */
 185     public function isAutoReload()
 186     {
 187         return $this->autoReload;
 188     }
 189
 190     /**
 191      * Enables the strict_variables option.
 192      */
 193     public function enableStrictVariables()
 194     {
 195         $this->strictVariables = true;
 196     }
 197
 198     /**
 199      * Disables the strict_variables option.
 200      */
 201     public function disableStrictVariables()
 202     {
 203         $this->strictVariables = false;
 204     }
 205
 206     /**
 207      * Checks if the strict_variables option is enabled.
 208      *
 209      * @return Boolean true if strict_variables is enabled, false otherwise
 210      */
 211     public function isStrictVariables()
 212     {
 213         return $this->strictVariables;
 214     }
 215
 216     /**
 217      * Gets the cache directory or false if cache is disabled.
 218      *
 219      * @return string|false
 220      */
 221     public function getCache()
 222     {
 223         return $this->cache;
 224     }
 225
 226      /**
 227       * Sets the cache directory or false if cache is disabled.
 228       *
 229       * @param string|false $cache The absolute path to the compiled templates,
 230       *                            or false to disable cache
 231       */
 232     public function setCache($cache)
 233     {
 234         $this->cache = $cache ? $cache : false;
 235     }
 236
 237     /**
 238      * Gets the cache filename for a given template.
 239      *
 240      * @param string $name The template name
 241      *
 242      * @return string The cache file name
 243      */
 244     public function getCacheFilename($name)
 245     {
 246         if (false === $this->cache) {
 247             return false;
 248         }
 249
 250         $class = substr($this->getTemplateClass($name), strlen($this->templateClassPrefix));
 251
 252         return $this->getCache().'/'.substr($class, 0, 2).'/'.substr($class, 2, 2).'/'.substr($class, 4).'.php';
 253     }
 254
 255     /**
 256      * Gets the template class associated with the given string.
 257      *
 258      * @param string  $name  The name for which to calculate the template class name
 259      * @param integer $index The index if it is an embedded template
 260      *
 261      * @return string The template class name
 262      */
 263     public function getTemplateClass($name, $index = null)
 264     {
 265         return $this->templateClassPrefix.md5($this->getLoader()->getCacheKey($name)).(null === $index ? '' : '_'.$index);
 266     }
 267
 268     /**
 269      * Gets the template class prefix.
 270      *
 271      * @return string The template class prefix
 272      */
 273     public function getTemplateClassPrefix()
 274     {
 275         return $this->templateClassPrefix;
 276     }
 277
 278     /**
 279      * Renders a template.
 280      *
 281      * @param string $name    The template name
 282      * @param array  $context An array of parameters to pass to the template
 283      *
 284      * @return string The rendered template
 285      */
 286     public function render($name, array $context = array())
 287     {
 288         return $this->loadTemplate($name)->render($context);
 289     }
 290
 291     /**
 292      * Displays a template.
 293      *
 294      * @param string $name    The template name
 295      * @param array  $context An array of parameters to pass to the template
 296      */
 297     public function display($name, array $context = array())
 298     {
 299         $this->loadTemplate($name)->display($context);
 300     }
 301
 302     /**
 303      * Loads a template by name.
 304      *
 305      * @param string  $name  The template name
 306      * @param integer $index The index if it is an embedded template
 307      *
 308      * @return Twig_TemplateInterface A template instance representing the given template name
 309      */
 310     public function loadTemplate($name, $index = null)
 311     {
 312         $cls = $this->getTemplateClass($name, $index);
 313
 314         if (isset($this->loadedTemplates[$cls])) {
 315             return $this->loadedTemplates[$cls];
 316         }
 317
 318         if (!class_exists($cls, false)) {
 319             if (false === $cache = $this->getCacheFilename($name)) {
 320                 eval('?>'.$this->compileSource($this->getLoader()->getSource($name), $name));
 321             } else {
 322                 if (!is_file($cache) || ($this->isAutoReload() && !$this->isTemplateFresh($name, filemtime($cache)))) {
 323                     $this->writeCacheFile($cache, $this->compileSource($this->getLoader()->getSource($name), $name));
 324                 }
 325
 326                 require_once $cache;
 327             }
 328         }
 329
 330         if (!$this->runtimeInitialized) {
 331             $this->initRuntime();
 332         }
 333
 334         return $this->loadedTemplates[$cls] = new $cls($this);
 335     }
 336
 337     /**
 338      * Returns true if the template is still fresh.
 339      *
 340      * Besides checking the loader for freshness information,
 341      * this method also checks if the enabled extensions have
 342      * not changed.
 343      *
 344      * @param string    $name The template name
 345      * @param timestamp $time The last modification time of the cached template
 346      *
 347      * @return Boolean true if the template is fresh, false otherwise
 348      */
 349     public function isTemplateFresh($name, $time)
 350     {
 351         foreach ($this->extensions as $extension) {
 352             $r = new ReflectionObject($extension);
 353             if (filemtime($r->getFileName()) > $time) {
 354                 return false;
 355             }
 356         }
 357
 358         return $this->getLoader()->isFresh($name, $time);
 359     }
 360
 361     public function resolveTemplate($names)
 362     {
 363         if (!is_array($names)) {
 364             $names = array($names);
 365         }
 366
 367         foreach ($names as $name) {
 368             if ($name instanceof Twig_Template) {
 369                 return $name;
 370             }
 371
 372             try {
 373                 return $this->loadTemplate($name);
 374             } catch (Twig_Error_Loader $e) {
 375             }
 376         }
 377
 378         if (1 === count($names)) {
 379             throw $e;
 380         }
 381
 382         throw new Twig_Error_Loader(sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
 383     }
 384
 385     /**
 386      * Clears the internal template cache.
 387      */
 388     public function clearTemplateCache()
 389     {
 390         $this->loadedTemplates = array();
 391     }
 392
 393     /**
 394      * Clears the template cache files on the filesystem.
 395      */
 396     public function clearCacheFiles()
 397     {
 398         if (false === $this->cache) {
 399             return;
 400         }
 401
 402         foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->cache), RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
 403             if ($file->isFile()) {
 404                 @unlink($file->getPathname());
 405             }
 406         }
 407     }
 408
 409     /**
 410      * Gets the Lexer instance.
 411      *
 412      * @return Twig_LexerInterface A Twig_LexerInterface instance
 413      */
 414     public function getLexer()
 415     {
 416         if (null === $this->lexer) {
 417             $this->lexer = new Twig_Lexer($this);
 418         }
 419
 420         return $this->lexer;
 421     }
 422
 423     /**
 424      * Sets the Lexer instance.
 425      *
 426      * @param Twig_LexerInterface A Twig_LexerInterface instance
 427      */
 428     public function setLexer(Twig_LexerInterface $lexer)
 429     {
 430         $this->lexer = $lexer;
 431     }
 432
 433     /**
 434      * Tokenizes a source code.
 435      *
 436      * @param string $source The template source code
 437      * @param string $name   The template name
 438      *
 439      * @return Twig_TokenStream A Twig_TokenStream instance
 440      */
 441     public function tokenize($source, $name = null)
 442     {
 443         return $this->getLexer()->tokenize($source, $name);
 444     }
 445
 446     /**
 447      * Gets the Parser instance.
 448      *
 449      * @return Twig_ParserInterface A Twig_ParserInterface instance
 450      */
 451     public function getParser()
 452     {
 453         if (null === $this->parser) {
 454             $this->parser = new Twig_Parser($this);
 455         }
 456
 457         return $this->parser;
 458     }
 459
 460     /**
 461      * Sets the Parser instance.
 462      *
 463      * @param Twig_ParserInterface A Twig_ParserInterface instance
 464      */
 465     public function setParser(Twig_ParserInterface $parser)
 466     {
 467         $this->parser = $parser;
 468     }
 469
 470     /**
 471      * Parses a token stream.
 472      *
 473      * @param Twig_TokenStream $tokens A Twig_TokenStream instance
 474      *
 475      * @return Twig_Node_Module A Node tree
 476      */
 477     public function parse(Twig_TokenStream $tokens)
 478     {
 479         return $this->getParser()->parse($tokens);
 480     }
 481
 482     /**
 483      * Gets the Compiler instance.
 484      *
 485      * @return Twig_CompilerInterface A Twig_CompilerInterface instance
 486      */
 487     public function getCompiler()
 488     {
 489         if (null === $this->compiler) {
 490             $this->compiler = new Twig_Compiler($this);
 491         }
 492
 493         return $this->compiler;
 494     }
 495
 496     /**
 497      * Sets the Compiler instance.
 498      *
 499      * @param Twig_CompilerInterface $compiler A Twig_CompilerInterface instance
 500      */
 501     public function setCompiler(Twig_CompilerInterface $compiler)
 502     {
 503         $this->compiler = $compiler;
 504     }
 505
 506     /**
 507      * Compiles a Node.
 508      *
 509      * @param Twig_NodeInterface $node A Twig_NodeInterface instance
 510      *
 511      * @return string The compiled PHP source code
 512      */
 513     public function compile(Twig_NodeInterface $node)
 514     {
 515         return $this->getCompiler()->compile($node)->getSource();
 516     }
 517
 518     /**
 519      * Compiles a template source code.
 520      *
 521      * @param string $source The template source code
 522      * @param string $name   The template name
 523      *
 524      * @return string The compiled PHP source code
 525      */
 526     public function compileSource($source, $name = null)
 527     {
 528         try {
 529             return $this->compile($this->parse($this->tokenize($source, $name)));
 530         } catch (Twig_Error $e) {
 531             $e->setTemplateFile($name);
 532             throw $e;
 533         } catch (Exception $e) {
 534             throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $name, $e);
 535         }
 536     }
 537
 538     /**
 539      * Sets the Loader instance.
 540      *
 541      * @param Twig_LoaderInterface $loader A Twig_LoaderInterface instance
 542      */
 543     public function setLoader(Twig_LoaderInterface $loader)
 544     {
 545         $this->loader = $loader;
 546     }
 547
 548     /**
 549      * Gets the Loader instance.
 550      *
 551      * @return Twig_LoaderInterface A Twig_LoaderInterface instance
 552      */
 553     public function getLoader()
 554     {
 555         if (null === $this->loader) {
 556             throw new LogicException('You must set a loader first.');
 557         }
 558
 559         return $this->loader;
 560     }
 561
 562     /**
 563      * Sets the default template charset.
 564      *
 565      * @param string $charset The default charset
 566      */
 567     public function setCharset($charset)
 568     {
 569         $this->charset = strtoupper($charset);
 570     }
 571
 572     /**
 573      * Gets the default template charset.
 574      *
 575      * @return string The default charset
 576      */
 577     public function getCharset()
 578     {
 579         return $this->charset;
 580     }
 581
 582     /**
 583      * Initializes the runtime environment.
 584      */
 585     public function initRuntime()
 586     {
 587         $this->runtimeInitialized = true;
 588
 589         foreach ($this->getExtensions() as $extension) {
 590             $extension->initRuntime($this);
 591         }
 592     }
 593
 594     /**
 595      * Returns true if the given extension is registered.
 596      *
 597      * @param string $name The extension name
 598      *
 599      * @return Boolean Whether the extension is registered or not
 600      */
 601     public function hasExtension($name)
 602     {
 603         return isset($this->extensions[$name]);
 604     }
 605
 606     /**
 607      * Gets an extension by name.
 608      *
 609      * @param string $name The extension name
 610      *
 611      * @return Twig_ExtensionInterface A Twig_ExtensionInterface instance
 612      */
 613     public function getExtension($name)
 614     {
 615         if (!isset($this->extensions[$name])) {
 616             throw new Twig_Error_Runtime(sprintf('The "%s" extension is not enabled.', $name));
 617         }
 618
 619         return $this->extensions[$name];
 620     }
 621
 622     /**
 623      * Registers an extension.
 624      *
 625      * @param Twig_ExtensionInterface $extension A Twig_ExtensionInterface instance
 626      */
 627     public function addExtension(Twig_ExtensionInterface $extension)
 628     {
 629         if ($this->extensionInitialized) {
 630             throw new LogicException(sprintf('Unable to register extension "%s" as extensions have already been initialized.', $extension->getName()));
 631         }
 632
 633         $this->extensions[$extension->getName()] = $extension;
 634     }
 635
 636     /**
 637      * Removes an extension by name.
 638      *
 639      * This method is deprecated and you should not use it.
 640      *
 641      * @param string $name The extension name
 642      *
 643      * @deprecated since 1.12 (to be removed in 2.0)
 644      */
 645     public function removeExtension($name)
 646     {
 647         if ($this->extensionInitialized) {
 648             throw new LogicException(sprintf('Unable to remove extension "%s" as extensions have already been initialized.', $name));
 649         }
 650
 651         unset($this->extensions[$name]);
 652     }
 653
 654     /**
 655      * Registers an array of extensions.
 656      *
 657      * @param array $extensions An array of extensions
 658      */
 659     public function setExtensions(array $extensions)
 660     {
 661         foreach ($extensions as $extension) {
 662             $this->addExtension($extension);
 663         }
 664     }
 665
 666     /**
 667      * Returns all registered extensions.
 668      *
 669      * @return array An array of extensions
 670      */
 671     public function getExtensions()
 672     {
 673         return $this->extensions;
 674     }
 675
 676     /**
 677      * Registers a Token Parser.
 678      *
 679      * @param Twig_TokenParserInterface $parser A Twig_TokenParserInterface instance
 680      */
 681     public function addTokenParser(Twig_TokenParserInterface $parser)
 682     {
 683         if ($this->extensionInitialized) {
 684             throw new LogicException('Unable to add a token parser as extensions have already been initialized.');
 685         }
 686
 687         $this->staging->addTokenParser($parser);
 688     }
 689
 690     /**
 691      * Gets the registered Token Parsers.
 692      *
 693      * @return Twig_TokenParserBrokerInterface A broker containing token parsers
 694      */
 695     public function getTokenParsers()
 696     {
 697         if (!$this->extensionInitialized) {
 698             $this->initExtensions();
 699         }
 700
 701         return $this->parsers;
 702     }
 703
 704     /**
 705      * Gets registered tags.
 706      *
 707      * Be warned that this method cannot return tags defined by Twig_TokenParserBrokerInterface classes.
 708      *
 709      * @return Twig_TokenParserInterface[] An array of Twig_TokenParserInterface instances
 710      */
 711     public function getTags()
 712     {
 713         $tags = array();
 714         foreach ($this->getTokenParsers()->getParsers() as $parser) {
 715             if ($parser instanceof Twig_TokenParserInterface) {
 716                 $tags[$parser->getTag()] = $parser;
 717             }
 718         }
 719
 720         return $tags;
 721     }
 722
 723     /**
 724      * Registers a Node Visitor.
 725      *
 726      * @param Twig_NodeVisitorInterface $visitor A Twig_NodeVisitorInterface instance
 727      */
 728     public function addNodeVisitor(Twig_NodeVisitorInterface $visitor)
 729     {
 730         if ($this->extensionInitialized) {
 731             throw new LogicException('Unable to add a node visitor as extensions have already been initialized.');
 732         }
 733
 734         $this->staging->addNodeVisitor($visitor);
 735     }
 736
 737     /**
 738      * Gets the registered Node Visitors.
 739      *
 740      * @return Twig_NodeVisitorInterface[] An array of Twig_NodeVisitorInterface instances
 741      */
 742     public function getNodeVisitors()
 743     {
 744         if (!$this->extensionInitialized) {
 745             $this->initExtensions();
 746         }
 747
 748         return $this->visitors;
 749     }
 750
 751     /**
 752      * Registers a Filter.
 753      *
 754      * @param string|Twig_SimpleFilter               $name   The filter name or a Twig_SimpleFilter instance
 755      * @param Twig_FilterInterface|Twig_SimpleFilter $filter A Twig_FilterInterface instance or a Twig_SimpleFilter instance
 756      */
 757     public function addFilter($name, $filter = null)
 758     {
 759         if (!$name instanceof Twig_SimpleFilter && !($filter instanceof Twig_SimpleFilter || $filter instanceof Twig_FilterInterface)) {
 760             throw new LogicException('A filter must be an instance of Twig_FilterInterface or Twig_SimpleFilter');
 761         }
 762
 763         if ($name instanceof Twig_SimpleFilter) {
 764             $filter = $name;
 765             $name = $filter->getName();
 766         }
 767
 768         if ($this->extensionInitialized) {
 769             throw new LogicException(sprintf('Unable to add filter "%s" as extensions have already been initialized.', $name));
 770         }
 771
 772         $this->staging->addFilter($name, $filter);
 773     }
 774
 775     /**
 776      * Get a filter by name.
 777      *
 778      * Subclasses may override this method and load filters differently;
 779      * so no list of filters is available.
 780      *
 781      * @param string $name The filter name
 782      *
 783      * @return Twig_Filter|false A Twig_Filter instance or false if the filter does not exist
 784      */
 785     public function getFilter($name)
 786     {
 787         if (!$this->extensionInitialized) {
 788             $this->initExtensions();
 789         }
 790
 791         if (isset($this->filters[$name])) {
 792             return $this->filters[$name];
 793         }
 794
 795         foreach ($this->filters as $pattern => $filter) {
 796             $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
 797
 798             if ($count) {
 799                 if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
 800                     array_shift($matches);
 801                     $filter->setArguments($matches);
 802
 803                     return $filter;
 804                 }
 805             }
 806         }
 807
 808         foreach ($this->filterCallbacks as $callback) {
 809             if (false !== $filter = call_user_func($callback, $name)) {
 810                 return $filter;
 811             }
 812         }
 813
 814         return false;
 815     }
 816
 817     public function registerUndefinedFilterCallback($callable)
 818     {
 819         $this->filterCallbacks[] = $callable;
 820     }
 821
 822     /**
 823      * Gets the registered Filters.
 824      *
 825      * Be warned that this method cannot return filters defined with registerUndefinedFunctionCallback.
 826      *
 827      * @return Twig_FilterInterface[] An array of Twig_FilterInterface instances
 828      *
 829      * @see registerUndefinedFilterCallback
 830      */
 831     public function getFilters()
 832     {
 833         if (!$this->extensionInitialized) {
 834             $this->initExtensions();
 835         }
 836
 837         return $this->filters;
 838     }
 839
 840     /**
 841      * Registers a Test.
 842      *
 843      * @param string|Twig_SimpleTest             $name The test name or a Twig_SimpleTest instance
 844      * @param Twig_TestInterface|Twig_SimpleTest $test A Twig_TestInterface instance or a Twig_SimpleTest instance
 845      */
 846     public function addTest($name, $test = null)
 847     {
 848         if (!$name instanceof Twig_SimpleTest && !($test instanceof Twig_SimpleTest || $test instanceof Twig_TestInterface)) {
 849             throw new LogicException('A test must be an instance of Twig_TestInterface or Twig_SimpleTest');
 850         }
 851
 852         if ($name instanceof Twig_SimpleTest) {
 853             $test = $name;
 854             $name = $test->getName();
 855         }
 856
 857         if ($this->extensionInitialized) {
 858             throw new LogicException(sprintf('Unable to add test "%s" as extensions have already been initialized.', $name));
 859         }
 860
 861         $this->staging->addTest($name, $test);
 862     }
 863
 864     /**
 865      * Gets the registered Tests.
 866      *
 867      * @return Twig_TestInterface[] An array of Twig_TestInterface instances
 868      */
 869     public function getTests()
 870     {
 871         if (!$this->extensionInitialized) {
 872             $this->initExtensions();
 873         }
 874
 875         return $this->tests;
 876     }
 877
 878     /**
 879      * Gets a test by name.
 880      *
 881      * @param string $name The test name
 882      *
 883      * @return Twig_Test|false A Twig_Test instance or false if the test does not exist
 884      */
 885     public function getTest($name)
 886     {
 887         if (!$this->extensionInitialized) {
 888             $this->initExtensions();
 889         }
 890
 891         if (isset($this->tests[$name])) {
 892             return $this->tests[$name];
 893         }
 894
 895         return false;
 896     }
 897
 898     /**
 899      * Registers a Function.
 900      *
 901      * @param string|Twig_SimpleFunction                 $name     The function name or a Twig_SimpleFunction instance
 902      * @param Twig_FunctionInterface|Twig_SimpleFunction $function A Twig_FunctionInterface instance or a Twig_SimpleFunction instance
 903      */
 904     public function addFunction($name, $function = null)
 905     {
 906         if (!$name instanceof Twig_SimpleFunction && !($function instanceof Twig_SimpleFunction || $function instanceof Twig_FunctionInterface)) {
 907             throw new LogicException('A function must be an instance of Twig_FunctionInterface or Twig_SimpleFunction');
 908         }
 909
 910         if ($name instanceof Twig_SimpleFunction) {
 911             $function = $name;
 912             $name = $function->getName();
 913         }
 914
 915         if ($this->extensionInitialized) {
 916             throw new LogicException(sprintf('Unable to add function "%s" as extensions have already been initialized.', $name));
 917         }
 918
 919         $this->staging->addFunction($name, $function);
 920     }
 921
 922     /**
 923      * Get a function by name.
 924      *
 925      * Subclasses may override this method and load functions differently;
 926      * so no list of functions is available.
 927      *
 928      * @param string $name function name
 929      *
 930      * @return Twig_Function|false A Twig_Function instance or false if the function does not exist
 931      */
 932     public function getFunction($name)
 933     {
 934         if (!$this->extensionInitialized) {
 935             $this->initExtensions();
 936         }
 937
 938         if (isset($this->functions[$name])) {
 939             return $this->functions[$name];
 940         }
 941
 942         foreach ($this->functions as $pattern => $function) {
 943             $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
 944
 945             if ($count) {
 946                 if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
 947                     array_shift($matches);
 948                     $function->setArguments($matches);
 949
 950                     return $function;
 951                 }
 952             }
 953         }
 954
 955         foreach ($this->functionCallbacks as $callback) {
 956             if (false !== $function = call_user_func($callback, $name)) {
 957                 return $function;
 958             }
 959         }
 960
 961         return false;
 962     }
 963
 964     public function registerUndefinedFunctionCallback($callable)
 965     {
 966         $this->functionCallbacks[] = $callable;
 967     }
 968
 969     /**
 970      * Gets registered functions.
 971      *
 972      * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
 973      *
 974      * @return Twig_FunctionInterface[] An array of Twig_FunctionInterface instances
 975      *
 976      * @see registerUndefinedFunctionCallback
 977      */
 978     public function getFunctions()
 979     {
 980         if (!$this->extensionInitialized) {
 981             $this->initExtensions();
 982         }
 983
 984         return $this->functions;
 985     }
 986
 987     /**
 988      * Registers a Global.
 989      *
 990      * New globals can be added before compiling or rendering a template;
 991      * but after, you can only update existing globals.
 992      *
 993      * @param string $name  The global name
 994      * @param mixed  $value The global value
 995      */
 996     public function addGlobal($name, $value)
 997     {
 998         if ($this->extensionInitialized || $this->runtimeInitialized) {
 999             if (null === $this->globals) {
1000                 $this->globals = $this->initGlobals();
1001             }
1002
1003             /* This condition must be uncommented in Twig 2.0
1004             if (!array_key_exists($name, $this->globals)) {
1005                 throw new LogicException(sprintf('Unable to add global "%s" as the runtime or the extensions have already been initialized.', $name));
1006             }
1007             */
1008         }
1009
1010         if ($this->extensionInitialized || $this->runtimeInitialized) {
1011             // update the value
1012             $this->globals[$name] = $value;
1013         } else {
1014             $this->staging->addGlobal($name, $value);
1015         }
1016     }
1017
1018     /**
1019      * Gets the registered Globals.
1020      *
1021      * @return array An array of globals
1022      */
1023     public function getGlobals()
1024     {
1025         if (!$this->runtimeInitialized && !$this->extensionInitialized) {
1026             return $this->initGlobals();
1027         }
1028
1029         if (null === $this->globals) {
1030             $this->globals = $this->initGlobals();
1031         }
1032
1033         return $this->globals;
1034     }
1035
1036     /**
1037      * Merges a context with the defined globals.
1038      *
1039      * @param array $context An array representing the context
1040      *
1041      * @return array The context merged with the globals
1042      */
1043     public function mergeGlobals(array $context)
1044     {
1045         // we don't use array_merge as the context being generally
1046         // bigger than globals, this code is faster.
1047         foreach ($this->getGlobals() as $key => $value) {
1048             if (!array_key_exists($key, $context)) {
1049                 $context[$key] = $value;
1050             }
1051         }
1052
1053         return $context;
1054     }
1055
1056     /**
1057      * Gets the registered unary Operators.
1058      *
1059      * @return array An array of unary operators
1060      */
1061     public function getUnaryOperators()
1062     {
1063         if (!$this->extensionInitialized) {
1064             $this->initExtensions();
1065         }
1066
1067         return $this->unaryOperators;
1068     }
1069
1070     /**
1071      * Gets the registered binary Operators.
1072      *
1073      * @return array An array of binary operators
1074      */
1075     public function getBinaryOperators()
1076     {
1077         if (!$this->extensionInitialized) {
1078             $this->initExtensions();
1079         }
1080
1081         return $this->binaryOperators;
1082     }
1083
1084     public function computeAlternatives($name, $items)
1085     {
1086         $alternatives = array();
1087         foreach ($items as $item) {
1088             $lev = levenshtein($name, $item);
1089             if ($lev <= strlen($name) / 3 || false !== strpos($item, $name)) {
1090                 $alternatives[$item] = $lev;
1091             }
1092         }
1093         asort($alternatives);
1094
1095         return array_keys($alternatives);
1096     }
1097
1098     protected function initGlobals()
1099     {
1100         $globals = array();
1101         foreach ($this->extensions as $extension) {
1102             $extGlob = $extension->getGlobals();
1103             if (!is_array($extGlob)) {
1104                 throw new UnexpectedValueException(sprintf('"%s::getGlobals()" must return an array of globals.', get_class($extension)));
1105             }
1106
1107             $globals[] = $extGlob;
1108         }
1109
1110         $globals[] = $this->staging->getGlobals();
1111
1112         return call_user_func_array('array_merge', $globals);
1113     }
1114
1115     protected function initExtensions()
1116     {
1117         if ($this->extensionInitialized) {
1118             return;
1119         }
1120
1121         $this->extensionInitialized = true;
1122         $this->parsers = new Twig_TokenParserBroker();
1123         $this->filters = array();
1124         $this->functions = array();
1125         $this->tests = array();
1126         $this->visitors = array();
1127         $this->unaryOperators = array();
1128         $this->binaryOperators = array();
1129
1130         foreach ($this->extensions as $extension) {
1131             $this->initExtension($extension);
1132         }
1133         $this->initExtension($this->staging);
1134     }
1135
1136     protected function initExtension(Twig_ExtensionInterface $extension)
1137     {
1138         // filters
1139         foreach ($extension->getFilters() as $name => $filter) {
1140             if ($name instanceof Twig_SimpleFilter) {
1141                 $filter = $name;
1142                 $name = $filter->getName();
1143             } elseif ($filter instanceof Twig_SimpleFilter) {
1144                 $name = $filter->getName();
1145             }
1146
1147             $this->filters[$name] = $filter;
1148         }
1149
1150         // functions
1151         foreach ($extension->getFunctions() as $name => $function) {
1152             if ($name instanceof Twig_SimpleFunction) {
1153                 $function = $name;
1154                 $name = $function->getName();
1155             } elseif ($function instanceof Twig_SimpleFunction) {
1156                 $name = $function->getName();
1157             }
1158
1159             $this->functions[$name] = $function;
1160         }
1161
1162         // tests
1163         foreach ($extension->getTests() as $name => $test) {
1164             if ($name instanceof Twig_SimpleTest) {
1165                 $test = $name;
1166                 $name = $test->getName();
1167             } elseif ($test instanceof Twig_SimpleTest) {
1168                 $name = $test->getName();
1169             }
1170
1171             $this->tests[$name] = $test;
1172         }
1173
1174         // token parsers
1175         foreach ($extension->getTokenParsers() as $parser) {
1176             if ($parser instanceof Twig_TokenParserInterface) {
1177                 $this->parsers->addTokenParser($parser);
1178             } elseif ($parser instanceof Twig_TokenParserBrokerInterface) {
1179                 $this->parsers->addTokenParserBroker($parser);
1180             } else {
1181                 throw new LogicException('getTokenParsers() must return an array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances');
1182             }
1183         }
1184
1185         // node visitors
1186         foreach ($extension->getNodeVisitors() as $visitor) {
1187             $this->visitors[] = $visitor;
1188         }
1189
1190         // operators
1191         if ($operators = $extension->getOperators()) {
1192             if (2 !== count($operators)) {
1193                 throw new InvalidArgumentException(sprintf('"%s::getOperators()" does not return a valid operators array.', get_class($extension)));
1194             }
1195
1196             $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
1197             $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
1198         }
1199     }
1200
1201     protected function writeCacheFile($file, $content)
1202     {
1203         $dir = dirname($file);
1204         if (!is_dir($dir)) {
1205             if (false === @mkdir($dir, 0777, true) && !is_dir($dir)) {
1206                 throw new RuntimeException(sprintf("Unable to create the cache directory (%s).", $dir));
1207             }
1208         } elseif (!is_writable($dir)) {
1209             throw new RuntimeException(sprintf("Unable to write in the cache directory (%s).", $dir));
1210         }
1211
1212         $tmpFile = tempnam(dirname($file), basename($file));
1213         if (false !== @file_put_contents($tmpFile, $content)) {
1214             // rename does not work on Win32 before 5.2.6
1215             if (@rename($tmpFile, $file) || (@copy($tmpFile, $file) && unlink($tmpFile))) {
1216                 @chmod($file, 0666 & ~umask());
1217
1218                 return;
1219             }
1220         }
1221
1222         throw new RuntimeException(sprintf('Failed to write cache file "%s".', $file));
1223     }
1224 }