Update Twig (now uses composer) and add composer.json.

12 years ago · 7d2f97f2f6
parent 070cb92661
commit 7d2f97f2f6
461 changed files with 3989 additions and 15084 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,2 +1,5 @@
-pico.sublime-project
+composer.lock
-pico.sublime-workspace
+composer.phar
 vendor/twig/twig/doc/*
 vendor/twig/twig/ext/*
 vendor/twig/twig/test/*
--- a/composer.json
+++ b/composer.json
@ -0,0 +1,5 @@
 {
    "require": {
        "twig/twig": "1.12.*"
    }
 }
--- a/config.php
+++ b/config.php
@ -3,7 +3,7 @@
 /*
 Override any of the default settings below:
-$config['site_title'] = 'Pico';				// Site title
+$config['site_title'] = 'Pico';			// Site title
 $config['base_url'] = ''; 				// Override base URL (e.g. http://example.com)
 $config['theme'] = 'default'; 			// Set the theme (defaults to "default")
 $config['enable_cache'] = false; 		// Enable caching
--- a/index.php
+++ b/index.php
@ -11,8 +11,8 @@ define('THEMES_DIR', ROOT_DIR .'themes/');
 define('CACHE_DIR', LIB_DIR .'cache/');
 require('config.php');
 require(ROOT_DIR .'vendor/autoload.php');
 require(LIB_DIR .'markdown.php');
 require(LIB_DIR .'twig/lib/Twig/Autoloader.php');
 require(LIB_DIR .'pico.php');
 $pico = new Pico();
--- a/lib/twig/bin/create_pear_package.php
+++ b/lib/twig/bin/create_pear_package.php
@ -1,42 +0,0 @@
 <?php
 if (!isset($argv[1]))
 {
    die('You must provide the version (1.0.0)');
 }
 if (!isset($argv[2]))
 {
    die('You must provide the stability (alpha, beta, or stable)');
 }
 $context = array(
    'date'          => date('Y-m-d'),
    'time'          => date('H:m:00'),
    'version'       => $argv[1],
    'api_version'   => $argv[1],
    'stability'     => $argv[2],
    'api_stability' => $argv[2],
 );
 $context['files'] = '';
 $path = realpath(dirname(__FILE__).'/../lib/Twig');
 foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::LEAVES_ONLY) as $file)
 {
    if (preg_match('/\.php$/', $file))
    {
        $name = str_replace($path.'/', '', $file);
        $context['files'] .= '        <file install-as="Twig/'.$name.'" name="'.$name.'" role="php" />'."\n";
    }
 }
 $template = file_get_contents(dirname(__FILE__).'/../package.xml.tpl');
 $content = preg_replace_callback('/\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/', 'replace_parameters', $template);
 file_put_contents(dirname(__FILE__).'/../package.xml', $content);
 function replace_parameters($matches)
 {
    global $context;
    return isset($context[$matches[1]]) ? $context[$matches[1]] : null;
 }
--- a/lib/twig/doc/advanced.rst
+++ b/lib/twig/doc/advanced.rst
@ -1,489 +0,0 @@
 Extending Twig
 ==============
 Twig can be extended in many ways; you can add extra tags, filters, tests,
 operators, global variables, and functions. You can even extend the parser
 itself with node visitors.
 .. note::
    This chapter describes how to extend Twig easily. If you want to reuse
    your changes in different projects or if you want to share them with
    others, you should then create an extension as described in the next
    chapter.
 Before extending Twig, you must understand the differences between all the
 different possible extension points and when to use them.
 First, remember that Twig has two main language constructs:
 * ``{{ }}``: used to print the result of an expression evaluation;
 * ``{% %}``: used to execute statements.
 To understand why Twig exposes so many extension points, let's see how to
 implement a *Lorem ipsum* generator (it needs to know the number of words to
 generate).
 You can use a ``lipsum`` *tag*:
 .. code-block:: jinja
    {% lipsum 40 %}
 That works, but using a tag for ``lipsum`` is not a good idea for at least
 three main reasons:
 * ``lipsum`` is not a language construct;
 * The tag outputs something;
 * The tag is not flexible as you cannot use it in an expression:
  .. code-block:: jinja
      {{ 'some text' ~ {% lipsum 40 %} ~ 'some more text' }}
 In fact, you rarely need to create tags; and that's good news because tags are
 the most complex extension point of Twig.
 Now, let's use a ``lipsum`` *filter*:
 .. code-block:: jinja
    {{ 40|lipsum }}
 Again, it works, but it looks weird. A filter transforms the passed value to
 something else but here we use the value to indicate the number of words to
 generate.
 Next, let's use a ``lipsum`` *function*:
 .. code-block:: jinja
    {{ lipsum(40) }}
 Here we go. For this specific example, the creation of a function is the
 extension point to use. And you can use it anywhere an expression is accepted:
 .. code-block:: jinja
    {{ 'some text' ~ ipsum(40) ~ 'some more text' }}
    {% set ipsum = ipsum(40) %}
 Last but not the least, you can also use a *global* object with a method able
 to generate lorem ipsum text:
 .. code-block:: jinja
    {{ text.lipsum(40) }}
 As a rule of thumb, use functions for frequently used features and global
 objects for everything else.
 Keep in mind the following when you want to extend Twig:
 ========== ========================== ========== =========================
 What?      Implementation difficulty? How often? When?
 ========== ========================== ========== =========================
 *macro*    trivial                    frequent   Content generation
 *global*   trivial                    frequent   Helper object
 *function* trivial                    frequent   Content generation
 *filter*   trivial                    frequent   Value transformation
 *tag*      complex                    rare       DSL language construct
 *test*     trivial                    rare       Boolean decision
 *operator* trivial                    rare       Values transformation
 ========== ========================== ========== =========================
 Globals
 -------
 A global variable is like any other template variable, except that it's
 available in all templates and macros::
    $twig = new Twig_Environment($loader);
    $twig->addGlobal('text', new Text());
 You can then use the ``text`` variable anywhere in a template:
 .. code-block:: jinja
    {{ text.lipsum(40) }}
 Filters
 -------
 A filter is a regular PHP function or an object method that takes the left
 side of the filter (before the pipe ``|``) as first argument and the extra
 arguments passed to the filter (within parentheses ``()``) as extra arguments.
 Defining a filter is as easy as associating the filter name with a PHP
 callable. For instance, let's say you have the following code in a template:
 .. code-block:: jinja
    {{ 'TWIG'|lower }}
 When compiling this template to PHP, Twig looks for the PHP callable
 associated with the ``lower`` filter. The ``lower`` filter is a built-in Twig
 filter, and it is simply mapped to the PHP ``strtolower()`` function. After
 compilation, the generated PHP code is roughly equivalent to:
 .. code-block:: html+php
    <?php echo strtolower('TWIG') ?>
 As you can see, the ``'TWIG'`` string is passed as a first argument to the PHP
 function.
 A filter can also take extra arguments like in the following example:
 .. code-block:: jinja
    {{ now|date('d/m/Y') }}
 In this case, the extra arguments are passed to the function after the main
 argument, and the compiled code is equivalent to:
 .. code-block:: html+php
    <?php echo twig_date_format_filter($now, 'd/m/Y') ?>
 Let's see how to create a new filter.
 In this section, we will create a ``rot13`` filter, which should return the
 `rot13`_ transformation of a string. Here is an example of its usage and the
 expected output:
 .. code-block:: jinja
    {{ "Twig"|rot13 }}
    {# should displays Gjvt #}
 Adding a filter is as simple as calling the ``addFilter()`` method on the
 ``Twig_Environment`` instance::
    $twig = new Twig_Environment($loader);
    $twig->addFilter('rot13', new Twig_Filter_Function('str_rot13'));
 The second argument of ``addFilter()`` is an instance of ``Twig_Filter``.
 Here, we use ``Twig_Filter_Function`` as the filter is a PHP function. The
 first argument passed to the ``Twig_Filter_Function`` constructor is the name
 of the PHP function to call, here ``str_rot13``, a native PHP function.
 Let's say I now want to be able to add a prefix before the converted string:
 .. code-block:: jinja
    {{ "Twig"|rot13('prefix_') }}
    {# should displays prefix_Gjvt #}
 As the PHP ``str_rot13()`` function does not support this requirement, let's
 create a new PHP function::
    function project_compute_rot13($string, $prefix = '')
    {
        return $prefix.str_rot13($string);
    }
 As you can see, the ``prefix`` argument of the filter is passed as an extra
 argument to the ``project_compute_rot13()`` function.
 Adding this filter is as easy as before::
    $twig->addFilter('rot13', new Twig_Filter_Function('project_compute_rot13'));
 For better encapsulation, a filter can also be defined as a static method of a
 class. The ``Twig_Filter_Function`` class can also be used to register such
 static methods as filters::
    $twig->addFilter('rot13', new Twig_Filter_Function('SomeClass::rot13Filter'));
 .. tip::
    In an extension, you can also define a filter as a static method of the
    extension class.
 Environment aware Filters
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 The ``Twig_Filter`` classes take options as their last argument. For instance,
 if you want access to the current environment instance in your filter, set the
 ``needs_environment`` option to ``true``::
    $filter = new Twig_Filter_Function('str_rot13', array('needs_environment' => true));
 Twig will then pass the current environment as the first argument to the
 filter call::
    function twig_compute_rot13(Twig_Environment $env, $string)
    {
        // get the current charset for instance
        $charset = $env->getCharset();
        return str_rot13($string);
    }
 Automatic Escaping
 ~~~~~~~~~~~~~~~~~~
 If automatic escaping is enabled, the output of the filter may be escaped
 before printing. If your filter acts as an escaper (or explicitly outputs html
 or javascript code), you will want the raw output to be printed. In such a
 case, set the ``is_safe`` option::
    $filter = new Twig_Filter_Function('nl2br', array('is_safe' => array('html')));
 Some filters may have to work on already escaped or safe values. In such a
 case, set the ``pre_escape`` option::
    $filter = new Twig_Filter_Function('somefilter', array('pre_escape' => 'html', 'is_safe' => array('html')));
 Dynamic Filters
 ~~~~~~~~~~~~~~~
 .. versionadded:: 1.5
    Dynamic filters support was added in Twig 1.5.
 A filter name containing the special ``*`` character is a dynamic filter as
 the ``*`` can be any string::
    $twig->addFilter('*_path', new Twig_Filter_Function('twig_path'));
    function twig_path($name, $arguments)
    {
        // ...
    }
 The following filters will be matched by the above defined dynamic filter:
 * ``product_path``
 * ``category_path``
 A dynamic filter can define more than one dynamic parts::
    $twig->addFilter('*_path_*', new Twig_Filter_Function('twig_path'));
    function twig_path($name, $suffix, $arguments)
    {
        // ...
    }
 The filter will receive all dynamic part values before the normal filters
 arguments. For instance, a call to ``'foo'|a_path_b()`` will result in the
 following PHP call: ``twig_path('a', 'b', 'foo')``.
 Functions
 ---------
 A function is a regular PHP function or an object method that can be called from
 templates.
 .. code-block:: jinja
    {{ constant("DATE_W3C") }}
 When compiling this template to PHP, Twig looks for the PHP callable
 associated with the ``constant`` function. The ``constant`` function is a built-in Twig
 function, and it is simply mapped to the PHP ``constant()`` function. After
 compilation, the generated PHP code is roughly equivalent to:
 .. code-block:: html+php
    <?php echo constant('DATE_W3C') ?>
 Adding a function is similar to adding a filter. This can be done by calling the
 ``addFunction()`` method on the ``Twig_Environment`` instance::
    $twig = new Twig_Environment($loader);
    $twig->addFunction('functionName', new Twig_Function_Function('someFunction'));
 You can also expose extension methods as functions in your templates::
    // $this is an object that implements Twig_ExtensionInterface.
    $twig = new Twig_Environment($loader);
    $twig->addFunction('otherFunction', new Twig_Function_Method($this, 'someMethod'));
 Functions also support ``needs_environment`` and ``is_safe`` parameters.
 Dynamic Functions
 ~~~~~~~~~~~~~~~~~
 .. versionadded:: 1.5
    Dynamic functions support was added in Twig 1.5.
 A function name containing the special ``*`` character is a dynamic function
 as the ``*`` can be any string::
    $twig->addFunction('*_path', new Twig_Function_Function('twig_path'));
    function twig_path($name, $arguments)
    {
        // ...
    }
 The following functions will be matched by the above defined dynamic function:
 * ``product_path``
 * ``category_path``
 A dynamic function can define more than one dynamic parts::
    $twig->addFilter('*_path_*', new Twig_Filter_Function('twig_path'));
    function twig_path($name, $suffix, $arguments)
    {
        // ...
    }
 The function will receive all dynamic part values before the normal functions
 arguments. For instance, a call to ``a_path_b('foo')`` will result in the
 following PHP call: ``twig_path('a', 'b', 'foo')``.
 Tags
 ----
 One of the most exciting feature of a template engine like Twig is the
 possibility to define new language constructs. This is also the most complex
 feature as you need to understand how Twig's internals work.
 Let's create a simple ``set`` tag that allows the definition of simple
 variables from within a template. The tag can be used like follows:
 .. code-block:: jinja
    {% set name = "value" %}
    {{ name }}
    {# should output value #}
 .. note::
    The ``set`` tag is part of the Core extension and as such is always
    available. The built-in version is slightly more powerful and supports
    multiple assignments by default (cf. the template designers chapter for
    more information).
 Three steps are needed to define a new tag:
 * Defining a Token Parser class (responsible for parsing the template code);
 * Defining a Node class (responsible for converting the parsed code to PHP);
 * Registering the tag.
 Registering a new tag
 ~~~~~~~~~~~~~~~~~~~~~
 Adding a tag is as simple as calling the ``addTokenParser`` method on the
 ``Twig_Environment`` instance::
    $twig = new Twig_Environment($loader);
    $twig->addTokenParser(new Project_Set_TokenParser());
 Defining a Token Parser
 ~~~~~~~~~~~~~~~~~~~~~~~
 Now, let's see the actual code of this class::
    class Project_Set_TokenParser extends Twig_TokenParser
    {
        public function parse(Twig_Token $token)
        {
            $lineno = $token->getLine();
            $name = $this->parser->getStream()->expect(Twig_Token::NAME_TYPE)->getValue();
            $this->parser->getStream()->expect(Twig_Token::OPERATOR_TYPE, '=');
            $value = $this->parser->getExpressionParser()->parseExpression();
            $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
            return new Project_Set_Node($name, $value, $lineno, $this->getTag());
        }
        public function getTag()
        {
            return 'set';
        }
    }
 The ``getTag()`` method must return the tag we want to parse, here ``set``.
 The ``parse()`` method is invoked whenever the parser encounters a ``set``
 tag. It should return a ``Twig_Node`` instance that represents the node (the
 ``Project_Set_Node`` calls creating is explained in the next section).
 The parsing process is simplified thanks to a bunch of methods you can call
 from the token stream (``$this->parser->getStream()``):
 * ``getCurrent()``: Gets the current token in the stream.
 * ``next()``: Moves to the next token in the stream, *but returns the old one*.
 * ``test($type)``, ``test($value)`` or ``test($type, $value)``: Determines whether
  the current token is of a particular type or value (or both). The value may be an
  array of several possible values.
 * ``expect($type[, $value[, $message]])``: If the current token isn't of the given
  type/value a syntax error is thrown. Otherwise, if the type and value are correct,
  the token is returned and the stream moves to the next token.
 * ``look()``: Looks a the next token without consuming it.
 Parsing expressions is done by calling the ``parseExpression()`` like we did for
 the ``set`` tag.
 .. tip::
    Reading the existing ``TokenParser`` classes is the best way to learn all
    the nitty-gritty details of the parsing process.
 Defining a Node
 ~~~~~~~~~~~~~~~
 The ``Project_Set_Node`` class itself is rather simple::
    class Project_Set_Node extends Twig_Node
    {
        public function __construct($name, Twig_Node_Expression $value, $lineno, $tag = null)
        {
            parent::__construct(array('value' => $value), array('name' => $name), $lineno, $tag);
        }
        public function compile(Twig_Compiler $compiler)
        {
            $compiler
                ->addDebugInfo($this)
                ->write('$context[\''.$this->getAttribute('name').'\'] = ')
                ->subcompile($this->getNode('value'))
                ->raw(";\n")
            ;
        }
    }
 The compiler implements a fluid interface and provides methods that helps the
 developer generate beautiful and readable PHP code:
 * ``subcompile()``: Compiles a node.
 * ``raw()``: Writes the given string as is.
 * ``write()``: Writes the given string by adding indentation at the beginning
  of each line.
 * ``string()``: Writes a quoted string.
 * ``repr()``: Writes a PHP representation of a given value (see
  ``Twig_Node_For`` for a usage example).
 * ``addDebugInfo()``: Adds the line of the original template file related to
  the current node as a comment.
 * ``indent()``: Indents the generated code (see ``Twig_Node_Block`` for a
  usage example).
 * ``outdent()``: Outdents the generated code (see ``Twig_Node_Block`` for a
  usage example).
 .. _`rot13`: http://www.php.net/manual/en/function.str-rot13.php
--- a/lib/twig/doc/api.rst
+++ b/lib/twig/doc/api.rst
@ -1,479 +0,0 @@
 Twig for Developers
 ===================
 This chapter describes the API to Twig and not the template language. It will
 be most useful as reference to those implementing the template interface to
 the application and not those who are creating Twig templates.
 Basics
 ------
 Twig uses a central object called the **environment** (of class
 ``Twig_Environment``). Instances of this class are used to store the
 configuration and extensions, and are used to load templates from the file
 system or other locations.
 Most applications will create one ``Twig_Environment`` object on application
 initialization and use that to load templates. In some cases it's however
 useful to have multiple environments side by side, if different configurations
 are in use.
 The simplest way to configure Twig to load templates for your application
 looks roughly like this::
    require_once '/path/to/lib/Twig/Autoloader.php';
    Twig_Autoloader::register();
    $loader = new Twig_Loader_Filesystem('/path/to/templates');
    $twig = new Twig_Environment($loader, array(
        'cache' => '/path/to/compilation_cache',
    ));
 This will create a template environment with the default settings and a loader
 that looks up the templates in the ``/path/to/templates/`` folder. Different
 loaders are available and you can also write your own if you want to load
 templates from a database or other resources.
 .. note::
    Notice that the second argument of the environment is an array of options.
    The ``cache`` option is a compilation cache directory, where Twig caches
    the compiled templates to avoid the parsing phase for sub-sequent
    requests. It is very different from the cache you might want to add for
    the evaluated templates. For such a need, you can use any available PHP
    cache library.
 To load a template from this environment you just have to call the
 ``loadTemplate()`` method which then returns a ``Twig_Template`` instance::
    $template = $twig->loadTemplate('index.html');
 To render the template with some variables, call the ``render()`` method::
    echo $template->render(array('the' => 'variables', 'go' => 'here'));
 .. note::
    The ``display()`` method is a shortcut to output the template directly.
 You can also load and render the template in one fell swoop::
    echo $twig->render('index.html', array('the' => 'variables', 'go' => 'here'));
 Environment Options
 -------------------
 When creating a new ``Twig_Environment`` instance, you can pass an array of
 options as the constructor second argument::
    $twig = new Twig_Environment($loader, array('debug' => true));
 The following options are available:
 * ``debug``: When set to ``true``, the generated templates have a
  ``__toString()`` method that you can use to display the generated nodes
  (default to ``false``).
 * ``charset``: The charset used by the templates (default to ``utf-8``).
 * ``base_template_class``: The base template class to use for generated
  templates (default to ``Twig_Template``).
 * ``cache``: An absolute path where to store the compiled templates, or
  ``false`` to disable caching (which is the default).
 * ``auto_reload``: When developing with Twig, it's useful to recompile the
  template whenever the source code changes. If you don't provide a value for
  the ``auto_reload`` option, it will be determined automatically based on the
  ``debug`` value.
 * ``strict_variables``: If set to ``false``, Twig will silently ignore invalid
  variables (variables and or attributes/methods that do not exist) and
  replace them with a ``null`` value. When set to ``true``, Twig throws an
  exception instead (default to ``false``).
 * ``autoescape``: If set to ``true``, auto-escaping will be enabled by default
  for all templates (default to ``true``).
 * ``optimizations``: A flag that indicates which optimizations to apply
  (default to ``-1`` -- all optimizations are enabled; set it to ``0`` to
  disable).
 Loaders
 -------
 Loaders are responsible for loading templates from a resource such as the file
 system.
 Compilation Cache
 ~~~~~~~~~~~~~~~~~
 All template loaders can cache the compiled templates on the filesystem for
 future reuse. It speeds up Twig a lot as templates are only compiled once; and
 the performance boost is even larger if you use a PHP accelerator such as APC.
 See the ``cache`` and ``auto_reload`` options of ``Twig_Environment`` above
 for more information.
 Built-in Loaders
 ~~~~~~~~~~~~~~~~
 Here is a list of the built-in loaders Twig provides:
 * ``Twig_Loader_Filesystem``: Loads templates from the file system. This
  loader can find templates in folders on the file system and is the preferred
  way to load them::
        $loader = new Twig_Loader_Filesystem($templateDir);
  It can also look for templates in an array of directories::
        $loader = new Twig_Loader_Filesystem(array($templateDir1, $templateDir2));
  With such a configuration, Twig will first look for templates in
  ``$templateDir1`` and if they do not exist, it will fallback to look for
  them in the ``$templateDir2``.
 * ``Twig_Loader_String``: Loads templates from a string. It's a dummy loader
  as you pass it the source code directly::
        $loader = new Twig_Loader_String();
 * ``Twig_Loader_Array``: Loads a template from a PHP array. It's passed an
  array of strings bound to template names. This loader is useful for unit
  testing::
        $loader = new Twig_Loader_Array($templates);
 .. tip::
    When using the ``Array`` or ``String`` loaders with a cache mechanism, you
    should know that a new cache key is generated each time a template content
    "changes" (the cache key being the source code of the template). If you
    don't want to see your cache grows out of control, you need to take care
    of clearing the old cache file by yourself.
 Create your own Loader
 ~~~~~~~~~~~~~~~~~~~~~~
 All loaders implement the ``Twig_LoaderInterface``::
    interface Twig_LoaderInterface
    {
        /**
         * Gets the source code of a template, given its name.
         *
         * @param  string $name string The name of the template to load
         *
         * @return string The template source code
         */
        function getSource($name);
        /**
         * Gets the cache key to use for the cache for a given template name.
         *
         * @param  string $name string The name of the template to load
         *
         * @return string The cache key
         */
        function getCacheKey($name);
        /**
         * Returns true if the template is still fresh.
         *
         * @param string    $name The template name
         * @param timestamp $time The last modification time of the cached template
         */
        function isFresh($name, $time);
    }
 As an example, here is how the built-in ``Twig_Loader_String`` reads::
    class Twig_Loader_String implements Twig_LoaderInterface
    {
        public function getSource($name)
        {
          return $name;
        }
        public function getCacheKey($name)
        {
          return $name;
        }
        public function isFresh($name, $time)
        {
          return false;
        }
    }
 The ``isFresh()`` method must return ``true`` if the current cached template
 is still fresh, given the last modification time, or ``false`` otherwise.
 Using Extensions
 ----------------
 Twig extensions are packages that add new features to Twig. Using an
 extension is as simple as using the ``addExtension()`` method::
    $twig->addExtension(new Twig_Extension_Sandbox());
 Twig comes bundled with the following extensions:
 * *Twig_Extension_Core*: Defines all the core features of Twig.
 * *Twig_Extension_Escaper*: Adds automatic output-escaping and the possibility
  to escape/unescape blocks of code.
 * *Twig_Extension_Sandbox*: Adds a sandbox mode to the default Twig
  environment, making it safe to evaluated untrusted code.
 * *Twig_Extension_Optimizer*: Optimizers the node tree before compilation.
 The core, escaper, and optimizer extensions do not need to be added to the
 Twig environment, as they are registered by default. You can disable an
 already registered extension::
    $twig->removeExtension('escaper');
 Built-in Extensions
 -------------------
 This section describes the features added by the built-in extensions.
 .. tip::
    Read the chapter about extending Twig to learn how to create your own
    extensions.
 Core Extension
 ~~~~~~~~~~~~~~
 The ``core`` extension defines all the core features of Twig:
 * Tags:
  * ``for``
  * ``if``
  * ``extends``
  * ``include``
  * ``block``
  * ``filter``
  * ``macro``
  * ``import``
  * ``from``
  * ``set``
  * ``spaceless``
 * Filters:
  * ``date``
  * ``format``
  * ``replace``
  * ``url_encode``
  * ``json_encode``
  * ``title``
  * ``capitalize``
  * ``upper``
  * ``lower``
  * ``striptags``
  * ``join``
  * ``reverse``
  * ``length``
  * ``sort``
  * ``merge``
  * ``default``
  * ``keys``
  * ``escape``
  * ``e``
 * Functions:
  * ``range``
  * ``constant``
  * ``cycle``
  * ``parent``
  * ``block``
 * Tests:
  * ``even``
  * ``odd``
  * ``defined``
  * ``sameas``
  * ``null``
  * ``divisibleby``
  * ``constant``
  * ``empty``
 Escaper Extension
 ~~~~~~~~~~~~~~~~~
 The ``escaper`` extension adds automatic output escaping to Twig. It defines a
 new tag, ``autoescape``, and a new filter, ``raw``.
 When creating the escaper extension, you can switch on or off the global
 output escaping strategy::
    $escaper = new Twig_Extension_Escaper(true);
    $twig->addExtension($escaper);
 If set to ``true``, all variables in templates are escaped, except those using
 the ``raw`` filter:
 .. code-block:: jinja
    {{ article.to_html|raw }}
 You can also change the escaping mode locally by using the ``autoescape`` tag:
 .. code-block:: jinja
    {% autoescape true %}
      {{ var }}
      {{ var|raw }}      {# var won't be escaped #}
      {{ var|escape }}   {# var won't be double-escaped #}
    {% endautoescape %}
 .. warning::
    The ``autoescape`` tag has no effect on included files.
 The escaping rules are implemented as follows:
 * Literals (integers, booleans, arrays, ...) used in the template directly as
  variables or filter arguments are never automatically escaped:
  .. code-block:: jinja
        {{ "Twig<br />" }} {# won't be escaped #}
        {% set text = "Twig<br />" %}
        {{ text }} {# will be escaped #}
 * Expressions which the result is always a literal or a variable marked safe
  are never automatically escaped:
  .. code-block:: jinja
        {{ foo ? "Twig<br />" : "<br />Twig" }} {# won't be escaped #}
        {% set text = "Twig<br />" %}
        {{ foo ? text : "<br />Twig" }} {# will be escaped #}
        {% set text = "Twig<br />" %}
        {{ foo ? text|raw : "<br />Twig" }} {# won't be escaped #}
        {% set text = "Twig<br />" %}
        {{ foo ? text|escape : "<br />Twig" }} {# the result of the expression won't be escaped #}
 * Escaping is applied before printing, after any other filter is applied:
  .. code-block:: jinja
        {{ var|upper }} {# is equivalent to {{ var|upper|escape }} #}
 * The `raw` filter should only be used at the end of the filter chain:
  .. code-block:: jinja
        {{ var|raw|upper }} {# will be escaped #}
        {{ var|upper|raw }} {# won't be escaped #}
 * Automatic escaping is not applied if the last filter in the chain is marked
  safe for the current context (e.g. ``html`` or ``js``). ``escaper`` and
  ``escaper('html')`` are marked safe for html, ``escaper('js')`` is marked
  safe for javascript, ``raw`` is marked safe for everything.
  .. code-block:: jinja
        {% autoescape true js %}
        {{ var|escape('html') }} {# will be escaped for html and javascript #}
        {{ var }} {# will be escaped for javascript #}
        {{ var|escape('js') }} {# won't be double-escaped #}
        {% endautoescape %}
 .. note::
    Note that autoescaping has some limitations as escaping is applied on
    expressions after evaluation. For instance, when working with
    concatenation, ``{{ foo|raw ~ bar }}`` won't give the expected result as
    escaping is applied on the result of the concatenation, not on the
    individual variables (so, the ``raw`` filter won't have any effect here).
 Sandbox Extension
 ~~~~~~~~~~~~~~~~~
 The ``sandbox`` extension can be used to evaluate untrusted code. Access to
 unsafe attributes and methods is prohibited. The sandbox security is managed
 by a policy instance. By default, Twig comes with one policy class:
 ``Twig_Sandbox_SecurityPolicy``. This class allows you to white-list some
 tags, filters, properties, and methods::
    $tags = array('if');
    $filters = array('upper');
    $methods = array(
        'Article' => array('getTitle', 'getBody'),
    );
    $properties = array(
        'Article' => array('title', 'body'),
    );
    $functions = array('range');
    $policy = new Twig_Sandbox_SecurityPolicy($tags, $filters, $methods, $properties, $functions);
 With the previous configuration, the security policy will only allow usage of
 the ``if`` tag, and the ``upper`` filter. Moreover, the templates will only be
 able to call the ``getTitle()`` and ``getBody()`` methods on ``Article``
 objects, and the ``title`` and ``body`` public properties. Everything else
 won't be allowed and will generate a ``Twig_Sandbox_SecurityError`` exception.
 The policy object is the first argument of the sandbox constructor::
    $sandbox = new Twig_Extension_Sandbox($policy);
    $twig->addExtension($sandbox);
 By default, the sandbox mode is disabled and should be enabled when including
 untrusted template code by using the ``sandbox`` tag:
 .. code-block:: jinja
    {% sandbox %}
        {% include 'user.html' %}
    {% endsandbox %}
 You can sandbox all templates by passing ``true`` as the second argument of
 the extension constructor::
    $sandbox = new Twig_Extension_Sandbox($policy, true);
 Optimizer Extension
 ~~~~~~~~~~~~~~~~~~~
 The ``optimizer`` extension optimizes the node tree before compilation::
    $twig->addExtension(new Twig_Extension_Optimizer());
 By default, all optimizations are turned on. You can select the ones you want
 to enable by passing them to the constructor::
    $optimizer = new Twig_Extension_Optimizer(Twig_NodeVisitor_Optimizer::OPTIMIZE_FOR);
    $twig->addExtension($optimizer);
 Exceptions
 ----------
 Twig can throw exceptions:
 * ``Twig_Error``: The base exception for all errors.
 * ``Twig_Error_Syntax``: Thrown to tell the user that there is a problem with
  the template syntax.
 * ``Twig_Error_Runtime``: Thrown when an error occurs at runtime (when a filter
  does not exist for instance).
 * ``Twig_Error_Loader``: Thrown when an error occurs during template loading.
 * ``Twig_Sandbox_SecurityError``: Thrown when an unallowed tag, filter, or
  method is called in a sandboxed template.
--- a/lib/twig/doc/coding_standards.rst
+++ b/lib/twig/doc/coding_standards.rst
@ -1,101 +0,0 @@
 Coding Standards
 ================
 When writing Twig templates, we recommend you to follow these official coding
 standards:
 * Put one (and only one) space after the start of a delimiter (``{{``, ``{%``,
  and ``{#``) and before the end of a delimiter (``}}``, ``%}``, and ``#}``):
  .. code-block:: jinja
    {{ foo }}
    {# comment #}
    {% if foo %}{% endif %}
  When using the whitespace control character, do not put any spaces between
  it and the delimiter:
  .. code-block:: jinja
    {{- foo -}}
    {#- comment -#}
    {%- if foo -%}{%- endif -%}
 * Put one (and only one) space before and after the following operators:
  comparison operators (``==``, ``!=``, ``<``, ``>``, ``>=``, ``<=``), math
  operators (``+``, ``-``, ``/``, ``*``, ``%``, ``//``, ``**``), logic
  operators (``not``, ``and``, ``or``), ``~``, ``is``, ``in``, and the ternary
  operator (``?:``):
  .. code-block:: jinja
     {{ 1 + 2 }}
     {{ foo ~ bar }}
     {{ true ? true : false }}
 * Put one (and only one) space after the ``:`` sign in hashes and ``,`` in
  arrays and hashes:
  .. code-block:: jinja
     {{ [1, 2, 3] }}
     {{ {'foo': 'bar'} }}
 * Do not put any spaces after an opening parenthesis and before a closing
  parenthesis in expressions:
  .. code-block:: jinja
    {{ 1 + (2 * 3) }}
 * Do not put any spaces before and after string delimiters:
  .. code-block:: jinja
    {{ 'foo' }}
    {{ "foo" }}
 * Do not put any spaces before and after the following operators: ``|``,
  ``.``, ``..``, ``[]``:
  .. code-block:: jinja
    {{ foo|upper|lower }}
    {{ user.name }}
    {{ user[name] }}
    {% for i in 1..12 %}{% endfor %}
 * Do not put any spaces before and after the parenthesis used for filter and
  function calls:
  .. code-block:: jinja
     {{ foo|default('foo') }}
     {{ range(1..10) }}
 * Do not put any spaces before and after the opening and the closing of arrays
  and hashes:
  .. code-block:: jinja
     {{ [1, 2, 3] }}
     {{ {'foo': 'bar'} }}
 * Use lower cased and underscored variable names:
  .. code-block:: jinja
     {% set foo = 'foo' %}
     {% set foo_bar = 'foo' %}
 * Indent your code inside tags (use the same indentation as the one used for
  the main language of the file):
  .. code-block:: jinja
     {% block foo %}
        {% if true %}
            true
        {% endif %}
     {% endblock %}
--- a/lib/twig/doc/extensions.rst
+++ b/lib/twig/doc/extensions.rst
@ -1,328 +0,0 @@
 Creating a Twig Extension
 =========================
 The main motivation for writing an extension is to move often used code into a
 reusable class like adding support for internationalization. An extension can
 define tags, filters, tests, operators, global variables, functions, and node
 visitors.
 Creating an extension also makes for a better separation of code that is
 executed at compilation time and code needed at runtime. As such, it makes
 your code faster.
 Most of the time, it is useful to create a single extension for your project,
 to host all the specific tags and filters you want to add to Twig.
 .. note::
    Before writing your own extensions, have a look at the Twig official
    extension repository: http://github.com/fabpot/Twig-extensions.
 An extension is a class that implements the following interface::
    interface Twig_ExtensionInterface
    {
        /**
         * Initializes the runtime environment.
         *
         * This is where you can load some file that contains filter functions for instance.
         *
         * @param Twig_Environment $environment The current Twig_Environment instance
         */
        function initRuntime(Twig_Environment $environment);
        /**
         * Returns the token parser instances to add to the existing list.
         *
         * @return array An array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances
         */
        function getTokenParsers();
        /**
         * Returns the node visitor instances to add to the existing list.
         *
         * @return array An array of Twig_NodeVisitorInterface instances
         */
        function getNodeVisitors();
        /**
         * Returns a list of filters to add to the existing list.
         *
         * @return array An array of filters
         */
        function getFilters();
        /**
         * Returns a list of tests to add to the existing list.
         *
         * @return array An array of tests
         */
        function getTests();
        /**
         * Returns a list of functions to add to the existing list.
         *
         * @return array An array of functions
         */
        function getFunctions();
        /**
         * Returns a list of operators to add to the existing list.
         *
         * @return array An array of operators
         */
        function getOperators();
        /**
         * Returns a list of global variables to add to the existing list.
         *
         * @return array An array of global variables
         */
        function getGlobals();
        /**
         * Returns the name of the extension.
         *
         * @return string The extension name
         */
        function getName();
    }
 To keep your extension class clean and lean, it can inherit from the built-in
 ``Twig_Extension`` class instead of implementing the whole interface. That
 way, you just need to implement the ``getName()`` method as the
 ``Twig_Extension`` provides empty implementations for all other methods.
 The ``getName()`` method must return a unique identifier for your extension.
 Now, with this information in mind, let's create the most basic extension
 possible::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getName()
        {
            return 'project';
        }
    }
 .. note::
    Of course, this extension does nothing for now. We will customize it in
    the next sections.
 Twig does not care where you save your extension on the filesystem, as all
 extensions must be registered explicitly to be available in your templates.
 You can register an extension by using the ``addExtension()`` method on your
 main ``Environment`` object::
    $twig = new Twig_Environment($loader);
    $twig->addExtension(new Project_Twig_Extension());
 Of course, you need to first load the extension file by either using
 ``require_once()`` or by using an autoloader (see `spl_autoload_register()`_).
 .. tip::
    The bundled extensions are great examples of how extensions work.
 Globals
 -------
 Global variables can be registered in an extension via the ``getGlobals()``
 method::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getGlobals()
        {
            return array(
                'text' => new Text(),
            );
        }
        // ...
    }
 Functions
 ---------
 Functions can be registered in an extension via the ``getFunctions()``
 method::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getFunctions()
        {
            return array(
                'lipsum' => new Twig_Function_Function('generate_lipsum'),
            );
        }
        // ...
    }
 Filters
 -------
 To add a filter to an extension, you need to override the ``getFilters()``
 method. This method must return an array of filters to add to the Twig
 environment::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getFilters()
        {
            return array(
                'rot13' => new Twig_Filter_Function('str_rot13'),
            );
        }
        // ...
    }
 As you can see in the above code, the ``getFilters()`` method returns an array
 where keys are the name of the filters (``rot13``) and the values the
 definition of the filter (``new Twig_Filter_Function('str_rot13')``).
 As seen in the previous chapter, you can also define filters as static methods
 on the extension class::
 $twig->addFilter('rot13', new Twig_Filter_Function('Project_Twig_Extension::rot13Filter'));
 You can also use ``Twig_Filter_Method`` instead of ``Twig_Filter_Function``
 when defining a filter to use a method::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getFilters()
        {
            return array(
                'rot13' => new Twig_Filter_Method($this, 'rot13Filter'),
            );
        }
        public function rot13Filter($string)
        {
            return str_rot13($string);
        }
        // ...
    }
 The first argument of the ``Twig_Filter_Method`` constructor is always
 ``$this``, the current extension object. The second one is the name of the
 method to call.
 Using methods for filters is a great way to package your filter without
 polluting the global namespace. This also gives the developer more flexibility
 at the cost of a small overhead.
 Overriding default Filters
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 If some default core filters do not suit your needs, you can easily override
 them by creating your own core extension. Of course, you don't need to copy
 and paste the whole core extension code of Twig. Instead, you can just extends
 it and override the filter(s) you want by overriding the ``getFilters()``
 method::
    class MyCoreExtension extends Twig_Extension_Core
    {
        public function getFilters()
        {
            return array_merge(parent::getFilters(), array(
                'date' => new Twig_Filter_Method($this, 'dateFilter'),
                // ...
            ));
        }
        public function dateFilter($timestamp, $format = 'F j, Y H:i')
        {
            return '...'.twig_date_format_filter($timestamp, $format);
        }
        // ...
    }
 Here, we override the ``date`` filter with a custom one. Using this new core
 extension is as simple as registering the ``MyCoreExtension`` extension by
 calling the ``addExtension()`` method on the environment instance::
    $twig = new Twig_Environment($loader);
    $twig->addExtension(new MyCoreExtension());
 But I can already hear some people wondering how it can work as the Core
 extension is loaded by default. That's true, but the trick is that both
 extensions share the same unique identifier (``core`` - defined in the
 ``getName()`` method). By registering an extension with the same name as an
 existing one, you have actually overridden the default one, even if it is
 already registered::
    $twig->addExtension(new Twig_Extension_Core());
    $twig->addExtension(new MyCoreExtension());
 Tags
 ----
 Adding a tag in an extension can be done by overriding the
 ``getTokenParsers()`` method. This method must return an array of tags to add
 to the Twig environment::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getTokenParsers()
        {
            return array(new Project_Set_TokenParser());
        }
        // ...
    }
 In the above code, we have added a single new tag, defined by the
 ``Project_Set_TokenParser`` class. The ``Project_Set_TokenParser`` class is
 responsible for parsing the tag and compiling it to PHP.
 Operators
 ---------
 The ``getOperators()`` methods allows to add new operators. Here is how to add
 ``!``, ``||``, and ``&&`` operators::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getOperators()
        {
            return array(
                array(
                    '!' => array('precedence' => 50, 'class' => 'Twig_Node_Expression_Unary_Not'),
                ),
                array(
                    '||' => array('precedence' => 10, 'class' => 'Twig_Node_Expression_Binary_Or', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
                    '&&' => array('precedence' => 15, 'class' => 'Twig_Node_Expression_Binary_And', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
                ),
            );
        }
        // ...
    }
 Tests
 -----
 The ``getTests()`` methods allows to add new test functions::
    class Project_Twig_Extension extends Twig_Extension
    {
        public function getTests()
        {
            return array(
                'even' => new Twig_Test_Function('twig_test_even'),
            );
        }
        // ...
    }
 .. _`spl_autoload_register()`: http://www.php.net/spl_autoload_register
--- a/lib/twig/doc/filters/capitalize.rst
+++ b/lib/twig/doc/filters/capitalize.rst
@ -1,11 +0,0 @@
 ``capitalize``
 ==============
 The ``capitalize`` filter capitalizes a value. The first character will be
 uppercase, all others lowercase:
 .. code-block:: jinja
    {{ 'my first car'|capitalize }}
    {# outputs 'My first car' #}
--- a/lib/twig/doc/filters/convert_encoding.rst
+++ b/lib/twig/doc/filters/convert_encoding.rst
@ -1,22 +0,0 @@
 ``convert_encoding``
 ====================
 .. versionadded:: 1.4
    The ``convert_encoding`` filter was added in Twig 1.4.
 The ``convert_encoding`` filter converts a string from one encoding to
 another. The first argument is the expected output charset and the second one
 is the input charset:
 .. code-block:: jinja
    {{ data|convert_encoding('UTF-8', 'iso-2022-jp') }}
 .. note::
    This filter relies on the `iconv`_ or `mbstring`_ extension, so one of
    them must be installed. In case both are installed, `iconv`_ is used
    by default.
 .. _`iconv`:    http://php.net/iconv
 .. _`mbstring`: http://php.net/mbstring
--- a/lib/twig/doc/filters/date.rst
+++ b/lib/twig/doc/filters/date.rst
@ -1,65 +0,0 @@
 ``date``
 ========
 .. versionadded:: 1.1
    The timezone support has been added in Twig 1.1.
 .. versionadded:: 1.5
    The default date format support has been added in Twig 1.5.
 .. versionadded:: 1.6.1
    The default timezone support has been added in Twig 1.6.1.
 The ``date`` filter formats a date to a given format:
 .. code-block:: jinja
    {{ post.published_at|date("m/d/Y") }}
 The ``date`` filter accepts strings (it must be in a format supported by the
 `date`_ function), `DateTime`_ instances, or `DateInterval`_ instances. For
 instance, to display the current date, filter the word "now":
 .. code-block:: jinja
    {{ "now"|date("m/d/Y") }}
 To escape words and characters in the date format use ``\\`` in front of each character:
 .. code-block:: jinja
    {{ post.published_at|date("F jS \\a\\t g:ia") }}
 You can also specify a timezone:
 .. code-block:: jinja
    {{ post.published_at|date("m/d/Y", "Europe/Paris") }}
 If no format is provided, Twig will use the default one: ``F j, Y H:i``. This
 default can be easily changed by calling the ``setDateFormat()`` method on the
 ``core`` extension instance. The first argument is the default format for
 dates and the second one is the default format for date intervals:
 .. code-block:: php
    $twig = new Twig_Environment($loader);
    $twig->getExtension('core')->setDateFormat('d/m/Y', '%d days');
 The default timezone can also be set globally by calling ``setTimezone()``:
 .. code-block:: php
    $twig = new Twig_Environment($loader);
    $twig->getExtension('core')->setTimezone('Europe/Paris');
 .. _`date`:         http://www.php.net/date
 .. _`DateTime`:     http://www.php.net/DateTime
 .. _`DateInterval`: http://www.php.net/DateInterval
 If the value passed to the ``date`` filter is null, it will return the current date by default.
 If an empty string is desired instead of the current date, use a ternary operator:
 .. code-block:: jinja
    {{ post.published_at is empty ? "" : post.published_at|date("m/d/Y") }}
--- a/lib/twig/doc/filters/default.rst
+++ b/lib/twig/doc/filters/default.rst
@ -1,28 +0,0 @@
 ``default``
 ===========
 The ``default`` filter returns the passed default value if the value is
 undefined or empty, otherwise the value of the variable:
 .. code-block:: jinja
    {{ var|default('var is not defined') }}
    {{ var.foo|default('foo item on var is not defined') }}
    {{ var['foo']|default('foo item on var is not defined') }}
    {{ ''|default('passed var is empty')  }}
 When using the ``default`` filter on an expression that uses variables in some
 method calls, be sure to use the ``default`` filter whenever a variable can be
 undefined:
 .. code-block:: jinja
    {{ var.method(foo|default('foo'))|default('foo') }}
 .. note::
    Read the documentation for the :doc:`defined<../tests/defined>` and
    :doc:`empty<../tests/empty>` tests to learn more about their semantics.
--- a/lib/twig/doc/filters/escape.rst
+++ b/lib/twig/doc/filters/escape.rst
@ -1,30 +0,0 @@
 ``escape``
 ==========
 The ``escape`` filter converts the characters ``&``, ``<``, ``>``, ``'``, and
 ``"`` in strings to HTML-safe sequences. Use this if you need to display text
 that might contain such characters in HTML:
 .. code-block:: jinja
    {{ user.username|escape }}
 For convenience, the ``e`` filter is defined as an alias:
 .. code-block:: jinja
    {{ user.username|e }}
 The ``escape`` filter can also be used in another context than HTML; for
 instance, to escape variables included in a JavaScript:
 .. code-block:: jinja
    {{ user.username|escape('js') }}
    {{ user.username|e('js') }}
 .. note::
    Internally, ``escape`` uses the PHP native `htmlspecialchars`_ function.
 .. _`htmlspecialchars`: http://php.net/htmlspecialchars
--- a/lib/twig/doc/filters/format.rst
+++ b/lib/twig/doc/filters/format.rst
@ -1,16 +0,0 @@
 ``format``
 ==========
 The ``format`` filter formats a given string by replacing the placeholders
 (placeholders follows the `printf`_ notation):
 .. code-block:: jinja
    {{ "I like %s and %s."|format(foo, "bar") }}
    {# returns I like foo and bar
       if the foo parameter equals to the foo string. #}
 .. _`printf`: http://www.php.net/printf
 .. seealso:: :doc:`replace<replace>`
--- a/lib/twig/doc/filters/index.rst
+++ b/lib/twig/doc/filters/index.rst
@ -1,29 +0,0 @@
 Filters
 =======
 .. toctree::
    :maxdepth: 1
    date
    format
    replace
    number_format
    url_encode
    json_encode
    convert_encoding
    title
    capitalize
    nl2br
    upper
    lower
    striptags
    join
    reverse
    length
    sort
    default
    keys
    escape
    raw
    merge
    slice
--- a/lib/twig/doc/filters/join.rst
+++ b/lib/twig/doc/filters/join.rst
@ -1,18 +0,0 @@
 ``join``
 ========
 The ``join`` filter returns a string which is the concatenation of the items
 of a sequence:
 .. code-block:: jinja
    {{ [1, 2, 3]|join }}
    {# returns 123 #}
 The separator between elements is an empty string per default, but you can
 define it with the optional first parameter:
 .. code-block:: jinja
    {{ [1, 2, 3]|join('|') }}
    {# returns 1|2|3 #}
--- a/lib/twig/doc/filters/json_encode.rst
+++ b/lib/twig/doc/filters/json_encode.rst
@ -1,14 +0,0 @@
 ``json_encode``
 ===============
 The ``json_encode`` filter returns the JSON representation of a string:
 .. code-block:: jinja
    {{ data|json_encode() }}
 .. note::
    Internally, Twig uses the PHP `json_encode`_ function.
 .. _`json_encode`: http://php.net/json_encode
--- a/lib/twig/doc/filters/keys.rst
+++ b/lib/twig/doc/filters/keys.rst
@ -1,11 +0,0 @@
 ``keys``
 ========
 The ``keys`` filter returns the keys of an array. It is useful when you want to
 iterate over the keys of an array:
 .. code-block:: jinja
    {% for key in array|keys %}
        ...
    {% endfor %}
--- a/lib/twig/doc/filters/length.rst
+++ b/lib/twig/doc/filters/length.rst
@ -1,12 +0,0 @@
 ``length``
 ==========
 The ``length`` filters returns the number of items of a sequence or mapping, or
 the length of a string:
 .. code-block:: jinja
    {% if users|length > 10 %}
        ...
    {% endif %}
--- a/lib/twig/doc/filters/lower.rst
+++ b/lib/twig/doc/filters/lower.rst
@ -1,10 +0,0 @@
 ``lower``
 =========
 The ``lower`` filter converts a value to lowercase:
 .. code-block:: jinja
    {{ 'WELCOME'|lower }}
    {# outputs 'welcome' #}
--- a/lib/twig/doc/filters/merge.rst
+++ b/lib/twig/doc/filters/merge.rst
@ -1,41 +0,0 @@
 ``merge``
 =========
 The ``merge`` filter merges an array with the another array:
 .. code-block:: jinja
    {% set values = [1, 2] %}
    {% set values = values|merge(['apple', 'orange']) %}
    {# values now contains [1, 2, 'apple', 'orange'] #}
 New values are added at the end of the existing ones.
 The ``merge`` filter also works on hashes:
 .. code-block:: jinja
    {% set items = { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'unknown' } %}
    {% set items = items|merge({ 'peugeot': 'car', 'renault': 'car' }) %}
    {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car', 'renault': 'car' } #}
 For hashes, the merging process occurs on the keys: if the key does not
 already exist, it is added but if the key already exists, its value is
 overridden.
 .. tip::
    If you want to ensure that some values are defined in an array (by given
    default values), reverse the two elements in the call:
    .. code-block:: jinja
        {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
        {% set items = { 'apple': 'unknown' }|merge(items) %}
        {# items now contains { 'apple': 'fruit', 'orange': 'fruit' } #}
--- a/lib/twig/doc/filters/nl2br.rst
+++ b/lib/twig/doc/filters/nl2br.rst
@ -1,22 +0,0 @@
 ``nl2br``
 =========
 .. versionadded:: 1.5
    The nl2br filter was added in Twig 1.5.
 The ``nl2br`` filter inserts HTML line breaks before all newlines in a string:
 .. code-block:: jinja
    {{ "I like Twig.\nYou will like it too."|nl2br }}
    {# outputs
        I like Twig.<br />
        You will like it too.
    #}
 .. note::
    The ``nl2br`` filter pre-escapes the input before applying the
    transformation.
--- a/lib/twig/doc/filters/number_format.rst
+++ b/lib/twig/doc/filters/number_format.rst
@ -1,38 +0,0 @@
 ``number_format``
 =================
 .. versionadded:: 1.5
    The number_format filter was added in Twig 1.5
 The ``number_format`` filter formats numbers.  It is a wrapper around PHP's
 `number_format`_ function:
 .. code-block:: jinja
    {{ 200.35|number_format }}
 You can control the number of decimal places, decimal point, and thousands
 separator using the additional arguments:
 .. code-block:: jinja
    {{ 9800.333|number_format(2, ',', '.') }}
 If no formatting options are provided then Twig will use the default formatting
 options of:
 - 0 decimal places.
 - ``.`` as the decimal point.
 - ``,`` as the thousands separator.
 These defaults can be easily changed through the core extension:
 .. code-block:: php
    $twig = new Twig_Environment($loader);
    $twig->getExtension('core')->setNumberFormat(3, ',', '.');
 The defaults set for ``number_format`` can be over-ridden upon each call using the
 additional parameters.
 .. _`number_format`: http://php.net/number_format
--- a/lib/twig/doc/filters/raw.rst
+++ b/lib/twig/doc/filters/raw.rst
@ -1,12 +0,0 @@
 ``raw``
 =======
 The ``raw`` filter marks the value as being "safe", which means that in an
 environment with automatic escaping enabled this variable will not be escaped
 if ``raw`` is the last filter applied to it:
 .. code-block:: jinja
    {% autoescape true %}
        {{ var|raw }} {# var won't be escaped #}
    {% endautoescape %}
--- a/lib/twig/doc/filters/replace.rst
+++ b/lib/twig/doc/filters/replace.rst
@ -1,14 +0,0 @@
 ``replace``
 ===========
 The ``replace`` filter formats a given string by replacing the placeholders
 (placeholders are free-form):
 .. code-block:: jinja
    {{ "I like %this% and %that%."|replace({'%this%': foo, '%that%': "bar"}) }}
    {# returns I like foo and bar
       if the foo parameter equals to the foo string. #}
 .. seealso:: :doc:`format<format>`
--- a/lib/twig/doc/filters/reverse.rst
+++ b/lib/twig/doc/filters/reverse.rst
@ -1,23 +0,0 @@
 ``reverse``
 ===========
 .. versionadded:: 1.6
    Support for strings has been added in Twig 1.6.
 The ``reverse`` filter reverses a sequence, a mapping, or a string:
 .. code-block:: jinja
    {% for use in users|reverse %}
        ...
    {% endfor %}
    {{ '1234'|reverse }}
    {# outputs 4321 #}
 .. note::
    It also works with objects implementing the `Traversable`_ interface.
 .. _`Traversable`: http://php.net/Traversable
--- a/lib/twig/doc/filters/slice.rst
+++ b/lib/twig/doc/filters/slice.rst
@ -1,57 +0,0 @@
 ``slice``
 ===========
 .. versionadded:: 1.6
    The slice filter was added in Twig 1.6.
 The ``slice`` filter extracts a slice of a sequence, a mapping, or a string:
 .. code-block:: jinja
    {% for i in [1, 2, 3, 4]|slice(1, 2) %}
        {# will iterate over 2 and 3 #}
    {% endfor %}
    {{ '1234'|slice(1, 2) }}
    {# outputs 23 #}
 You can use any valid expression for both the start and the length:
 .. code-block:: jinja
    {% for i in [1, 2, 3, 4]|slice(start, length) %}
        {# ... #}
    {% endfor %}
 As syntactic sugar, you can also use the ``[]`` notation:
 .. code-block:: jinja
    {% for i in [1, 2, 3, 4][start:length] %}
        {# ... #}
    {% endfor %}
    {{ '1234'[1:2] }}
 The ``slice`` filter works as the `array_slice`_ PHP function for arrays and
 `substr`_ for strings.
 If the start is non-negative, the sequence will start at that start in the
 variable. If start is negative, the sequence will start that far from the end
 of the variable.
 If length is given and is positive, then the sequence will have up to that
 many elements in it. If the variable is shorter than the length, then only the
 available variable elements will be present. If length is given and is
 negative then the sequence will stop that many elements from the end of the
 variable. If it is omitted, then the sequence will have everything from offset
 up until the end of the variable.
 .. note::
    It also works with objects implementing the `Traversable`_ interface.
 .. _`Traversable`: http://php.net/manual/en/class.traversable.php
 .. _`array_slice`: http://php.net/array_slice
 .. _`substr`:      http://php.net/substr
--- a/lib/twig/doc/filters/sort.rst
+++ b/lib/twig/doc/filters/sort.rst
@ -1,17 +0,0 @@
 ``sort``
 ========
 The ``sort`` filter sorts an array:
 .. code-block:: jinja
    {% for use in users|sort %}
        ...
    {% endfor %}
 .. note::
    Internally, Twig uses the PHP `asort`_ function to maintain index
    association.
 .. _`asort`: http://php.net/asort
--- a/lib/twig/doc/filters/striptags.rst
+++ b/lib/twig/doc/filters/striptags.rst
@ -1,15 +0,0 @@
 ``striptags``
 =============
 The ``striptags`` filter strips SGML/XML tags and replace adjacent whitespace
 by one space:
 .. code-block:: jinja
    {% some_html|striptags %}
 .. note::
    Internally, Twig uses the PHP `strip_tags`_ function.
 .. _`strip_tags`: http://php.net/strip_tags
--- a/lib/twig/doc/filters/title.rst
+++ b/lib/twig/doc/filters/title.rst
@ -1,11 +0,0 @@
 ``title``
 =========
 The ``title`` filter returns a titlecased version of the value. Words will
 start with uppercase letters, all remaining characters are lowercase:
 .. code-block:: jinja
    {{ 'my first car'|title }}
    {# outputs 'My First Car' #}
--- a/lib/twig/doc/filters/trim.rst
+++ b/lib/twig/doc/filters/trim.rst
@ -1,24 +0,0 @@
 ``trim``
 ========
 .. versionadded:: 1.6.2
    The trim filter was added in Twig 1.6.2.
 The ``trim`` filter strips whitespace (or other characters) from the beginning
 and end of a string:
 .. code-block:: jinja
    {{ '  I like Twig.  '|trim }}
    {# outputs 'I like Twig.' #}
    {{ '  I like Twig.'|trim('.') }}
    {# outputs '  I like Twig' #}
 .. note::
    Internally, Twig uses the PHP `trim`_ function.
 .. _`trim`: http://php.net/trim
--- a/lib/twig/doc/filters/upper.rst
+++ b/lib/twig/doc/filters/upper.rst
@ -1,10 +0,0 @@
 ``upper``
 =========
 The ``upper`` filter converts a value to uppercase:
 .. code-block:: jinja
    {{ 'welcome'|upper }}
    {# outputs 'WELCOME' #}
--- a/lib/twig/doc/filters/url_encode.rst
+++ b/lib/twig/doc/filters/url_encode.rst
@ -1,14 +0,0 @@
 ``url_encode``
 ==============
 The ``url_encode`` filter URL encodes a given string:
 .. code-block:: jinja
    {{ data|url_encode() }}
 .. note::
    Internally, Twig uses the PHP `urlencode`_ function.
 .. _`urlencode`: http://php.net/urlencode
--- a/lib/twig/doc/functions/attribute.rst
+++ b/lib/twig/doc/functions/attribute.rst
@ -1,18 +0,0 @@
 ``attribute``
 =============
 .. versionadded:: 1.2
    The ``attribute`` function was added in Twig 1.2.
 ``attribute`` can be used to access a "dynamic" attribute of a variable:
 .. code-block:: jinja
    {{ attribute(object, method) }}
    {{ attribute(object, method, arguments) }}
    {{ attribute(array, item) }}
 .. note::
    The resolution algorithm is the same as the one used for the ``.``
    notation, except that the item can be any valid expression.
--- a/lib/twig/doc/functions/block.rst
+++ b/lib/twig/doc/functions/block.rst
@ -1,15 +0,0 @@
 ``block``
 =========
 When a template uses inheritance and if you want to print a block multiple
 times, use the ``block`` function:
 .. code-block:: jinja
    <title>{% block title %}{% endblock %}</title>
    <h1>{{ block('title') }}</h1>
    {% block body %}{% endblock %}
 .. seealso:: :doc:`extends<../tags/extends>`, :doc:`parent<../functions/parent>`
--- a/lib/twig/doc/functions/constant.rst
+++ b/lib/twig/doc/functions/constant.rst
@ -1,9 +0,0 @@
 ``constant``
 ============
 ``constant`` returns the constant value for a given string:
 .. code-block:: jinja
    {{ some_date|date(constant('DATE_W3C')) }}
    {{ constant('Namespace\\Classname::CONSTANT_NAME') }}
--- a/lib/twig/doc/functions/cycle.rst
+++ b/lib/twig/doc/functions/cycle.rst
@ -1,20 +0,0 @@
 ``cycle``
 =========
 The ``cycle`` function cycles on an array of values:
 .. code-block:: jinja
    {% for i in 0..10 %}
        {{ cycle(['odd', 'even'], i) }}
    {% endfor %}
 The array can contain any number of values:
 .. code-block:: jinja
    {% set fruits = ['apple', 'orange', 'citrus'] %}
    {% for i in 0..10 %}
        {{ cycle(fruits, i) }}
    {% endfor %}
--- a/lib/twig/doc/functions/date.rst
+++ b/lib/twig/doc/functions/date.rst
@ -1,46 +0,0 @@
 ``date``
 ========
 .. versionadded:: 1.6
    The date function has been added in Twig 1.6.
 .. versionadded:: 1.6.1
    The default timezone support has been added in Twig 1.6.1.
 Converts an argument to a date to allow date comparison:
 .. code-block:: jinja
    {% if date(user.created_at) < date('+2days') %}
        {# do something #}
    {% endif %}
 The argument must be in a format supported by the `date`_ function.
 You can pass a timezone as the second argument:
 .. code-block:: jinja
    {% if date(user.created_at) < date('+2days', 'Europe/Paris') %}
        {# do something #}
    {% endif %}
 If no argument is passed, the function returns the current date:
 .. code-block:: jinja
    {% if date(user.created_at) < date() %}
        {# always! #}
    {% endif %}
 .. note::
    You can set the default timezone globally by calling ``setTimezone()`` on
    the ``core`` extension instance:
    .. code-block:: php
        $twig = new Twig_Environment($loader);
        $twig->getExtension('core')->setTimezone('Europe/Paris');
 .. _`date`: http://www.php.net/date
--- a/lib/twig/doc/functions/dump.rst
+++ b/lib/twig/doc/functions/dump.rst
@ -1,58 +0,0 @@
 ``dump``
 ========
 .. versionadded:: 1.5
    The dump function was added in Twig 1.5.
 The ``dump`` function dumps information about a template variable. This is
 mostly useful to debug a template that does not behave as expected by
 introspecting its variables:
 .. code-block:: jinja
    {{ dump(user) }}
 .. note::
    The ``debug`` function is not available by default. You must load it explicitly::
        $twig = new Twig_Environment($loader, $config);
        $twig->addExtension(new Twig_Extension_Debug());
    Even when loaded explicitly, it won't do anything if the ``debug`` option
    is not enabled.
 In an HTML context, wrap the output with a ``pre`` tag to make it easier to
 read:
 .. code-block:: jinja
    <pre>
        {{ dump(user) }}
    </pre>
 .. tip::
    Using a ``pre`` tag is not needed when `XDebug`_ is enabled and
    ``html_errors`` is ``on``; as a bonus, the output is also nicer with
    XDebug enabled.
 You can debug several variables by passing them as additional arguments:
 .. code-block:: jinja
    {{ dump(user, categories) }}
 If you don't pass any value, all variables from the current context are
 dumped:
 .. code-block:: jinja
    {{ dump() }}
 .. note::
    Internally, Twig uses the PHP `var_dump`_ function.
 .. _`XDebug`: http://xdebug.org/docs/display
 .. _`var_dump`: http://php.net/var_dump
--- a/lib/twig/doc/functions/index.rst
+++ b/lib/twig/doc/functions/index.rst
@ -1,15 +0,0 @@
 Functions
 =========
 .. toctree::
    :maxdepth: 1
    range
    cycle
    constant
    random
    attribute
    block
    parent
    dump
    date
--- a/lib/twig/doc/functions/parent.rst
+++ b/lib/twig/doc/functions/parent.rst
@ -1,20 +0,0 @@
 ``parent``
 ==========
 When a template uses inheritance, it's possible to render the contents of the
 parent block when overriding a block by using the ``parent`` function:
 .. code-block:: jinja
    {% extends "base.html" %}
    {% block sidebar %}
        <h3>Table Of Contents</h3>
        ...
        {{ parent() }}
    {% endblock %}
 The ``parent()`` call will return the content of the ``sidebar`` block as
 defined in the ``base.html`` template.
 .. seealso:: :doc:`extends<../tags/extends>`, :doc:`block<../functions/block>`, :doc:`block<../tags/block>`
--- a/lib/twig/doc/functions/random.rst
+++ b/lib/twig/doc/functions/random.rst
@ -1,24 +0,0 @@
 ``random``
 ==========
 .. versionadded:: 1.5
    The random function was added in Twig 1.5.
 .. versionadded:: 1.6
    String and integer handling was added in Twig 1.6.
 The ``random`` function returns a random value depending on the supplied
 parameter type:
 * a random item from a sequence;
 * a random character from a string;
 * a random integer between 0 and the integer parameter (inclusive).
 .. code-block:: jinja
    {{ random(['apple', 'orange', 'citrus']) }} {# example output: orange #}
    {{ random('ABC') }}                         {# example output: C #}
    {{ random() }}                              {# example output: 15386094 (works as native PHP `mt_rand`_ function) #}
    {{ random(5) }}                             {# example output: 3 #}
 .. _`mt_rand`: http://php.net/mt_rand
--- a/lib/twig/doc/functions/range.rst
+++ b/lib/twig/doc/functions/range.rst
@ -1,38 +0,0 @@
 ``range``
 =========
 Returns a list containing an arithmetic progression of integers:
 .. code-block:: jinja
    {% for i in range(0, 3) %}
        {{ i }},
    {% endfor %}
    {# returns 0, 1, 2, 3 #}
 When step is given (as the third parameter), it specifies the increment (or
 decrement):
 .. code-block:: jinja
    {% for i in range(0, 6, 2) %}
        {{ i }},
    {% endfor %}
    {# returns 0, 2, 4, 6 #}
 The Twig built-in ``..`` operator is just syntactic sugar for the ``range``
 function (with a step of 1):
 .. code-block:: jinja
    {% for i in 0..3 %}
        {{ i }},
    {% endfor %}
 .. tip::
    The ``range`` function works as the native PHP `range`_ function.
 .. _`range`: http://php.net/range
--- a/lib/twig/doc/hacking.rst
+++ b/lib/twig/doc/hacking.rst
@ -1,184 +0,0 @@
 Hacking Twig
 ============
 Twig is very extensible and you can easily hack it. Keep in mind that you
 should probably try to create an extension before hacking the core, as most
 features and enhancements can be done with extensions. This chapter is also
 useful for people who want to understand how Twig works under the hood.
 How Twig works?
 ---------------
 The rendering of a Twig template can be summarized into four key steps:
 * **Load** the template: If the template is already compiled, load it and go
  to the *evaluation* step, otherwise:
  * First, the **lexer** tokenizes the template source code into small pieces
    for easier processing;
  * Then, the **parser** converts the token stream into a meaningful tree
    of nodes (the Abstract Syntax Tree);
  * Eventually, the *compiler* transforms the AST into PHP code;
 * **Evaluate** the template: It basically means calling the ``display()``
  method of the compiled template and passing it the context.
 The Lexer
 ---------
 The Twig lexer goal is to tokenize a source code into a token stream (each
 token is of class ``Token``, and the stream is an instance of
 ``Twig_TokenStream``). The default lexer recognizes nine different token types:
 * ``Twig_Token::TEXT_TYPE``
 * ``Twig_Token::BLOCK_START_TYPE``
 * ``Twig_Token::VAR_START_TYPE``
 * ``Twig_Token::BLOCK_END_TYPE``
 * ``Twig_Token::VAR_END_TYPE``
 * ``Twig_Token::NAME_TYPE``
 * ``Twig_Token::NUMBER_TYPE``
 * ``Twig_Token::STRING_TYPE``
 * ``Twig_Token::OPERATOR_TYPE``
 * ``Twig_Token::EOF_TYPE``
 You can manually convert a source code into a token stream by calling the
 ``tokenize()`` of an environment::
    $stream = $twig->tokenize($source, $identifier);
 As the stream has a ``__toString()`` method, you can have a textual
 representation of it by echoing the object::
    echo $stream."\n";
 Here is the output for the ``Hello {{ name }}`` template:
 .. code-block:: text
    TEXT_TYPE(Hello )
    VAR_START_TYPE()
    NAME_TYPE(name)
    VAR_END_TYPE()
    EOF_TYPE()
 You can change the default lexer use by Twig (``Twig_Lexer``) by calling the
 ``setLexer()`` method::
    $twig->setLexer($lexer);
 Lexer classes must implement the ``Twig_LexerInterface``::
    interface Twig_LexerInterface
    {
        /**
         * Tokenizes a source code.
         *
         * @param  string $code     The source code
         * @param  string $filename A unique identifier for the source code
         *
         * @return Twig_TokenStream A token stream instance
         */
        function tokenize($code, $filename = 'n/a');
    }
 The Parser
 ----------
 The parser converts the token stream into an AST (Abstract Syntax Tree), or a
 node tree (of class ``Twig_Node_Module``). The core extension defines the
 basic nodes like: ``for``, ``if``, ... and the expression nodes.
 You can manually convert a token stream into a node tree by calling the
 ``parse()`` method of an environment::
    $nodes = $twig->parse($stream);
 Echoing the node object gives you a nice representation of the tree::
    echo $nodes."\n";
 Here is the output for the ``Hello {{ name }}`` template:
 .. code-block:: text
    Twig_Node_Module(
      Twig_Node_Text(Hello )
      Twig_Node_Print(
        Twig_Node_Expression_Name(name)
      )
    )
 The default parser (``Twig_TokenParser``) can be also changed by calling the
 ``setParser()`` method::
    $twig->setParser($parser);
 All Twig parsers must implement the ``Twig_ParserInterface``::
    interface Twig_ParserInterface
    {
        /**
         * Converts a token stream to a node tree.
         *
         * @param  Twig_TokenStream $stream A token stream instance
         *
         * @return Twig_Node_Module A node tree
         */
        function parser(Twig_TokenStream $code);
    }
 The Compiler
 ------------
 The last step is done by the compiler. It takes a node tree as an input and
 generates PHP code usable for runtime execution of the templates. The default
 compiler generates PHP classes to ease the implementation of the template
 inheritance feature.
 You can call the compiler by hand with the ``compile()`` method of an
 environment::
    $php = $twig->compile($nodes);
 The ``compile()`` method returns the PHP source code representing the node.
 The generated template for a ``Hello {{ name }}`` template reads as follows::
    /* Hello {{ name }} */
    class __TwigTemplate_1121b6f109fe93ebe8c6e22e3712bceb extends Twig_Template
    {
        public function display($context)
        {
            $this->env->initRuntime();
            // line 1
            echo "Hello ";
            echo (isset($context['name']) ? $context['name'] : null);
        }
    }
 As for the lexer and the parser, the default compiler (``Twig_Compiler``) can
 be changed by calling the ``setCompiler()`` method::
    $twig->setCompiler($compiler);
 All Twig compilers must implement the ``Twig_CompilerInterface``::
    interface Twig_CompilerInterface
    {
        /**
         * Compiles a node.
         *
         * @param  Twig_Node $node The node to compile
         *
         * @return Twig_Compiler The current compiler instance
         */
        function compile(Twig_Node $node);
        /**
         * Gets the current PHP code after compilation.
         *
         * @return string The PHP code
         */
        function getSource();
    }
--- a/lib/twig/doc/index.rst
+++ b/lib/twig/doc/index.rst
@ -1,18 +0,0 @@
 Twig
 ====
 .. toctree::
    :maxdepth: 2
    intro
    templates
    api
    advanced
    extensions
    hacking
    recipes
    coding_standards
    tags/index
    filters/index
    functions/index
    tests/index
--- a/lib/twig/doc/intro.rst
+++ b/lib/twig/doc/intro.rst
@ -1,153 +0,0 @@
 Introduction
 ============
 This is the documentation for Twig, the flexible, fast, and secure template
 engine for PHP.
 If you have any exposure to other text-based template languages, such as
 Smarty, Django, or Jinja, you should feel right at home with Twig. It's both
 designer and developer friendly by sticking to PHP's principles and adding
 functionality useful for templating environments.
 The key-features are...
 * *Fast*: Twig compiles templates down to plain optimized PHP code. The
  overhead compared to regular PHP code was reduced to the very minimum.
 * *Secure*: Twig has a sandbox mode to evaluate untrusted template code. This
  allows Twig to be used as a template language for applications where users
  may modify the template design.
 * *Flexible*: Twig is powered by a flexible lexer and parser. This allows the
  developer to define its own custom tags and filters, and create its own DSL.
 Prerequisites
 -------------
 Twig needs at least **PHP 5.2.4** to run.
 Installation
 ------------
 You have multiple ways to install Twig. If you are unsure what to do, go with
 the tarball.
 Installing from the tarball release
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 1. Download the most recent tarball from the `download page`_
 2. Unpack the tarball
 3. Move the files somewhere in your project
 Installing the development version
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 1. Install Subversion or Git
 2. For Git: ``git clone git://github.com/fabpot/Twig.git``
 3. For Subversion: ``svn co http://svn.twig-project.org/trunk/ twig``
 Installing the PEAR package
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 1. Install PEAR
 2. ``pear channel-discover pear.twig-project.org``
 3. ``pear install twig/Twig`` (or ``pear install twig/Twig-beta``)
 Installing via Composer
 ~~~~~~~~~~~~~~~~~~~~~~~
 1. Install composer in your project:
 .. code-block:: bash
    curl -s http://getcomposer.org/installer | php``
 2. Create a ``composer.json`` file in your project root:
 .. code-block:: javascript
    {
        "require": {
            "twig/twig": "1.6.0"
        }
    }
 3. Install via composer
 .. code-block:: bash
    php composer.phar install
 Installing the C extension
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 .. versionadded:: 1.4
    The C extension was added in Twig 1.4.
 Twig comes with a C extension that enhances the performance of the Twig
 runtime engine. You can install it like any other PHP extension:
 .. code-block:: bash
    $ cd ext/twig
    $ phpize
    $ ./configure
    $ make
    $ make install
 Finally, enable the extension in your ``php.ini`` configuration file:
 .. code-block:: ini
    extension=twig.so
 And from now on, Twig will automatically compile your templates to take
 advantage of the C extension.
 .. tip::
    On Windows, you can also simply download and install a `pre-build DLL`_.
 Basic API Usage
 ---------------
 This section gives you a brief introduction to the PHP API for Twig.
 The first step to use Twig is to register its autoloader::
    require_once '/path/to/lib/Twig/Autoloader.php';
    Twig_Autoloader::register();
 Replace the ``/path/to/lib/`` path with the path you used for Twig
 installation.
 .. note::
    Twig follows the PEAR convention names for its classes, which means you
    can easily integrate Twig classes loading in your own autoloader.
 .. code-block:: php
    $loader = new Twig_Loader_String();
    $twig = new Twig_Environment($loader);
    echo $twig->render('Hello {{ name }}!', array('name' => 'Fabien'));
 Twig uses a loader (``Twig_Loader_String``) to locate templates, and an
 environment (``Twig_Environment``) to store the configuration.
 The ``render()`` method loads the template passed as a first argument and
 renders it with the variables passed as a second argument.
 As templates are generally stored on the filesystem, Twig also comes with a
 filesystem loader::
    $loader = new Twig_Loader_Filesystem('/path/to/templates');
    $twig = new Twig_Environment($loader, array(
      'cache' => '/path/to/compilation_cache',
    ));
    echo $twig->render('index.html', array('name' => 'Fabien'));
 .. _`download page`: https://github.com/fabpot/Twig/tags
 .. _`pre-build DLL`: https://github.com/stealth35/stealth35.github.com/downloads
--- a/lib/twig/doc/recipes.rst
+++ b/lib/twig/doc/recipes.rst
@ -1,301 +0,0 @@
 Recipes
 =======
 Making a Layout conditional
 ---------------------------
 Working with Ajax means that the same content is sometimes displayed as is,
 and sometimes decorated with a layout. As Twig layout template names can be
 any valid expression, you can pass a variable that evaluates to ``true`` when
 the request is made via Ajax and choose the layout accordingly:
 .. code-block:: jinja
    {% extends request.ajax ? "base_ajax.html" : "base.html" %}
    {% block content %}
        This is the content to be displayed.
    {% endblock %}
 Making an Include dynamic
 -------------------------
 When including a template, its name does not need to be a string. For
 instance, the name can depend on the value of a variable:
 .. code-block:: jinja
    {% include var ~ '_foo.html' %}
 If ``var`` evaluates to ``index``, the ``index_foo.html`` template will be
 rendered.
 As a matter of fact, the template name can be any valid expression, such as
 the following:
 .. code-block:: jinja
    {% include var|default('index') ~ '_foo.html' %}
 Overriding a Template that also extends itself
 ----------------------------------------------
 A template can be customized in two different ways:
 * *Inheritance*: A template *extends* a parent template and overrides some
  blocks;
 * *Replacement*: If you use the filesystem loader, Twig loads the first
  template it finds in a list of configured directories; a template found in a
  directory *replaces* another one from a directory further in the list.
 But how do you combine both: *replace* a template that also extends itself
 (aka a template in a directory further in the list)?
 Let's say that your templates are loaded from both ``.../templates/mysite``
 and ``.../templates/default`` in this order. The ``page.twig`` template,
 stored in ``.../templates/default`` reads as follows:
 .. code-block:: jinja
    {# page.twig #}
    {% extends "layout.twig" %}
    {% block content %}
    {% endblock %}
 You can replace this template by putting a file with the same name in
 ``.../templates/mysite``. And if you want to extend the original template, you
 might be tempted to write the following:
 .. code-block:: jinja
    {# page.twig in .../templates/mysite #}
    {% extends "page.twig" %} {# from .../templates/default #}
 Of course, this will not work as Twig will always load the template from
 ``.../templates/mysite``.
 It turns out it is possible to get this to work, by adding a directory right
 at the end of your template directories, which is the parent of all of the
 other directories: ``.../templates`` in our case. This has the effect of
 making every template file within our system uniquely addressable. Most of the
 time you will use the "normal" paths, but in the special case of wanting to
 extend a template with an overriding version of itself we can reference its
 parent's full, unambiguous template path in the extends tag:
 .. code-block:: jinja
    {# page.twig in .../templates/mysite #}
    {% extends "default/page.twig" %} {# from .../templates #}
 .. note::
    This recipe was inspired by the following Django wiki page:
    http://code.djangoproject.com/wiki/ExtendingTemplates
 Customizing the Syntax
 ----------------------
 Twig allows some syntax customization for the block delimiters. It's not
 recommended to use this feature as templates will be tied with your custom
 syntax. But for specific projects, it can make sense to change the defaults.
 To change the block delimiters, you need to create your own lexer object::
    $twig = new Twig_Environment();
    $lexer = new Twig_Lexer($twig, array(
        'tag_comment'  => array('{#', '#}'),
        'tag_block'    => array('{%', '%}'),
        'tag_variable' => array('{{', '}}'),
    ));
    $twig->setLexer($lexer);
 Here are some configuration example that simulates some other template engines
 syntax::
    // Ruby erb syntax
    $lexer = new Twig_Lexer($twig, array(
        'tag_comment'  => array('<%#', '%>'),
        'tag_block'    => array('<%', '%>'),
        'tag_variable' => array('<%=', '%>'),
    ));
    // SGML Comment Syntax
    $lexer = new Twig_Lexer($twig, array(
        'tag_comment'  => array('<!--#', '-->'),
        'tag_block'    => array('<!--', '-->'),
        'tag_variable' => array('${', '}'),
    ));
    // Smarty like
    $lexer = new Twig_Lexer($twig, array(
        'tag_comment'  => array('{*', '*}'),
        'tag_block'    => array('{', '}'),
        'tag_variable' => array('{$', '}'),
    ));
 Using dynamic Object Properties
 -------------------------------
 When Twig encounters a variable like ``article.title``, it tries to find a
 ``title`` public property in the ``article`` object.
 It also works if the property does not exist but is rather defined dynamically
 thanks to the magic ``__get()`` method; you just need to also implement the
 ``__isset()`` magic method like shown in the following snippet of code::
    class Article
    {
        public function __get($name)
        {
            if ('title' == $name)
            {
                return 'The title';
            }
            // throw some kind of error
        }
        public function __isset($name)
        {
            if ('title' == $name)
            {
                return true;
            }
            return false;
        }
    }
 Accessing the parent Context in Nested Loops
 --------------------------------------------
 Sometimes, when using nested loops, you need to access the parent context. The
 parent context is always accessible via the ``loop.parent`` variable. For
 instance, if you have the following template data::
    $data = array(
        'topics' => array(
            'topic1' => array('Message 1 of topic 1', 'Message 2 of topic 1'),
            'topic2' => array('Message 1 of topic 2', 'Message 2 of topic 2'),
        ),
    );
 And the following template to display all messages in all topics:
 .. code-block:: jinja
    {% for topic, messages in topics %}
        * {{ loop.index }}: {{ topic }}
      {% for message in messages %}
          - {{ loop.parent.loop.index }}.{{ loop.index }}: {{ message }}
      {% endfor %}
    {% endfor %}
 The output will be similar to:
 .. code-block:: text
    * 1: topic1
      - 1.1: The message 1 of topic 1
      - 1.2: The message 2 of topic 1
    * 2: topic2
      - 2.1: The message 1 of topic 2
      - 2.2: The message 2 of topic 2
 In the inner loop, the ``loop.parent`` variable is used to access the outer
 context. So, the index of the current ``topic`` defined in the outer for loop
 is accessible via the ``loop.parent.loop.index`` variable.
 Defining undefined Functions and Filters on the Fly
 ---------------------------------------------------
 When a function (or a filter) is not defined, Twig defaults to throw a
 ``Twig_Error_Syntax`` exception. However, it can also call a `callback`_ (any
 valid PHP callable) which should return a function (or a filter).
 For filters, register callbacks with ``registerUndefinedFilterCallback()``.
 For functions, use ``registerUndefinedFunctionCallback()``::
    // auto-register all native PHP functions as Twig functions
    // don't try this at home as it's not secure at all!
    $twig->registerUndefinedFunctionCallback(function ($name) {
        if (function_exists($name)) {
            return new Twig_Function_Function($name);
        }
        return false;
    });
 If the callable is not able to return a valid function (or filter), it must
 return ``false``.
 If you register more than one callback, Twig will call them in turn until one
 does not return ``false``.
 .. tip::
    As the resolution of functions and filters is done during compilation,
    there is no overhead when registering these callbacks.
 Validating the Template Syntax
 ------------------------------
 When template code is providing by a third-party (through a web interface for
 instance), it might be interesting to validate the template syntax before
 saving it. If the template code is stored in a `$template` variable, here is
 how you can do it::
    try {
        $twig->parse($twig->tokenize($template));
        // the $template is valid
    } catch (Twig_Error_Syntax $e) {
        // $template contains one or more syntax errors
    }
 Refreshing modified Templates when APC is enabled and apc.stat = 0
 ------------------------------------------------------------------
 When using APC with ``apc.stat`` set to ``0`` and Twig cache enabled, clearing
 the template cache won't update the APC cache. To get around this, one can
 extend ``Twig_Environment`` and force the update of the APC cache when Twig
 rewrites the cache::
    class Twig_Environment_APC extends Twig_Environment
    {
        protected function writeCacheFile($file, $content)
        {
            parent::writeCacheFile($file, $content);
            // Compile cached file into bytecode cache
            apc_compile_file($file);
        }
    }
 Reusing a stateful Node Visitor
 -------------------------------
 When attaching a visitor to a ``Twig_Environment`` instance, Twig uses it to
 visit *all* templates it compiles. If you need to keep some state information
 around, you probably want to reset it when visiting a new template.
 This can be easily achieved with the following code::
    protected $someTemplateState = array();
    public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
    {
        if ($node instanceof Twig_Node_Module) {
            // reset the state as we are entering a new template
            $this->someTemplateState = array();
        }
        // ...
        return $node;
    }
 .. _callback: http://www.php.net/manual/en/function.is-callable.php
--- a/lib/twig/doc/tags/autoescape.rst
+++ b/lib/twig/doc/tags/autoescape.rst
@ -1,43 +0,0 @@
 ``autoescape``
 ==============
 Whether automatic escaping is enabled or not, you can mark a section of a
 template to be escaped or not by using the ``autoescape`` tag:
 .. code-block:: jinja
    {% autoescape true %}
        Everything will be automatically escaped in this block
    {% endautoescape %}
    {% autoescape false %}
        Everything will be outputed as is in this block
    {% endautoescape %}
    {% autoescape true js %}
        Everything will be automatically escaped in this block
        using the js escaping strategy
    {% endautoescape %}
 When automatic escaping is enabled everything is escaped by default except for
 values explicitly marked as safe. Those can be marked in the template by using
 the :doc:`raw<../filters/raw>` filter:
 .. code-block:: jinja
    {% autoescape true %}
        {{ safe_value|raw }}
    {% endautoescape %}
 Functions returning template data (like :doc:`macros<macro>` and
 :doc:`parent<../functions/parent>`) always return safe markup.
 .. note::
    Twig is smart enough to not escape an already escaped value by the
    :doc:`escape<../filters/escape>` filter.
 .. note::
    The chapter :doc:`Twig for Developers<../api>` gives more information
    about when and how automatic escaping is applied.
--- a/lib/twig/doc/tags/block.rst
+++ b/lib/twig/doc/tags/block.rst
@ -1,11 +0,0 @@
 ``block``
 =========
 Blocks are used for inheritance and act as placeholders and replacements at
 the same time. They are documented in detail in the documentation for the
 :doc:`extends<../tags/extends>` tag.
 Block names should consist of alphanumeric characters, and underscores. Dashes
 are not permitted.
 .. seealso:: :doc:`block<../functions/block>`, :doc:`parent<../functions/parent>`, :doc:`use<../tags/use>`, :doc:`extends<../tags/extends>`
--- a/lib/twig/doc/tags/do.rst
+++ b/lib/twig/doc/tags/do.rst
@ -1,12 +0,0 @@
 ``do``
 ======
 .. versionadded:: 1.5
    The do tag was added in Twig 1.5.
 The ``do`` tag works exactly like the regular variable expression (``{{ ...
 }}``) just that it doesn't print anything:
 .. code-block:: jinja
    {% do 1 + 2 %}
--- a/lib/twig/doc/tags/extends.rst
+++ b/lib/twig/doc/tags/extends.rst
@ -1,187 +0,0 @@
 ``extends``
 ===========
 The ``extends`` tag can be used to extend a template from another one.
 .. note::
    Like PHP, Twig does not support multiple inheritance. So you can only have
    one extends tag called per rendering. However, Twig supports horizontal
    :doc:`reuse<use>`.
 Let's define a base template, ``base.html``, which defines a simple HTML
 skeleton document:
 .. code-block:: html+jinja
    <!DOCTYPE html>
    <html>
        <head>
            {% block head %}
                <link rel="stylesheet" href="style.css" />
                <title>{% block title %}{% endblock %} - My Webpage</title>
            {% endblock %}
        </head>
        <body>
            <div id="content">{% block content %}{% endblock %}</div>
            <div id="footer">
                {% block footer %}
                    &copy; Copyright 2011 by <a href="http://domain.invalid/">you</a>.
                {% endblock %}
            </div>
        </body>
    </html>
 In this example, the :doc:`block<block>` tags define four blocks that child
 templates can fill in. All the ``block`` tag does is to tell the template
 engine that a child template may override those portions of the template.
 Child Template
 --------------
 A child template might look like this:
 .. code-block:: jinja
    {% extends "base.html" %}
    {% block title %}Index{% endblock %}
    {% block head %}
        {{ parent() }}
        <style type="text/css">
            .important { color: #336699; }
        </style>
    {% endblock %}
    {% block content %}
        <h1>Index</h1>
        <p class="important">
            Welcome on my awesome homepage.
        </p>
    {% endblock %}
 The ``extends`` tag is the key here. It tells the template engine that this
 template "extends" another template. When the template system evaluates this
 template, first it locates the parent. The extends tag should be the first tag
 in the template.
 Note that since the child template doesn't define the ``footer`` block, the
 value from the parent template is used instead.
 You can't define multiple ``block`` tags with the same name in the same
 template. This limitation exists because a block tag works in "both"
 directions. That is, a block tag doesn't just provide a hole to fill - it also
 defines the content that fills the hole in the *parent*. If there were two
 similarly-named ``block`` tags in a template, that template's parent wouldn't
 know which one of the blocks' content to use.
 If you want to print a block multiple times you can however use the
 ``block`` function:
 .. code-block:: jinja
    <title>{% block title %}{% endblock %}</title>
    <h1>{{ block('title') }}</h1>
    {% block body %}{% endblock %}
 Parent Blocks
 -------------
 It's possible to render the contents of the parent block by using the
 :doc:`parent<../functions/parent>` function. This gives back the results of
 the parent block:
 .. code-block:: jinja
    {% block sidebar %}
        <h3>Table Of Contents</h3>
        ...
        {{ parent() }}
    {% endblock %}
 Named Block End-Tags
 --------------------
 Twig allows you to put the name of the block after the end tag for better
 readability:
 .. code-block:: jinja
    {% block sidebar %}
        {% block inner_sidebar %}
            ...
        {% endblock inner_sidebar %}
    {% endblock sidebar %}
 Of course, the name after the ``endblock`` word must match the block name.
 Block Nesting and Scope
 -----------------------
 Blocks can be nested for more complex layouts. Per default, blocks have access
 to variables from outer scopes:
 .. code-block:: jinja
    {% for item in seq %}
        <li>{% block loop_item %}{{ item }}{% endblock %}</li>
    {% endfor %}
 Block Shortcuts
 ---------------
 For blocks with few content, it's possible to use a shortcut syntax. The
 following constructs do the same:
 .. code-block:: jinja
    {% block title %}
        {{ page_title|title }}
    {% endblock %}
 .. code-block:: jinja
    {% block title page_title|title %}
 Dynamic Inheritance
 -------------------
 Twig supports dynamic inheritance by using a variable as the base template:
 .. code-block:: jinja
    {% extends some_var %}
 If the variable evaluates to a ``Twig_Template`` object, Twig will use it as
 the parent template::
    // {% extends layout %}
    $layout = $twig->loadTemplate('some_layout_template.twig');
    $twig->display('template.twig', array('layout' => $layout));
 .. versionadded:: 1.2
    The possibility to pass an array of templates has been added in Twig 1.2.
 You can also provide a list of templates that are checked for existence. The
 first template that exists will be used as a parent:
 .. code-block:: jinja
    {% extends ['layout.html', 'base_layout.html'] %}
 Conditional Inheritance
 -----------------------
 As the template name for the parent can be any valid Twig expression, it's
 possible to make the inheritance mechanism conditional:
 .. code-block:: jinja
    {% extends standalone ? "minimum.html" : "base.html" %}
 In this example, the template will extend the "minimum.html" layout template
 if the ``standalone`` variable evaluates to ``true``, and "base.html"
 otherwise.
 .. seealso:: :doc:`block<../functions/block>`, :doc:`block<../tags/block>`, :doc:`parent<../functions/parent>`, :doc:`use<../tags/use>`
--- a/lib/twig/doc/tags/filter.rst
+++ b/lib/twig/doc/tags/filter.rst
@ -1,21 +0,0 @@
 ``filter``
 ==========
 Filter sections allow you to apply regular Twig filters on a block of template
 data. Just wrap the code in the special ``filter`` section:
 .. code-block:: jinja
    {% filter upper %}
        This text becomes uppercase
    {% endfilter %}
 You can also chain filters:
 .. code-block:: jinja
    {% filter lower|escape %}
        <strong>SOME TEXT</strong>
    {% endfilter %}
    {# outputs "&lt;strong&gt;some text&lt;/strong&gt;" #}
--- a/lib/twig/doc/tags/flush.rst
+++ b/lib/twig/doc/tags/flush.rst
@ -1,17 +0,0 @@
 ``flush``
 =========
 .. versionadded:: 1.5
    The flush tag was added in Twig 1.5.
 The ``flush`` tag tells Twig to flush the output buffer:
 .. code-block:: jinja
    {% flush %}
 .. note::
    Internally, Twig uses the PHP `flush`_ function.
 .. _`flush`: http://php.net/flush
--- a/lib/twig/doc/tags/for.rst
+++ b/lib/twig/doc/tags/for.rst
@ -1,149 +0,0 @@
 ``for``
 =======
 Loop over each item in a sequence. For example, to display a list of users
 provided in a variable called ``users``:
 .. code-block:: jinja
    <h1>Members</h1>
    <ul>
        {% for user in users %}
            <li>{{ user.username|e }}</li>
        {% endfor %}
    </ul>
 .. note::
    A sequence can be either an array or an object implementing the
    ``Traversable`` interface.
 If you do need to iterate over a sequence of numbers, you can use the ``..``
 operator:
 .. code-block:: jinja
    {% for i in 0..10 %}
        * {{ i }}
    {% endfor %}
 The above snippet of code would print all numbers from 0 to 10.
 It can be also useful with letters:
 .. code-block:: jinja
    {% for letter in 'a'..'z' %}
        * {{ letter }}
    {% endfor %}
 The ``..`` operator can take any expression at both sides:
 .. code-block:: jinja
    {% for letter in 'a'|upper..'z'|upper %}
        * {{ letter }}
    {% endfor %}
 .. tip:
    If you need a step different from 1, you can use the ``range`` function
    instead.
 The `loop` variable
 -------------------
 Inside of a ``for`` loop block you can access some special variables:
 ===================== =============================================================
 Variable              Description
 ===================== =============================================================
 ``loop.index``        The current iteration of the loop. (1 indexed)
 ``loop.index0``       The current iteration of the loop. (0 indexed)
 ``loop.revindex``     The number of iterations from the end of the loop (1 indexed)
 ``loop.revindex0``    The number of iterations from the end of the loop (0 indexed)
 ``loop.first``        True if first iteration
 ``loop.last``         True if last iteration
 ``loop.length``       The number of items in the sequence
 ``loop.parent``       The parent context
 ===================== =============================================================
 .. note::
    The ``loop.length``, ``loop.revindex``, ``loop.revindex0``, and
    ``loop.last`` variables are only available for PHP arrays, or objects that
    implement the ``Countable`` interface.
 .. versionadded:: 1.2
    The ``if`` modifier support has been added in Twig 1.2.
 Adding a condition
 ------------------
 Unlike in PHP, it's not possible to ``break`` or ``continue`` in a loop. You
 can however filter the sequence during iteration which allows you to skip
 items. The following example skips all the users which are not active:
 .. code-block:: jinja
    <ul>
        {% for user in users if user.active %}
            <li>{{ user.username|e }}</li>
        {% endfor %}
    </ul>
 The advantage is that the special loop variable will count correctly thus not
 counting the users not iterated over.
 .. note::
    Using the ``loop`` variable within the condition is not recommended as it
    will probably not be doing what you expect it to. For instance, adding a
    condition like ``loop.index > 4`` won't work as the index is only
    incremented when the condition is true (so the condition will never
    match).
 The `else` Clause
 -----------------
 If no iteration took place because the sequence was empty, you can render a
 replacement block by using ``else``:
 .. code-block:: jinja
    <ul>
        {% for user in users %}
            <li>{{ user.username|e }}</li>
        {% else %}
            <li><em>no user found</em></li>
        {% endfor %}
    </ul>
 Iterating over Keys
 -------------------
 By default, a loop iterates over the values of the sequence. You can iterate
 on keys by using the ``keys`` filter:
 .. code-block:: jinja
    <h1>Members</h1>
    <ul>
        {% for key in users|keys %}
            <li>{{ key }}</li>
        {% endfor %}
    </ul>
 Iterating over Keys and Values
 ------------------------------
 You can also access both keys and values:
 .. code-block:: jinja
    <h1>Members</h1>
    <ul>
        {% for key, user in users %}
            <li>{{ key }}: {{ user.username|e }}</li>
        {% endfor %}
    </ul>
--- a/lib/twig/doc/tags/from.rst
+++ b/lib/twig/doc/tags/from.rst
@ -1,8 +0,0 @@
 ``from``
 ========
 The ``from`` tags import :doc:`macro<../tags/macro>` names into the current
 namespace. The tag is documented in detail in the documentation for the
 :doc:`import<../tags/import>` tag.
 .. seealso:: :doc:`macro<../tags/macro>`, :doc:`import<../tags/import>`
--- a/lib/twig/doc/tags/if.rst
+++ b/lib/twig/doc/tags/if.rst
@ -1,43 +0,0 @@
 ``if``
 ======
 The ``if`` statement in Twig is comparable with the if statements of PHP.
 In the simplest form you can use it to test if an expression evaluates to
 ``true``:
 .. code-block:: jinja
    {% if online == false %}
        <p>Our website is in maintenance mode. Please, come back later.</p>
    {% endif %}
 You can also test if an array is not empty:
 .. code-block:: jinja
    {% if users %}
        <ul>
            {% for user in users %}
                <li>{{ user.username|e }}</li>
            {% endfor %}
        </ul>
    {% endif %}
 .. note::
    If you want to test if the variable is defined, use ``if users is
    defined`` instead.
 For multiple branches ``elseif`` and ``else`` can be used like in PHP. You can use
 more complex ``expressions`` there too:
 .. code-block:: jinja
    {% if kenny.sick %}
        Kenny is sick.
    {% elseif kenny.dead %}
        You killed Kenny!  You bastard!!!
    {% else %}
        Kenny looks okay --- so far
    {% endif %}
--- a/lib/twig/doc/tags/import.rst
+++ b/lib/twig/doc/tags/import.rst
@ -1,79 +0,0 @@
 ``import``
 ==========
 Twig supports putting often used code into :doc:`macros<../tags/macro>`. These
 macros can go into different templates and get imported from there.
 There are two ways to import templates. You can import the complete template
 into a variable or request specific macros from it.
 Imagine we have a helper module that renders forms (called ``forms.html``):
 .. code-block:: jinja
    {% macro input(name, value, type, size) %}
        <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
    {% endmacro %}
    {% macro textarea(name, value, rows) %}
        <textarea name="{{ name }}" rows="{{ rows|default(10) }}" cols="{{ cols|default(40) }}">{{ value|e }}</textarea>
    {% endmacro %}
 The easiest and most flexible is importing the whole module into a variable.
 That way you can access the attributes:
 .. code-block:: jinja
    {% import 'forms.html' as forms %}
    <dl>
        <dt>Username</dt>
        <dd>{{ forms.input('username') }}</dd>
        <dt>Password</dt>
        <dd>{{ forms.input('password', null, 'password') }}</dd>
    </dl>
    <p>{{ forms.textarea('comment') }}</p>
 Alternatively you can import names from the template into the current
 namespace:
 .. code-block:: jinja
    {% from 'forms.html' import input as input_field, textarea %}
    <dl>
        <dt>Username</dt>
        <dd>{{ input_field('username') }}</dd>
        <dt>Password</dt>
        <dd>{{ input_field('password', '', 'password') }}</dd>
    </dl>
    <p>{{ textarea('comment') }}</p>
 Importing is not needed if the macros and the template are defined in the same
 file; use the special ``_self`` variable instead:
 .. code-block:: jinja
    {# index.html template #}
    {% macro textarea(name, value, rows) %}
        <textarea name="{{ name }}" rows="{{ rows|default(10) }}" cols="{{ cols|default(40) }}">{{ value|e }}</textarea>
    {% endmacro %}
    <p>{{ _self.textarea('comment') }}</p>
 But you can still create an alias by importing from the ``_self`` variable:
 .. code-block:: jinja
    {# index.html template #}
    {% macro textarea(name, value, rows) %}
        <textarea name="{{ name }}" rows="{{ rows|default(10) }}" cols="{{ cols|default(40) }}">{{ value|e }}</textarea>
    {% endmacro %}
    {% import _self as forms %}
    <p>{{ forms.textarea('comment') }}</p>
 .. seealso:: :doc:`macro<../tags/macro>`, :doc:`from<../tags/from>`
--- a/lib/twig/doc/tags/include.rst
+++ b/lib/twig/doc/tags/include.rst
@ -1,86 +0,0 @@
 ``include``
 ===========
 The ``include`` statement includes a template and return the rendered content
 of that file into the current namespace:
 .. code-block:: jinja
    {% include 'header.html' %}
        Body
    {% include 'footer.html' %}
 Included templates have access to the variables of the active context.
 If you are using the filesystem loader, the templates are looked for in the
 paths defined by it.
 You can add additional variables by passing them after the ``with`` keyword:
 .. code-block:: jinja
    {# the foo template will have access to the variables from the current context and the foo one #}
    {% include 'foo' with {'foo': 'bar'} %}
    {% set vars = {'foo': 'bar'} %}
    {% include 'foo' with vars %}
 You can disable access to the context by appending the ``only`` keyword:
 .. code-block:: jinja
    {# only the foo variable will be accessible #}
    {% include 'foo' with {'foo': 'bar'} only %}
 .. code-block:: jinja
    {# no variable will be accessible #}
    {% include 'foo' only %}
 .. tip::
    When including a template created by an end user, you should consider
    sandboxing it. More information in the :doc:`Twig for Developers<../api>`
    chapter.
 The template name can be any valid Twig expression:
 .. code-block:: jinja
    {% include some_var %}
    {% include ajax ? 'ajax.html' : 'not_ajax.html' %}
 And if the expression evaluates to a ``Twig_Template`` object, Twig will use it
 directly::
    // {% include template %}
    $template = $twig->loadTemplate('some_template.twig');
    $twig->loadTemplate('template.twig')->display(array('template' => $template));
 .. versionadded:: 1.2
    The ``ignore missing`` feature has been added in Twig 1.2.
 You can mark an include with ``ignore missing`` in which case Twig will ignore
 the statement if the template to be ignored does not exist. It has to be
 placed just after the template name. Here some valid examples:
 .. code-block:: jinja
    {% include "sidebar.html" ignore missing %}
    {% include "sidebar.html" ignore missing with {'foo': 'bar} %}
    {% include "sidebar.html" ignore missing only %}
 .. versionadded:: 1.2
    The possibility to pass an array of templates has been added in Twig 1.2.
 You can also provide a list of templates that are checked for existence before
 inclusion. The first template that exists will be included:
 .. code-block:: jinja
    {% include ['page_detailed.html', 'page.html'] %}
 If ``ignore missing`` is given, it will fall back to rendering nothing if none
 of the templates exist, otherwise it will throw an exception.
--- a/lib/twig/doc/tags/index.rst
+++ b/lib/twig/doc/tags/index.rst
@ -1,22 +0,0 @@
 Tags
 ====
 .. toctree::
    :maxdepth: 1
    for
    if
    macro
    filter
    set
    extends
    block
    include
    import
    from
    use
    spaceless
    autoescape
    raw
    flush
    do
--- a/lib/twig/doc/tags/macro.rst
+++ b/lib/twig/doc/tags/macro.rst
@ -1,91 +0,0 @@
 ``macro``
 =========
 Macros are comparable with functions in regular programming languages. They
 are useful to put often used HTML idioms into reusable elements to not repeat
 yourself.
 Here is a small example of a macro that renders a form element:
 .. code-block:: jinja
    {% macro input(name, value, type, size) %}
        <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
    {% endmacro %}
 Macros differs from native PHP functions in a few ways:
 * Default argument values are defined by using the ``default`` filter in the
  macro body;
 * Arguments of a macro are always optional.
 But as PHP functions, macros don't have access to the current template
 variables.
 .. tip::
    You can pass the whole context as an argument by using the special
    ``_context`` variable.
 Macros can be defined in any template, and need to be "imported" before being
 used (see the documentation for the :doc:`import<../tags/import>` tag for more
 information):
 .. code-block:: jinja
    {% import "forms.html" as forms %}
 The above ``import`` call imports the "forms.html" file (which can contain only
 macros, or a template and some macros), and import the functions as items of
 the ``forms`` variable.
 The macro can then be called at will:
 .. code-block:: jinja
    <p>{{ forms.input('username') }}</p>
    <p>{{ forms.input('password', null, 'password') }}</p>
 If macros are defined and used in the same template, you can use the
 special ``_self`` variable, without importing them:
 .. code-block:: jinja
    <p>{{ _self.input('username') }}</p>
 When you want to use a macro in another one from the same file, use the ``_self``
 variable:
 .. code-block:: jinja
    {% macro input(name, value, type, size) %}
      <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
    {% endmacro %}
    {% macro wrapped_input(name, value, type, size) %}
        <div class="field">
            {{ _self.input(name, value, type, size) }}
        </div>
    {% endmacro %}
 When the macro is defined in another file, you need to import it:
 .. code-block:: jinja
    {# forms.html #}
    {% macro input(name, value, type, size) %}
      <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
    {% endmacro %}
    {# shortcuts.html #}
    {% macro wrapped_input(name, value, type, size) %}
        {% import "forms.html" as forms %}
        <div class="field">
            {{ forms.input(name, value, type, size) }}
        </div>
    {% endmacro %}
 .. seealso:: :doc:`from<../tags/from>`, :doc:`import<../tags/import>`
--- a/lib/twig/doc/tags/raw.rst
+++ b/lib/twig/doc/tags/raw.rst
@ -1,16 +0,0 @@
 ``raw``
 =======
 The ``raw`` tag marks sections as being raw text that should not be parsed.
 For example to put Twig syntax as example into a template you can use this
 snippet:
 .. code-block:: jinja
    {% raw %}
        <ul>
        {% for item in seq %}
            <li>{{ item }}</li>
        {% endfor %}
        </ul>
    {% endraw %}
--- a/lib/twig/doc/tags/set.rst
+++ b/lib/twig/doc/tags/set.rst
@ -1,32 +0,0 @@
 ``set``
 =======
 Inside code blocks you can also assign values to variables. Assignments use
 the ``set`` tag and can have multiple targets:
 .. code-block:: jinja
    {% set foo = 'foo' %}
    {% set foo = [1, 2] %}
    {% set foo = {'foo': 'bar'} %}
    {% set foo = 'foo' ~ 'bar' %}
    {% set foo, bar = 'foo', 'bar' %}
 The ``set`` tag can also be used to 'capture' chunks of text:
 .. code-block:: jinja
    {% set foo %}
      <div id="pagination">
        ...
      </div>
    {% endset %}
 .. caution::
    If you enable automatic output escaping, Twig will only consider the
    content to be safe when capturing chunks of text.
--- a/lib/twig/doc/tags/spaceless.rst
+++ b/lib/twig/doc/tags/spaceless.rst
@ -1,37 +0,0 @@
 ``spaceless``
 =============
 Use the ``spaceless`` tag to remove whitespace *between HTML tags*, not
 whitespace within HTML tags or whitespace in plain text:
 .. code-block:: jinja
    {% spaceless %}
        <div>
            <strong>foo</strong>
        </div>
    {% endspaceless %}
    {# output will be <div><strong>foo</strong></div> #}
 This tag is not meant to "optimize" the size of the generated HTML content but
 merely to avoid extra whitespace between HTML tags to avoid browser rendering
 quirks under some circumstances.
 .. tip::
    If you want to optimize the size of the generated HTML content, gzip
    compress the output instead.
 .. tip::
    If you want to create a tag that actually removes all extra whitespace in
    an HTML string, be warned that this is not as easy as it seems to be
    (think of ``textarea`` or ``pre`` tags for instance). Using a third-party
    library like Tidy is probably a better idea.
 .. tip::
    For more information on whitespace control, read the
    :doc:`dedicated<../templates>` section of the documentation and learn how
    you can also use the whitespace control modifier on your tags.
--- a/lib/twig/doc/tags/use.rst
+++ b/lib/twig/doc/tags/use.rst
@ -1,123 +0,0 @@
 ``use``
 =======
 .. versionadded:: 1.1
    Horizontal reuse was added in Twig 1.1.
 .. note::
    Horizontal reuse is an advanced Twig feature that is hardly ever needed in
    regular templates. It is mainly used by projects that need to make
    template blocks reusable without using inheritance.
 Template inheritance is one of the most powerful Twig's feature but it is
 limited to single inheritance; a template can only extend one other template.
 This limitation makes template inheritance simple to understand and easy to
 debug:
 .. code-block:: jinja
    {% extends "base.html" %}
    {% block title %}{% endblock %}
    {% block content %}{% endblock %}
 Horizontal reuse is a way to achieve the same goal as multiple inheritance,
 but without the associated complexity:
 .. code-block:: jinja
    {% extends "base.html" %}
    {% use "blocks.html" %}
    {% block title %}{% endblock %}
    {% block content %}{% endblock %}
 The ``use`` statement tells Twig to import the blocks defined in
 ```blocks.html`` into the current template (it's like macros, but for blocks):
 .. code-block:: jinja
    # blocks.html
    {% block sidebar %}{% endblock %}
 In this example, the ``use`` statement imports the ``sidebar`` block into the
 main template. The code is mostly equivalent to the following one (the
 imported blocks are not outputted automatically):
 .. code-block:: jinja
    {% extends "base.html" %}
    {% block sidebar %}{% endblock %}
    {% block title %}{% endblock %}
    {% block content %}{% endblock %}
 .. note::
    The ``use`` tag only imports a template if it does not extend another
    template, if it does not define macros, and if the body is empty. But it
    can *use* other templates.
 .. note::
    Because ``use`` statements are resolved independently of the context
    passed to the template, the template reference cannot be an expression.
 The main template can also override any imported block. If the template
 already defines the ``sidebar`` block, then the one defined in ``blocks.html``
 is ignored. To avoid name conflicts, you can rename imported blocks:
 .. code-block:: jinja
    {% extends "base.html" %}
    {% use "blocks.html" with sidebar as base_sidebar %}
    {% block sidebar %}{% endblock %}
    {% block title %}{% endblock %}
    {% block content %}{% endblock %}
 .. versionadded:: 1.3
    The ``parent()`` support was added in Twig 1.3.
 The ``parent()`` function automatically determines the correct inheritance
 tree, so it can be used when overriding a block defined in an imported
 template:
 .. code-block:: jinja
    {% extends "base.html" %}
    {% use "blocks.html" %}
    {% block sidebar %}
        {{ parent() }}
    {% endblock %}
    {% block title %}{% endblock %}
    {% block content %}{% endblock %}
 In this example, ``parent()`` will correctly call the ``sidebar`` block from
 the ``blocks.html`` template.
 .. tip::
    In Twig 1.2, renaming allows you to simulate inheritance by calling the
    "parent" block:
    .. code-block:: jinja
        {% extends "base.html" %}
        {% use "blocks.html" with sidebar as parent_sidebar %}
        {% block sidebar %}
            {{ block('parent_sidebar') }}
        {% endblock %}
 .. note::
    You can use as many ``use`` statements as you want in any given template.
    If two imported templates define the same block, the latest one wins.
--- a/lib/twig/doc/templates.rst
+++ b/lib/twig/doc/templates.rst
@ -1,719 +0,0 @@
 Twig for Template Designers
 ===========================
 This document describes the syntax and semantics of the template engine and
 will be most useful as reference to those creating Twig templates.
 Synopsis
 --------
 A template is simply a text file. It can generate any text-based format (HTML,
 XML, CSV, LaTeX, etc.). It doesn't have a specific extension, ``.html`` or
 ``.xml`` are just fine.
 A template contains **variables** or **expressions**, which get replaced with
 values when the template is evaluated, and **tags**, which control the logic
 of the template.
 Below is a minimal template that illustrates a few basics. We will cover the
 details later on:
 .. code-block:: html+jinja
    <!DOCTYPE html>
    <html>
        <head>
            <title>My Webpage</title>
        </head>
        <body>
            <ul id="navigation">
            {% for item in navigation %}
                <li><a href="{{ item.href }}">{{ item.caption }}</a></li>
            {% endfor %}
            </ul>
            <h1>My Webpage</h1>
            {{ a_variable }}
        </body>
    </html>
 There are two kinds of delimiters: ``{% ... %}`` and ``{{ ... }}``. The first
 one is used to execute statements such as for-loops, the latter prints the
 result of an expression to the template.
 IDEs Integration
 ----------------
 Many IDEs support syntax highlighting and auto-completion for Twig:
 * *Textmate* via the `Twig bundle`_
 * *Vim* via the `Jinja syntax plugin`_
 * *Netbeans* via the `Twig syntax plugin`_
 * *PhpStorm* (native as of 2.1)
 * *Eclipse* via the `Twig plugin`_
 * *Sublime Text* via the `Twig bundle`_
 * *GtkSourceView* via the `Twig language definition`_ (used by gedit and other projects)
 * *Coda* and *SubEthaEdit* via the `Twig syntax mode`_
 Variables
 ---------
 The application passes variables to the templates you can mess around in the
 template. Variables may have attributes or elements on them you can access
 too. How a variable looks like heavily depends on the application providing
 those.
 You can use a dot (``.``) to access attributes of a variable (methods or
 properties of a PHP object, or items of a PHP array), or the so-called
 "subscript" syntax (``[]``):
 .. code-block:: jinja
    {{ foo.bar }}
    {{ foo['bar'] }}
 .. note::
    It's important to know that the curly braces are *not* part of the
    variable but the print statement. If you access variables inside tags
    don't put the braces around.
 If a variable or attribute does not exist you will get back a ``null`` value.
 .. sidebar:: Implementation
    For convenience sake ``foo.bar`` does the following things on the PHP
    layer:
    * check if ``foo`` is an array and ``bar`` a valid element;
    * if not, and if ``foo`` is an object, check that ``bar`` is a valid property;
    * if not, and if ``foo`` is an object, check that ``bar`` is a valid method
      (even if ``bar`` is the constructor - use ``__construct()`` instead);
    * if not, and if ``foo`` is an object, check that ``getBar`` is a valid method;
    * if not, and if ``foo`` is an object, check that ``isBar`` is a valid method;
    * if not, return a ``null`` value.
    ``foo['bar']`` on the other hand only works with PHP arrays:
    * check if ``foo`` is an array and ``bar`` a valid element;
    * if not, return a ``null`` value.
 .. note::
    If you want to get a dynamic attribute on a variable, use the
    :doc:`attribute<functions/attribute>` function instead.
 Global Variables
 ~~~~~~~~~~~~~~~~
 The following variables are always available in templates:
 * ``_self``: references the current template;
 * ``_context``: references the current context;
 * ``_charset``: references the current charset.
 Setting Variables
 ~~~~~~~~~~~~~~~~~
 You can assign values to variables inside code blocks. Assignments use the
 :doc:`set<tags/set>` tag:
 .. code-block:: jinja
    {% set foo = 'foo' %}
    {% set foo = [1, 2] %}
    {% set foo = {'foo': 'bar'} %}
 Filters
 -------
 Variables can be modified by **filters**. Filters are separated from the
 variable by a pipe symbol (``|``) and may have optional arguments in
 parentheses. Multiple filters can be chained. The output of one filter is
 applied to the next.
 The following example removes all HTML tags from the ``name`` and title-cases
 it:
 .. code-block:: jinja
    {{ name|striptags|title }}
 Filters that accept arguments have parentheses around the arguments. This
 example will join a list by commas:
 .. code-block:: jinja
    {{ list|join(', ') }}
 To apply a filter on a section of code, wrap it with the
 :doc:`filter<tags/filter>` tag:
 .. code-block:: jinja
    {% filter upper %}
      This text becomes uppercase
    {% endfilter %}
 Go to the :doc:`filters<filters/index>` page to learn more about the built-in
 filters.
 Functions
 ---------
 Functions can be called to generate content. Functions are called by their
 name followed by parentheses (``()``) and may have arguments.
 For instance, the ``range`` function returns a list containing an arithmetic
 progression of integers:
 .. code-block:: jinja
    {% for i in range(0, 3) %}
        {{ i }},
    {% endfor %}
 Go to the :doc:`functions<functions/index>` page to learn more about the
 built-in functions.
 Control Structure
 -----------------
 A control structure refers to all those things that control the flow of a
 program - conditionals (i.e. ``if``/``elseif``/``else``), ``for``-loops, as
 well as things like blocks. Control structures appear inside ``{% ... %}``
 blocks.
 For example, to display a list of users provided in a variable called
 ``users``, use the :doc:`for<tags/for>` tag:
 .. code-block:: jinja
    <h1>Members</h1>
    <ul>
        {% for user in users %}
            <li>{{ user.username|e }}</li>
        {% endfor %}
    </ul>
 The :doc:`if<tags/if>` tag can be used to test an expression:
 .. code-block:: jinja
    {% if users|length > 0 %}
        <ul>
            {% for user in users %}
                <li>{{ user.username|e }}</li>
            {% endfor %}
        </ul>
    {% endif %}
 Go to the :doc:`tags<tags/index>` page to learn more about the built-in tags.
 Comments
 --------
 To comment-out part of a line in a template, use the comment syntax ``{# ...
 #}``. This is useful for debugging or to add information for other template
 designers or yourself:
 .. code-block:: jinja
    {# note: disabled template because we no longer use this
        {% for user in users %}
            ...
        {% endfor %}
    #}
 Including other Templates
 -------------------------
 The :doc:`include<tags/include>` tag is useful to include a template and
 return the rendered content of that template into the current one:
 .. code-block:: jinja
    {% include 'sidebar.html' %}
 Per default included templates are passed the current context.
 The context that is passed to the included template includes variables defined
 in the template:
 .. code-block:: jinja
    {% for box in boxes %}
        {% include "render_box.html" %}
    {% endfor %}
 The included template ``render_box.html`` is able to access ``box``.
 The filename of the template depends on the template loader. For instance, the
 ``Twig_Loader_Filesystem`` allows you to access other templates by giving the
 filename. You can access templates in subdirectories with a slash:
 .. code-block:: jinja
    {% include "sections/articles/sidebar.html" %}
 This behavior depends on the application embedding Twig.
 Template Inheritance
 --------------------
 The most powerful part of Twig is template inheritance. Template inheritance
 allows you to build a base "skeleton" template that contains all the common
 elements of your site and defines **blocks** that child templates can
 override.
 Sounds complicated but is very basic. It's easiest to understand it by
 starting with an example.
 Let's define a base template, ``base.html``, which defines a simple HTML
 skeleton document that you might use for a simple two-column page:
 .. code-block:: html+jinja
    <!DOCTYPE html>
    <html>
        <head>
            {% block head %}
                <link rel="stylesheet" href="style.css" />
                <title>{% block title %}{% endblock %} - My Webpage</title>
            {% endblock %}
        </head>
        <body>
            <div id="content">{% block content %}{% endblock %}</div>
            <div id="footer">
                {% block footer %}
                    &copy; Copyright 2011 by <a href="http://domain.invalid/">you</a>.
                {% endblock %}
            </div>
        </body>
    </html>
 In this example, the :doc:`block<tags/block>` tags define four blocks that
 child templates can fill in. All the ``block`` tag does is to tell the
 template engine that a child template may override those portions of the
 template.
 A child template might look like this:
 .. code-block:: jinja
    {% extends "base.html" %}
    {% block title %}Index{% endblock %}
    {% block head %}
        {{ parent() }}
        <style type="text/css">
            .important { color: #336699; }
        </style>
    {% endblock %}
    {% block content %}
        <h1>Index</h1>
        <p class="important">
            Welcome on my awesome homepage.
        </p>
    {% endblock %}
 The :doc:`extends<tags/extends>` tag is the key here. It tells the template
 engine that this template "extends" another template. When the template system
 evaluates this template, first it locates the parent. The extends tag should
 be the first tag in the template.
 Note that since the child template doesn't define the ``footer`` block, the
 value from the parent template is used instead.
 It's possible to render the contents of the parent block by using the
 :doc:`parent<functions/parent>` function. This gives back the results of the
 parent block:
 .. code-block:: jinja
    {% block sidebar %}
        <h3>Table Of Contents</h3>
        ...
        {{ parent() }}
    {% endblock %}
 .. tip::
    The documentation page for the :doc:`extends<tags/extends>` tag describes
    more advanced features like block nesting, scope, dynamic inheritance, and
    conditional inheritance.
 .. note::
    Twig also supports multiple inheritance with the so called horizontal reuse
    with the help of the :doc:`use<tags/use>` tag. This is an advanced feature
    hardly ever needed in regular templates.
 HTML Escaping
 -------------
 When generating HTML from templates, there's always a risk that a variable
 will include characters that affect the resulting HTML. There are two
 approaches: manually escaping each variable or automatically escaping
 everything by default.
 Twig supports both, automatic escaping is enabled by default.
 .. note::
    Automatic escaping is only supported if the *escaper* extension has been
    enabled (which is the default).
 Working with Manual Escaping
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 If manual escaping is enabled it's **your** responsibility to escape variables
 if needed. What to escape? If you have a variable that *may* include any of
 the following chars (``>``, ``<``, ``&``, or ``"``) you **have to** escape it
 unless the variable contains well-formed and trusted HTML. Escaping works by
 piping the variable through the :doc:`escape<filters/escape>` or ``e`` filter:
 .. code-block:: jinja
    {{ user.username|e }}
    {{ user.username|e('js') }}
 Working with Automatic Escaping
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Whether automatic escaping is enabled or not, you can mark a section of a
 template to be escaped or not by using the :doc:`autoescape<tags/autoescape>`
 tag:
 .. code-block:: jinja
    {% autoescape true %}
        Everything will be automatically escaped in this block
    {% endautoescape %}
 Escaping
 --------
 It is sometimes desirable or even necessary to have Twig ignore parts it would
 otherwise handle as variables or blocks. For example if the default syntax is
 used and you want to use ``{{`` as raw string in the template and not start a
 variable you have to use a trick.
 The easiest way is to output the variable delimiter (``{{``) by using a variable
 expression:
 .. code-block:: jinja
    {{ '{{' }}
 For bigger sections it makes sense to mark a block :doc:`raw<tags/raw>`.
 Macros
 ------
 Macros are comparable with functions in regular programming languages. They
 are useful to put often used HTML idioms into reusable elements to not repeat
 yourself.
 A macro is defined via the :doc:`macro<tags/macro>` tag. Here is a small
 example of a macro that renders a form element:
 .. code-block:: jinja
    {% macro input(name, value, type, size) %}
        <input type="{{ type|default('text') }}" name="{{ name }}" value="{{ value|e }}" size="{{ size|default(20) }}" />
    {% endmacro %}
 Macros can be defined in any template, and need to be "imported" before being
 used via the :doc:`import<tags/import>` tag:
 .. code-block:: jinja
    {% import "forms.html" as forms %}
    <p>{{ forms.input('username') }}</p>
 Alternatively you can import names from the template into the current
 namespace via the :doc:`from<tags/from>` tag:
 .. code-block:: jinja
    {% from 'forms.html' import input as input_field, textarea %}
    <dl>
        <dt>Username</dt>
        <dd>{{ input_field('username') }}</dd>
        <dt>Password</dt>
        <dd>{{ input_field('password', type='password') }}</dd>
    </dl>
    <p>{{ textarea('comment') }}</p>
 Expressions
 -----------
 Twig allows expressions everywhere. These work very similar to regular PHP and
 even if you're not working with PHP you should feel comfortable with it.
 .. note::
    The operator precedence is as follows, with the lowest-precedence
    operators listed first: ``&``, ``^``, ``|``, ``or``, ``and``, ``==``,
    ``!=``, ``<``, ``>``, ``>=``, ``<=``, ``in``, ``..``, ``+``, ``-``, ``~``,
    ``*``, ``/``, ``//``, ``%``, ``is``, and ``**``.
 Literals
 ~~~~~~~~
 .. versionadded:: 1.5
    Support for hash keys as names and expressions was added in Twig 1.5.
 The simplest form of expressions are literals. Literals are representations
 for PHP types such as strings, numbers, and arrays. The following literals
 exist:
 * ``"Hello World"``: Everything between two double or single quotes is a
  string. They are useful whenever you need a string in the template (for
  example as arguments to function calls, filters or just to extend or
  include a template).
 * ``42`` / ``42.23``: Integers and floating point numbers are created by just
  writing the number down. If a dot is present the number is a float,
  otherwise an integer.
 * ``["foo", "bar"]``: Arrays are defined by a sequence of expressions
  separated by a comma (``,``) and wrapped with squared brackets (``[]``).
 * ``{"foo": "bar"}``: Hashes are defined by a list of keys and values
  separated by a comma (``,``) and wrapped with curly braces (``{}``):
  .. code-block:: jinja
    {# keys as string #}
    { 'foo': 'foo', 'bar': 'bar' }
    {# keys as names (equivalent to the previous hash) -- as of Twig 1.5 #}
    { foo: 'foo', bar: 'bar' }
    {# keys as integer #}
    { 2: 'foo', 4: 'bar' }
    {# keys as expressions (the expression must be enclosed into parentheses) -- as of Twig 1.5 #}
    { (1 + 1): 'foo', (a ~ 'b'): 'bar' }
 * ``true`` / ``false``: ``true`` represents the true value, ``false``
  represents the false value.
 * ``null``: ``null`` represents no specific value. This is the value returned
  when a variable does not exist. ``none`` is an alias for ``null``.
 Arrays and hashes can be nested:
 .. code-block:: jinja
    {% set foo = [1, {"foo": "bar"}] %}
 Math
 ~~~~
 Twig allows you to calculate with values. This is rarely useful in templates
 but exists for completeness' sake. The following operators are supported:
 * ``+``: Adds two objects together (the operands are casted to numbers). ``{{
  1 + 1 }}`` is ``2``.
 * ``-``: Substracts the second number from the first one. ``{{ 3 - 2 }}`` is
  ``1``.
 * ``/``: Divides two numbers. The return value will be a floating point
  number. ``{{ 1 / 2 }}`` is ``{{ 0.5 }}``.
 * ``%``: Calculates the remainder of an integer division. ``{{ 11 % 7 }}`` is
  ``4``.
 * ``//``: Divides two numbers and returns the truncated integer result. ``{{
  20 // 7 }}`` is ``2``.
 * ``*``: Multiplies the left operand with the right one. ``{{ 2 * 2 }}`` would
  return ``4``.
 * ``**``: Raises the left operand to the power of the right operand. ``{{ 2 **
  3 }}`` would return ``8``.
 Logic
 ~~~~~
 You can combine multiple expressions with the following operators:
 * ``and``: Returns true if the left and the right operands are both true.
 * ``or``: Returns true if the left or the right operand is true.
 * ``not``: Negates a statement.
 * ``(expr)``: Groups an expression.
 Comparisons
 ~~~~~~~~~~~
 The following comparison operators are supported in any expression: ``==``,
 ``!=``, ``<``, ``>``, ``>=``, and ``<=``.
 Containment Operator
 ~~~~~~~~~~~~~~~~~~~~
 The ``in`` operator performs containment test.
 It returns ``true`` if the left operand is contained in the right:
 .. code-block:: jinja
    {# returns true #}
    {{ 1 in [1, 2, 3] }}
    {{ 'cd' in 'abcde' }}
 .. tip::
    You can use this filter to perform a containment test on strings, arrays,
    or objects implementing the ``Traversable`` interface.
 To perform a negative test, use the ``not in`` operator:
 .. code-block:: jinja
    {% if 1 not in [1, 2, 3] %}
    {# is equivalent to #}
    {% if not (1 in [1, 2, 3]) %}
 Test Operator
 ~~~~~~~~~~~~~
 The ``is`` operator performs tests. Tests can be used to test a variable against
 a common expression. The right operand is name of the test:
 .. code-block:: jinja
    {# find out if a variable is odd #}
    {{ name is odd }}
 Tests can accept arguments too:
 .. code-block:: jinja
    {% if loop.index is divisibleby(3) %}
 Tests can be negated by using the ``is not`` operator:
 .. code-block:: jinja
    {% if loop.index is not divisibleby(3) %}
    {# is equivalent to #}
    {% if not (loop.index is divisibleby(3)) %}
 Go to the :doc:`tests<tests/index>` page to learn more about the built-in
 tests.
 Other Operators
 ~~~~~~~~~~~~~~~
 The following operators are very useful but don't fit into any of the other
 categories:
 * ``..``: Creates a sequence based on the operand before and after the
  operator (this is just syntactic sugar for the :doc:`range<functions/range>`
  function).
 * ``|``: Applies a filter.
 * ``~``: Converts all operands into strings and concatenates them. ``{{ "Hello
  " ~ name ~ "!" }}`` would return (assuming ``name`` is ``'John'``) ``Hello
  John!``.
 * ``.``, ``[]``: Gets an attribute of an object.
 * ``?:``: The PHP ternary operator: ``{{ foo ? 'yes' : 'no' }}``
 String Interpolation
 ~~~~~~~~~~~~~~~~~~~~
 .. versionadded:: 1.5
    String interpolation was added in Twig 1.5.
 String interpolation (`#{expression}`) allows any valid expression to appear
 within a string. The result of evaluating that expression is inserted into the
 string:
 .. code-block:: jinja
    {{ "foo #{bar} baz" }}
    {{ "foo #{1 + 2} baz" }}
 Whitespace Control
 ------------------
 .. versionadded:: 1.1
    Tag level whitespace control was added in Twig 1.1.
 The first newline after a template tag is removed automatically (like in PHP.)
 Whitespace is not further modified by the template engine, so each whitespace
 (spaces, tabs, newlines etc.) is returned unchanged.
 Use the ``spaceless`` tag to remove whitespace *between HTML tags*:
 .. code-block:: jinja
    {% spaceless %}
        <div>
            <strong>foo</strong>
        </div>
    {% endspaceless %}
    {# output will be <div><strong>foo</strong></div> #}
 In addition to the spaceless tag you can also control whitespace on a per tag
 level. By using the whitespace control modifier on your tags, you can trim
 leading and or trailing whitespace:
 .. code-block:: jinja
    {% set value = 'no spaces' %}
    {#- No leading/trailing whitespace -#}
    {%- if true -%}
        {{- value -}}
    {%- endif -%}
    {# output 'no spaces' #}
 The above sample shows the default whitespace control modifier, and how you can
 use it to remove whitespace around tags.  Trimming space will consume all whitespace
 for that side of the tag.  It is possible to use whitespace trimming on one side
 of a tag:
 .. code-block:: jinja
    {% set value = 'no spaces' %}
    <li>    {{- value }}    </li>
    {# outputs '<li>no spaces    </li>' #}
 Extensions
 ----------
 Twig can be easily extended.
 If you are looking for new tags, filters, or functions, have a look at the Twig official
 `extension repository`_.
 If you want to create your own, read :doc:`extensions`.
 .. _`Twig bundle`:              https://github.com/Anomareh/PHP-Twig.tmbundle
 .. _`Jinja syntax plugin`:      http://jinja.pocoo.org/2/documentation/integration
 .. _`Twig syntax plugin`:       http://plugins.netbeans.org/plugin/37069/php-twig
 .. _`Twig plugin`:              https://github.com/pulse00/Twig-Eclipse-Plugin
 .. _`Twig language definition`: https://github.com/gabrielcorpse/gedit-twig-template-language
 .. _`extension repository`:     http://github.com/fabpot/Twig-extensions
 .. _`Twig syntax mode`:         https://github.com/bobthecow/Twig-HTML.mode
--- a/lib/twig/doc/tests/constant.rst
+++ b/lib/twig/doc/tests/constant.rst
@ -1,11 +0,0 @@
 ``constant``
 ============
 ``constant`` checks if a variable has the exact same value as a constant. You
 can use either global constants or class constants:
 .. code-block:: jinja
    {% if post.status is constant('Post::PUBLISHED') %}
        the status attribute is exactly the same as Post::PUBLISHED
    {% endif %}
--- a/lib/twig/doc/tests/defined.rst
+++ b/lib/twig/doc/tests/defined.rst
@ -1,30 +0,0 @@
 ``defined``
 ===========
 ``defined`` checks if a variable is defined in the current context. This is very
 useful if you use the ``strict_variables`` option:
 .. code-block:: jinja
    {# defined works with variable names #}
    {% if foo is defined %}
        ...
    {% endif %}
    {# and attributes on variables names #}
    {% if foo.bar is defined %}
        ...
    {% endif %}
    {% if foo['bar'] is defined %}
        ...
    {% endif %}
 When using the ``defined`` test on an expression that uses variables in some
 method calls, be sure that they are all defined first:
 .. code-block:: jinja
    {% if var is defined and foo.method(var) is defined %}
        ...
    {% endif %}
--- a/lib/twig/doc/tests/divisibleby.rst
+++ b/lib/twig/doc/tests/divisibleby.rst
@ -1,10 +0,0 @@
 ``divisibleby``
 ===============
 ``divisibleby`` checks if a variable is divisible by a number:
 .. code-block:: jinja
    {% if loop.index is divisibleby(3) %}
        ...
    {% endif %}
--- a/lib/twig/doc/tests/empty.rst
+++ b/lib/twig/doc/tests/empty.rst
@ -1,11 +0,0 @@
 ``empty``
 =========
 ``empty`` checks if a variable is empty:
 .. code-block:: jinja
    {# evaluates to true if the foo variable is null, false, or the empty string #}
    {% if foo is empty %}
        ...
    {% endif %}
--- a/lib/twig/doc/tests/even.rst
+++ b/lib/twig/doc/tests/even.rst
@ -1,10 +0,0 @@
 ``even``
 ========
 ``even`` returns ``true`` if the given number is even:
 .. code-block:: jinja
    {{ var is even }}
 .. seealso:: :doc:`odd<../tests/odd>`
--- a/lib/twig/doc/tests/index.rst
+++ b/lib/twig/doc/tests/index.rst
@ -1,14 +0,0 @@
 Tests
 =====
 .. toctree::
    :maxdepth: 1
    divisibleby
    null
    even
    odd
    sameas
    constant
    defined
    empty
--- a/lib/twig/doc/tests/null.rst
+++ b/lib/twig/doc/tests/null.rst
@ -1,12 +0,0 @@
 ``null``
 ========
 ``null`` returns ``true`` if the variable is ``null``:
 .. code-block:: jinja
    {{ var is null }}
 .. note::
    ``none`` is an alias for ``null``.
--- a/lib/twig/doc/tests/odd.rst
+++ b/lib/twig/doc/tests/odd.rst
@ -1,10 +0,0 @@
 ``odd``
 =======
 ``odd`` returns ``true`` if the given number is odd:
 .. code-block:: jinja
    {{ var is odd }}
 .. seealso:: :doc:`even<../tests/even>`
--- a/lib/twig/doc/tests/sameas.rst
+++ b/lib/twig/doc/tests/sameas.rst
@ -1,11 +0,0 @@
 ``sameas``
 ==========
 ``sameas`` checks if a variable points to the same memory address than another
 variable:
 .. code-block:: jinja
    {% if foo.attribute is sameas(false) %}
        the foo attribute really is the ``false`` PHP value
    {% endif %}
--- a/lib/twig/ext/twig/.gitignore
+++ b/lib/twig/ext/twig/.gitignore
@ -1,30 +0,0 @@
 *.sw*
 .deps
 Makefile
 Makefile.fragments
 Makefile.global
 Makefile.objects
 acinclude.m4
 aclocal.m4
 build/
 config.cache
 config.guess
 config.h
 config.h.in
 config.log
 config.nice
 config.status
 config.sub
 configure
 configure.in
 install-sh
 libtool
 ltmain.sh
 missing
 mkinstalldirs
 run-tests.php
 twig.loT
 .libs/
 modules/
 twig.la
 twig.lo
--- a/lib/twig/ext/twig/LICENSE
+++ b/lib/twig/ext/twig/LICENSE
@ -1,22 +0,0 @@
 Copyright (c) 2011, Derick Rethans <derick@derickrethans.nl>
 All rights reserved.
 Redistribution and use in source and binary forms, with or without 
 modification, are permitted provided that the following conditions are met:
    * Redistributions of source code must retain the above copyright notice, 
      this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright 
      notice, this list of conditions and the following disclaimer in the 
      documentation and/or other materials provided with the distribution.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- a/lib/twig/ext/twig/config.m4
+++ b/lib/twig/ext/twig/config.m4
@ -1,8 +0,0 @@
 dnl config.m4 for extension twig
 PHP_ARG_ENABLE(twig, whether to enable twig support,
 [  --enable-twig           Enable twig support])
 if test "$PHP_TWIG" != "no"; then
  PHP_NEW_EXTENSION(twig, twig.c, $ext_shared)
 fi
--- a/lib/twig/ext/twig/config.w32
+++ b/lib/twig/ext/twig/config.w32
@ -1,8 +0,0 @@
 // vim:ft=javascript
 ARG_ENABLE("twig", "Twig support", "no");
 if (PHP_TWIG != "no") {
 	AC_DEFINE('HAVE_TWIG', 1);
 	EXTENSION('twig', 'twig.c');
 }
--- a/lib/twig/ext/twig/php_twig.h
+++ b/lib/twig/ext/twig/php_twig.h
@ -1,49 +0,0 @@
 /*
   +----------------------------------------------------------------------+
   | Twig Extension                                                       |
   +----------------------------------------------------------------------+
   | Copyright (c) 2011 Derick Rethans                                    |
   +----------------------------------------------------------------------+
   | Redistribution and use in source and binary forms, with or without   |
   | modification, are permitted provided that the conditions mentioned   |
   | in the accompanying LICENSE file are met (BSD, revised).             |
   +----------------------------------------------------------------------+
   | Author: Derick Rethans <derick@derickrethans.nl>                     |
   +----------------------------------------------------------------------+
 */
 #ifndef PHP_TWIG_H
 #define PHP_TWIG_H
 #define PHP_TWIG_VERSION "1.6.4"
 #include "php.h"
 extern zend_module_entry twig_module_entry;
 #define phpext_twig_ptr &twig_module_entry
 #ifdef PHP_WIN32
 #define PHP_TWIG_API __declspec(dllexport)
 #else
 #define PHP_TWIG_API
 #endif
 #ifdef ZTS
 #include "TSRM.h"
 #endif
 PHP_FUNCTION(twig_template_get_attributes);
 PHP_MINIT_FUNCTION(twig);
 PHP_MSHUTDOWN_FUNCTION(twig);
 PHP_RINIT_FUNCTION(twig);
 PHP_RSHUTDOWN_FUNCTION(twig);
 PHP_MINFO_FUNCTION(twig);
 #ifdef ZTS
 #define TWIG_G(v) TSRMG(twig_globals_id, zend_twig_globals *, v)
 #else
 #define TWIG_G(v) (twig_globals.v)
 #endif
 #endif
--- a/lib/twig/ext/twig/twig.c
+++ b/lib/twig/ext/twig/twig.c
--- a/lib/twig/lib/Twig/Error.php
+++ b/lib/twig/lib/Twig/Error.php
@ -1,176 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2009 Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 /**
 * Twig base exception.
 *
 * @package    twig
 * @author     Fabien Potencier <fabien@symfony.com>
 */
 class Twig_Error extends Exception
 {
    protected $lineno;
    protected $filename;
    protected $rawMessage;
    protected $previous;
    /**
     * Constructor.
     *
     * @param string    $message  The error message
     * @param integer   $lineno   The template line where the error occurred
     * @param string    $filename The template file name where the error occurred
     * @param Exception $previous The previous exception
     */
    public function __construct($message, $lineno = -1, $filename = null, Exception $previous = null)
    {
        if (-1 === $lineno || null === $filename) {
            if ($trace = $this->getTemplateTrace()) {
                if (-1 === $lineno) {
                    $lineno = $this->guessTemplateLine($trace);
                }
                if (null === $filename) {
                    $filename = $trace['object']->getTemplateName();
                }
            }
        }
        $this->lineno = $lineno;
        $this->filename = $filename;
        $this->rawMessage = $message;
        $this->updateRepr();
        if (version_compare(PHP_VERSION, '5.3.0', '<')) {
            $this->previous = $previous;
            parent::__construct($this->message);
        } else {
            parent::__construct($this->message, 0, $previous);
        }
    }
    /**
     * Gets the raw message.
     *
     * @return string The raw message
     */
    public function getRawMessage()
    {
        return $this->rawMessage;
    }
    /**
     * Gets the filename where the error occurred.
     *
     * @return string The filename
     */
    public function getTemplateFile()
    {
        return $this->filename;
    }
    /**
     * Sets the filename where the error occurred.
     *
     * @param string $filename The filename
     */
    public function setTemplateFile($filename)
    {
        $this->filename = $filename;
        $this->updateRepr();
    }
    /**
     * Gets the template line where the error occurred.
     *
     * @return integer The template line
     */
    public function getTemplateLine()
    {
        return $this->lineno;
    }
    /**
     * Sets the template line where the error occurred.
     *
     * @param integer $lineno The template line
     */
    public function setTemplateLine($lineno)
    {
        $this->lineno = $lineno;
        $this->updateRepr();
    }
    /**
     * For PHP < 5.3.0, provides access to the getPrevious() method.
     *
     * @param  string $method    The method name
     * @param  array  $arguments The parameters to be passed to the method
     *
     * @return Exception The previous exception or null
     */
    public function __call($method, $arguments)
    {
        if ('getprevious' == strtolower($method)) {
            return $this->previous;
        }
        throw new BadMethodCallException(sprintf('Method "Twig_Error::%s()" does not exist.', $method));
    }
    protected function updateRepr()
    {
        $this->message = $this->rawMessage;
        $dot = false;
        if ('.' === substr($this->message, -1)) {
            $this->message = substr($this->message, 0, -1);
            $dot = true;
        }
        if (null !== $this->filename) {
            $this->message .= sprintf(' in %s', is_string($this->filename) ? '"'.$this->filename.'"' : json_encode($this->filename));
        }
        if ($this->lineno >= 0) {
            $this->message .= sprintf(' at line %d', $this->lineno);
        }
        if ($dot) {
            $this->message .= '.';
        }
    }
    protected function getTemplateTrace()
    {
        foreach (debug_backtrace() as $trace) {
            if (isset($trace['object']) && $trace['object'] instanceof Twig_Template) {
                return $trace;
            }
        }
    }
    protected function guessTemplateLine($trace)
    {
        if (isset($trace['line'])) {
            foreach ($trace['object']->getDebugInfo() as $codeLine => $templateLine) {
                if ($codeLine <= $trace['line']) {
                    return $templateLine;
                }
            }
        }
        return -1;
    }
 }
--- a/lib/twig/lib/Twig/Error/Loader.php
+++ b/lib/twig/lib/Twig/Error/Loader.php
@ -1,20 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2010 Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 /**
 * Exception thrown when an error occurs during template loading.
 *
 * @package    twig
 * @author     Fabien Potencier <fabien@symfony.com>
 */
 class Twig_Error_Loader extends Twig_Error
 {
 }
--- a/lib/twig/lib/Twig/FilterInterface.php
+++ b/lib/twig/lib/Twig/FilterInterface.php
@ -1,38 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2010 Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 /**
 * Represents a template filter.
 *
 * @package    twig
 * @author     Fabien Potencier <fabien@symfony.com>
 */
 interface Twig_FilterInterface
 {
    /**
     * Compiles a filter.
     *
     * @return string The PHP code for the filter
     */
    function compile();
    function needsEnvironment();
    function needsContext();
    function getSafe(Twig_Node $filterArgs);
    function getPreEscape();
    function setArguments($arguments);
    function getArguments();
 }
--- a/lib/twig/lib/Twig/Loader/Chain.php
+++ b/lib/twig/lib/Twig/Loader/Chain.php
@ -1,100 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2011 Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 /**
 * Loads templates from other loaders.
 *
 * @package twig
 * @author  Fabien Potencier <fabien@symfony.com>
 */
 class Twig_Loader_Chain implements Twig_LoaderInterface
 {
    protected $loaders;
    /**
     * Constructor.
     *
     * @param Twig_LoaderInterface[] $loaders An array of loader instances
     */
    public function __construct(array $loaders = array())
    {
        $this->loaders = array();
        foreach ($loaders as $loader) {
            $this->addLoader($loader);
        }
    }
    /**
     * Adds a loader instance.
     *
     * @param Twig_LoaderInterface $loader A Loader instance
     */
    public function addLoader(Twig_LoaderInterface $loader)
    {
        $this->loaders[] = $loader;
    }
    /**
     * Gets the source code of a template, given its name.
     *
     * @param  string $name The name of the template to load
     *
     * @return string The template source code
     */
    public function getSource($name)
    {
        foreach ($this->loaders as $loader) {
            try {
                return $loader->getSource($name);
            } catch (Twig_Error_Loader $e) {
            }
        }
        throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
    }
    /**
     * Gets the cache key to use for the cache for a given template name.
     *
     * @param  string $name The name of the template to load
     *
     * @return string The cache key
     */
    public function getCacheKey($name)
    {
        foreach ($this->loaders as $loader) {
            try {
                return $loader->getCacheKey($name);
            } catch (Twig_Error_Loader $e) {
            }
        }
        throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
    }
    /**
     * Returns true if the template is still fresh.
     *
     * @param string    $name The template name
     * @param timestamp $time The last modification time of the cached template
     */
    public function isFresh($name, $time)
    {
        foreach ($this->loaders as $loader) {
            try {
                return $loader->isFresh($name, $time);
            } catch (Twig_Error_Loader $e) {
            }
        }
        throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
    }
 }
--- a/lib/twig/lib/Twig/Loader/Filesystem.php
+++ b/lib/twig/lib/Twig/Loader/Filesystem.php
@ -1,152 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2009 Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 /**
 * Loads template from the filesystem.
 *
 * @package    twig
 * @author     Fabien Potencier <fabien@symfony.com>
 */
 class Twig_Loader_Filesystem implements Twig_LoaderInterface
 {
    protected $paths;
    protected $cache;
    /**
     * Constructor.
     *
     * @param string|array $paths A path or an array of paths where to look for templates
     */
    public function __construct($paths)
    {
        $this->setPaths($paths);
    }
    /**
     * Returns the paths to the templates.
     *
     * @return array The array of paths where to look for templates
     */
    public function getPaths()
    {
        return $this->paths;
    }
    /**
     * Sets the paths where templates are stored.
     *
     * @param string|array $paths A path or an array of paths where to look for templates
     */
    public function setPaths($paths)
    {
        if (!is_array($paths)) {
            $paths = array($paths);
        }
        $this->paths = array();
        foreach ($paths as $path) {
            $this->addPath($path);
        }
    }
    /**
     * Adds a path where templates are stored.
     *
     * @param string $path A path where to look for templates
     */
    public function addPath($path)
    {
        // invalidate the cache
        $this->cache = array();
        if (!is_dir($path)) {
            throw new Twig_Error_Loader(sprintf('The "%s" directory does not exist.', $path));
        }
        $this->paths[] = $path;
    }
    /**
     * Gets the source code of a template, given its name.
     *
     * @param  string $name The name of the template to load
     *
     * @return string The template source code
     */
    public function getSource($name)
    {
        return file_get_contents($this->findTemplate($name));
    }
    /**
     * Gets the cache key to use for the cache for a given template name.
     *
     * @param  string $name The name of the template to load
     *
     * @return string The cache key
     */
    public function getCacheKey($name)
    {
        return $this->findTemplate($name);
    }
    /**
     * Returns true if the template is still fresh.
     *
     * @param string    $name The template name
     * @param timestamp $time The last modification time of the cached template
     */
    public function isFresh($name, $time)
    {
        return filemtime($this->findTemplate($name)) < $time;
    }
    protected function findTemplate($name)
    {
        // normalize name
        $name = preg_replace('#/{2,}#', '/', strtr($name, '\\', '/'));
        if (isset($this->cache[$name])) {
            return $this->cache[$name];
        }
        $this->validateName($name);
        foreach ($this->paths as $path) {
            if (is_file($path.'/'.$name)) {
                return $this->cache[$name] = $path.'/'.$name;
            }
        }
        throw new Twig_Error_Loader(sprintf('Unable to find template "%s" (looked into: %s).', $name, implode(', ', $this->paths)));
    }
    protected function validateName($name)
    {
        if (false !== strpos($name, "\0")) {
            throw new Twig_Error_Loader('A template name cannot contain NUL bytes.');
        }
        $parts = explode('/', $name);
        $level = 0;
        foreach ($parts as $part) {
            if ('..' === $part) {
                --$level;
            } elseif ('.' !== $part) {
                ++$level;
            }
            if ($level < 0) {
                throw new Twig_Error_Loader(sprintf('Looks like you try to load a template outside configured directories (%s).', $name));
            }
        }
    }
 }
--- a/lib/twig/lib/Twig/Node/Expression/Filter.php
+++ b/lib/twig/lib/Twig/Node/Expression/Filter.php
@ -1,61 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2009 Fabien Potencier
 * (c) 2009 Armin Ronacher
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Node_Expression_Filter extends Twig_Node_Expression
 {
    public function __construct(Twig_NodeInterface $node, Twig_Node_Expression_Constant $filterName, Twig_NodeInterface $arguments, $lineno, $tag = null)
    {
        parent::__construct(array('node' => $node, 'filter' => $filterName, 'arguments' => $arguments), array(), $lineno, $tag);
    }
    public function compile(Twig_Compiler $compiler)
    {
        $name = $this->getNode('filter')->getAttribute('value');
        if (false === $filter = $compiler->getEnvironment()->getFilter($name)) {
            $message = sprintf('The filter "%s" does not exist', $name);
            if ($alternatives = $compiler->getEnvironment()->computeAlternatives($name, array_keys($compiler->getEnvironment()->getFilters()))) {
                $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
            }
            throw new Twig_Error_Syntax($message, $this->getLine());
        }
        $this->compileFilter($compiler, $filter);
    }
    protected function compileFilter(Twig_Compiler $compiler, Twig_FilterInterface $filter)
    {
        $compiler
            ->raw($filter->compile().'(')
            ->raw($filter->needsEnvironment() ? '$this->env, ' : '')
            ->raw($filter->needsContext() ? '$context, ' : '')
        ;
        foreach ($filter->getArguments() as $argument) {
            $compiler
                ->string($argument)
                ->raw(', ')
            ;
        }
        $compiler->subcompile($this->getNode('node'));
        foreach ($this->getNode('arguments') as $node) {
            $compiler
                ->raw(', ')
                ->subcompile($node)
            ;
        }
        $compiler->raw(')');
    }
 }
--- a/lib/twig/lib/Twig/Node/Expression/Function.php
+++ b/lib/twig/lib/Twig/Node/Expression/Function.php
@ -1,66 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2010 Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Node_Expression_Function extends Twig_Node_Expression
 {
    public function __construct($name, Twig_NodeInterface $arguments, $lineno)
    {
        parent::__construct(array('arguments' => $arguments), array('name' => $name), $lineno);
    }
    public function compile(Twig_Compiler $compiler)
    {
        $name = $this->getAttribute('name');
        if (false === $function = $compiler->getEnvironment()->getFunction($name)) {
            $message = sprintf('The function "%s" does not exist', $name);
            if ($alternatives = $compiler->getEnvironment()->computeAlternatives($name, array_keys($compiler->getEnvironment()->getFunctions()))) {
                $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
            }
            throw new Twig_Error_Syntax($message, $this->getLine());
        }
        $compiler->raw($function->compile().'(');
        $first = true;
        if ($function->needsEnvironment()) {
            $compiler->raw('$this->env');
            $first = false;
        }
        if ($function->needsContext()) {
            if (!$first) {
                $compiler->raw(', ');
            }
            $compiler->raw('$context');
            $first = false;
        }
        foreach ($function->getArguments() as $argument) {
            if (!$first) {
                $compiler->raw(', ');
            }
            $compiler->string($argument);
            $first = false;
        }
        foreach ($this->getNode('arguments') as $node) {
            if (!$first) {
                $compiler->raw(', ');
            }
            $compiler->subcompile($node);
            $first = false;
        }
        $compiler->raw(')');
    }
 }
--- a/lib/twig/lib/Twig/Node/Expression/Test.php
+++ b/lib/twig/lib/Twig/Node/Expression/Test.php
@ -1,54 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2010 Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Node_Expression_Test extends Twig_Node_Expression
 {
    public function __construct(Twig_NodeInterface $node, $name, Twig_NodeInterface $arguments = null, $lineno)
    {
        parent::__construct(array('node' => $node, 'arguments' => $arguments), array('name' => $name), $lineno);
    }
    public function compile(Twig_Compiler $compiler)
    {
        $name = $this->getAttribute('name');
        $testMap = $compiler->getEnvironment()->getTests();
        if (!isset($testMap[$name])) {
            $message = sprintf('The test "%s" does not exist', $name);
            if ($alternatives = $compiler->getEnvironment()->computeAlternatives($name, array_keys($compiler->getEnvironment()->getTests()))) {
                $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
            }
            throw new Twig_Error_Syntax($message, $this->getLine());
        }
        $name = $this->getAttribute('name');
        $node = $this->getNode('node');
        $compiler
            ->raw($testMap[$name]->compile().'(')
            ->subcompile($node)
        ;
        if (null !== $this->getNode('arguments')) {
            $compiler->raw(', ');
            $max = count($this->getNode('arguments')) - 1;
            foreach ($this->getNode('arguments') as $i => $arg) {
                $compiler->subcompile($arg);
                if ($i != $max) {
                    $compiler->raw(', ');
                }
            }
        }
        $compiler->raw(')');
    }
 }
--- a/lib/twig/lib/Twig/TokenParser/For.php
+++ b/lib/twig/lib/Twig/TokenParser/For.php
@ -1,89 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) 2009 Fabien Potencier
 * (c) 2009 Armin Ronacher
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 /**
 * Loops over each item of a sequence.
 *
 * <pre>
 * <ul>
 *  {% for user in users %}
 *    <li>{{ user.username|e }}</li>
 *  {% endfor %}
 * </ul>
 * </pre>
 */
 class Twig_TokenParser_For extends Twig_TokenParser
 {
    /**
     * Parses a token and returns a node.
     *
     * @param Twig_Token $token A Twig_Token instance
     *
     * @return Twig_NodeInterface A Twig_NodeInterface instance
     */
    public function parse(Twig_Token $token)
    {
        $lineno = $token->getLine();
        $targets = $this->parser->getExpressionParser()->parseAssignmentExpression();
        $this->parser->getStream()->expect(Twig_Token::OPERATOR_TYPE, 'in');
        $seq = $this->parser->getExpressionParser()->parseExpression();
        $ifexpr = null;
        if ($this->parser->getStream()->test(Twig_Token::NAME_TYPE, 'if')) {
            $this->parser->getStream()->next();
            $ifexpr = $this->parser->getExpressionParser()->parseExpression();
        }
        $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
        $body = $this->parser->subparse(array($this, 'decideForFork'));
        if ($this->parser->getStream()->next()->getValue() == 'else') {
            $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
            $else = $this->parser->subparse(array($this, 'decideForEnd'), true);
        } else {
            $else = null;
        }
        $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
        if (count($targets) > 1) {
            $keyTarget = $targets->getNode(0);
            $keyTarget = new Twig_Node_Expression_AssignName($keyTarget->getAttribute('name'), $keyTarget->getLine());
            $valueTarget = $targets->getNode(1);
            $valueTarget = new Twig_Node_Expression_AssignName($valueTarget->getAttribute('name'), $valueTarget->getLine());
        } else {
            $keyTarget = new Twig_Node_Expression_AssignName('_key', $lineno);
            $valueTarget = $targets->getNode(0);
            $valueTarget = new Twig_Node_Expression_AssignName($valueTarget->getAttribute('name'), $valueTarget->getLine());
        }
        return new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, $lineno, $this->getTag());
    }
    public function decideForFork(Twig_Token $token)
    {
        return $token->test(array('else', 'endfor'));
    }
    public function decideForEnd(Twig_Token $token)
    {
        return $token->test('endfor');
    }
    /**
     * Gets the tag name associated with this token parser.
     *
     * @return string The tag name
     */
    public function getTag()
    {
        return 'for';
    }
 }
--- a/lib/twig/package.xml.tpl
+++ b/lib/twig/package.xml.tpl
@ -1,64 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <package packagerversion="1.8.0" version="2.0" xmlns="http://pear.php.net/dtd/package-2.0" xmlns:tasks="http://pear.php.net/dtd/tasks-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://pear.php.net/dtd/tasks-1.0
    http://pear.php.net/dtd/tasks-1.0.xsd
    http://pear.php.net/dtd/package-2.0
    http://pear.php.net/dtd/package-2.0.xsd">
 <name>Twig</name>
 <channel>pear.twig-project.org</channel>
 <summary>Twig is a PHP template engine.</summary>
 <description>
   Twig is a template language for PHP, released under the new BSD license
   (code and documentation).
   Twig uses a syntax similar to the Django and Jinja template languages which
   inspired the Twig runtime environment.
 </description>
 <lead>
  <name>Fabien Potencier</name>
  <user>fabpot</user>
  <email>fabien.potencier@symfony-project.org</email>
  <active>yes</active>
 </lead>
 <lead>
  <name>Armin Ronacher</name>
  <user>armin</user>
  <email>armin.ronacher@active-4.com</email>
  <active>no</active>
 </lead>
 <date>{{ date }}</date>
 <time>{{ time }}</time>
 <version>
  <release>{{ version }}</release>
  <api>{{ api_version }}</api>
 </version>
 <stability>
  <release>{{ stability }}</release>
  <api>{{ stability }}</api>
 </stability>
 <license uri="http://www.opensource.org/licenses/bsd-license.php">BSD Style</license>
 <notes>-</notes>
 <contents>
   <dir name="/">
     <file name="AUTHORS" role="doc" />
     <file name="CHANGELOG" role="doc" />
     <file name="LICENSE" role="doc" />
     <file name="README.markdown" role="doc" />
     <dir name="lib">
      <dir name="Twig">
 {{ files }}
      </dir>
     </dir>
   </dir>
 </contents>
 <dependencies>
  <required>
   <php>
    <min>5.2.4</min>
   </php>
   <pearinstaller>
    <min>1.4.0</min>
   </pearinstaller>
  </required>
 </dependencies>
 <phprelease />
 </package>
--- a/lib/twig/test/Twig/Tests/AutoloaderTest.php
+++ b/lib/twig/test/Twig/Tests/AutoloaderTest.php
@ -1,21 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Tests_AutoloaderTest extends PHPUnit_Framework_TestCase
 {
    public function testAutoload()
    {
        $this->assertFalse(class_exists('FooBarFoo'), '->autoload() does not try to load classes that does not begin with Twig');
        $autoloader = new Twig_Autoloader();
        $this->assertNull($autoloader->autoload('Foo'), '->autoload() returns false if it is not able to load a class');
    }
 }
--- a/lib/twig/test/Twig/Tests/CompilerTest.php
+++ b/lib/twig/test/Twig/Tests/CompilerTest.php
@ -1,33 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Tests_CompilerTest extends PHPUnit_Framework_TestCase
 {
    public function testReprNumericValueWithLocale()
    {
        $compiler = new Twig_Compiler(new Twig_Environment());
        $locale = setlocale(LC_NUMERIC, 0);
        if (false === $locale) {
            $this->markTestSkipped('Your platform does not support locales.');
        }
        $required_locales = array('fr_FR.UTF-8', 'fr_FR.UTF8', 'fr_FR.utf-8', 'fr_FR.utf8', 'French_France.1252');
        if (false === setlocale(LC_ALL, $required_locales)) {
            $this->markTestSkipped('Could not set any of required locales: ' . implode(", ", $required_locales));
        }
        $this->assertEquals('1.2', $compiler->repr(1.2)->getSource());
        $this->assertContains('fr', strtolower(setlocale(LC_NUMERIC, 0)));
        setlocale(LC_ALL, $locale);
    }
 }
--- a/lib/twig/test/Twig/Tests/ErrorTest.php
+++ b/lib/twig/test/Twig/Tests/ErrorTest.php
@ -1,81 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Tests_ErrorTest extends PHPUnit_Framework_TestCase
 {
    public function testTwigExceptionAddsFileAndLineWhenMissing()
    {
        $loader = new Twig_Loader_Array(array('index' => "\n\n{{ foo.bar }}"));
        $twig = new Twig_Environment($loader, array('strict_variables' => true, 'debug' => true, 'cache' => false));
        $template = $twig->loadTemplate('index');
        try {
            $template->render(array());
            $this->fail();
        } catch (Twig_Error_Runtime $e) {
            $this->assertEquals('Variable "foo" does not exist in "index" at line 3', $e->getMessage());
            $this->assertEquals(3, $e->getTemplateLine());
            $this->assertEquals('index', $e->getTemplateFile());
        }
    }
    public function testRenderWrapsExceptions()
    {
        $loader = new Twig_Loader_Array(array('index' => "\n\n\n{{ foo.bar }}"));
        $twig = new Twig_Environment($loader, array('strict_variables' => true, 'debug' => true, 'cache' => false));
        $template = $twig->loadTemplate('index');
        try {
            $template->render(array('foo' => new Twig_Tests_ErrorTest_Foo()));
            $this->fail();
        } catch (Twig_Error_Runtime $e) {
            $this->assertEquals('An exception has been thrown during the rendering of a template ("Runtime error...") in "index" at line 4.', $e->getMessage());
            $this->assertEquals(4, $e->getTemplateLine());
            $this->assertEquals('index', $e->getTemplateFile());
        }
    }
    public function testTwigExceptionAddsFileAndLineWhenMissingWithInheritance()
    {
        $loader = new Twig_Loader_Array(array(
            'index' => "{% extends 'base' %}
            {% block content %}
                {{ foo.bar }}
            {% endblock %}",
            'base' => '{% block content %}{% endblock %}'
        ));
        $twig = new Twig_Environment($loader, array('strict_variables' => true, 'debug' => true, 'cache' => false));
        $template = $twig->loadTemplate('index');
        try {
            $template->render(array());
            $this->fail();
        } catch (Twig_Error_Runtime $e) {
            $this->assertEquals('Variable "foo" does not exist in "index" at line 3', $e->getMessage());
            $this->assertEquals(3, $e->getTemplateLine());
            $this->assertEquals('index', $e->getTemplateFile());
        }
    }
 }
 class Twig_Tests_ErrorTest_Foo
 {
    public function bar()
    {
        throw new Exception('Runtime error...');
    }
 }
--- a/lib/twig/test/Twig/Tests/ExpressionParserTest.php
+++ b/lib/twig/test/Twig/Tests/ExpressionParserTest.php
@ -1,217 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Tests_ExpressionParserTest extends PHPUnit_Framework_TestCase
 {
    /**
     * @expectedException Twig_Error_Syntax
     * @dataProvider getFailingTestsForAssignment
     */
    public function testCanOnlyAssignToNames($template)
    {
        $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false, 'autoescape' => false));
        $parser = new Twig_Parser($env);
        $parser->parse($env->tokenize($template, 'index'));
    }
    public function getFailingTestsForAssignment()
    {
        return array(
            array('{% set false = "foo" %}'),
            array('{% set true = "foo" %}'),
            array('{% set none = "foo" %}'),
            array('{% set 3 = "foo" %}'),
            array('{% set 1 + 2 = "foo" %}'),
            array('{% set "bar" = "foo" %}'),
            array('{% set %}{% endset %}')
        );
    }
    /**
     * @dataProvider getTestsForArray
     */
    public function testArrayExpression($template, $expected)
    {
        $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false, 'autoescape' => false));
        $stream = $env->tokenize($template, 'index');
        $parser = new Twig_Parser($env);
        $this->assertEquals($expected, $parser->parse($stream)->getNode('body')->getNode(0)->getNode('expr'));
    }
    /**
     * @expectedException Twig_Error_Syntax
     * @dataProvider getFailingTestsForArray
     */
    public function testArraySyntaxError($template)
    {
        $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false, 'autoescape' => false));
        $parser = new Twig_Parser($env);
        $parser->parse($env->tokenize($template, 'index'));
    }
    public function getFailingTestsForArray()
    {
        return array(
            array('{{ [1, "a": "b"] }}'),
            array('{{ {"a": "b", 2} }}'),
        );
    }
    public function getTestsForArray()
    {
        return array(
            // simple array
            array('{{ [1, 2] }}', new Twig_Node_Expression_Array(array(
                  new Twig_Node_Expression_Constant(0, 1),
                  new Twig_Node_Expression_Constant(1, 1),
                  new Twig_Node_Expression_Constant(1, 1),
                  new Twig_Node_Expression_Constant(2, 1),
                ), 1),
            ),
            // array with trailing ,
            array('{{ [1, 2, ] }}', new Twig_Node_Expression_Array(array(
                  new Twig_Node_Expression_Constant(0, 1),
                  new Twig_Node_Expression_Constant(1, 1),
                  new Twig_Node_Expression_Constant(1, 1),
                  new Twig_Node_Expression_Constant(2, 1),
                ), 1),
            ),
            // simple hash
            array('{{ {"a": "b", "b": "c"} }}', new Twig_Node_Expression_Array(array(
                  new Twig_Node_Expression_Constant('a', 1),
                  new Twig_Node_Expression_Constant('b', 1),
                  new Twig_Node_Expression_Constant('b', 1),
                  new Twig_Node_Expression_Constant('c', 1),
                ), 1),
            ),
            // hash with trailing ,
            array('{{ {"a": "b", "b": "c", } }}', new Twig_Node_Expression_Array(array(
                  new Twig_Node_Expression_Constant('a', 1),
                  new Twig_Node_Expression_Constant('b', 1),
                  new Twig_Node_Expression_Constant('b', 1),
                  new Twig_Node_Expression_Constant('c', 1),
                ), 1),
            ),
            // hash in an array
            array('{{ [1, {"a": "b", "b": "c"}] }}', new Twig_Node_Expression_Array(array(
                  new Twig_Node_Expression_Constant(0, 1),
                  new Twig_Node_Expression_Constant(1, 1),
                  new Twig_Node_Expression_Constant(1, 1),
                  new Twig_Node_Expression_Array(array(
                        new Twig_Node_Expression_Constant('a', 1),
                        new Twig_Node_Expression_Constant('b', 1),
                        new Twig_Node_Expression_Constant('b', 1),
                        new Twig_Node_Expression_Constant('c', 1),
                      ), 1),
                ), 1),
            ),
            // array in a hash
            array('{{ {"a": [1, 2], "b": "c"} }}', new Twig_Node_Expression_Array(array(
                  new Twig_Node_Expression_Constant('a', 1),
                  new Twig_Node_Expression_Array(array(
                        new Twig_Node_Expression_Constant(0, 1),
                        new Twig_Node_Expression_Constant(1, 1),
                        new Twig_Node_Expression_Constant(1, 1),
                        new Twig_Node_Expression_Constant(2, 1),
                      ), 1),
                  new Twig_Node_Expression_Constant('b', 1),
                  new Twig_Node_Expression_Constant('c', 1),
                ), 1),
            ),
        );
    }
    /**
     * @expectedException Twig_Error_Syntax
     */
    public function testStringExpressionDoesNotConcatenateTwoConsecutiveStrings()
    {
        $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false, 'autoescape' => false, 'optimizations' => 0));
        $stream = $env->tokenize('{{ "a" "b" }}', 'index');
        $parser = new Twig_Parser($env);
        $parser->parse($stream);
    }
    /**
     * @dataProvider getTestsForString
     */
    public function testStringExpression($template, $expected)
    {
        $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false, 'autoescape' => false, 'optimizations' => 0));
        $stream = $env->tokenize($template, 'index');
        $parser = new Twig_Parser($env);
        $this->assertEquals($expected, $parser->parse($stream)->getNode('body')->getNode(0)->getNode('expr'));
    }
    public function getTestsForString()
    {
        return array(
            array(
                '{{ "foo" }}', new Twig_Node_Expression_Constant('foo', 1),
            ),
            array(
                '{{ "foo #{bar}" }}', new Twig_Node_Expression_Binary_Concat(
                    new Twig_Node_Expression_Constant('foo ', 1),
                    new Twig_Node_Expression_Name('bar', 1),
                    1
                ),
            ),
            array(
                '{{ "foo #{bar} baz" }}', new Twig_Node_Expression_Binary_Concat(
                    new Twig_Node_Expression_Binary_Concat(
                        new Twig_Node_Expression_Constant('foo ', 1),
                        new Twig_Node_Expression_Name('bar', 1),
                        1
                    ),
                    new Twig_Node_Expression_Constant(' baz', 1),
                    1
                )
            ),
            array(
                '{{ "foo #{"foo #{bar} baz"} baz" }}', new Twig_Node_Expression_Binary_Concat(
                    new Twig_Node_Expression_Binary_Concat(
                        new Twig_Node_Expression_Constant('foo ', 1),
                        new Twig_Node_Expression_Binary_Concat(
                            new Twig_Node_Expression_Binary_Concat(
                                new Twig_Node_Expression_Constant('foo ', 1),
                                new Twig_Node_Expression_Name('bar', 1),
                                1
                            ),
                            new Twig_Node_Expression_Constant(' baz', 1),
                            1
                        ),
                        1
                    ),
                    new Twig_Node_Expression_Constant(' baz', 1),
                    1
                ),
            ),
        );
    }
 }
--- a/lib/twig/test/Twig/Tests/Extension/CoreTest.php
+++ b/lib/twig/test/Twig/Tests/Extension/CoreTest.php
@ -1,114 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Tests_Extension_CoreTest extends PHPUnit_Framework_TestCase
 {
    /**
     * @dataProvider getRandomFunctionTestData
     */
    public function testRandomFunction($value, $expectedInArray)
    {
        for ($i = 0; $i < 100; $i++) {
            $this->assertTrue(in_array(twig_random(new Twig_Environment(), $value), $expectedInArray, true)); // assertContains() would not consider the type
        }
    }
    public function getRandomFunctionTestData()
    {
        return array(
            array( // array
                array('apple', 'orange', 'citrus'),
                array('apple', 'orange', 'citrus'),
            ),
            array( // Traversable
                new ArrayObject(array('apple', 'orange', 'citrus')),
                array('apple', 'orange', 'citrus'),
            ),
            array( // unicode string
                'Ä€é',
                array('Ä', '€', 'é'),
            ),
            array( // numeric but string
                '123',
                array('1', '2', '3'),
            ),
            array( // integer
                5,
                range(0, 5, 1),
            ),
            array( // float
                5.9,
                range(0, 5, 1),
            ),
            array( // negative
                -2,
                array(0, -1, -2),
            ),
        );
    }
    public function testRandomFunctionWithoutParameter()
    {
        $max = mt_getrandmax();
        for ($i = 0; $i < 100; $i++) {
            $val = twig_random(new Twig_Environment());
            $this->assertTrue(is_int($val) && $val >= 0 && $val <= $max);
        }
    }
    public function testRandomFunctionReturnsAsIs()
    {
        $this->assertSame('', twig_random(new Twig_Environment(), ''));
        $instance = new stdClass();
        $this->assertSame($instance, twig_random(new Twig_Environment(), $instance));
    }
    /**
     * @expectedException Twig_Error_Runtime
     */
    public function testRandomFunctionOfEmptyArrayThrowsException()
    {
        twig_random(new Twig_Environment(), array());
    }
    public function testRandomFunctionOnNonUTF8String()
    {
        if (!function_exists('iconv') && !function_exists('mb_convert_encoding')) {
            $this->markTestSkipped('needs iconv or mbstring');
        }
        $twig = new Twig_Environment();
        $twig->setCharset('ISO-8859-1');
        $text = twig_convert_encoding('Äé', 'ISO-8859-1', 'UTF-8');
        for ($i = 0; $i < 30; $i++) {
            $rand = twig_random($twig, $text);
            $this->assertTrue(in_array(twig_convert_encoding($rand, 'UTF-8', 'ISO-8859-1'), array('Ä', 'é'), true));
        }
    }
    public function testReverseFilterOnNonUTF8String()
    {
        if (!function_exists('iconv') && !function_exists('mb_convert_encoding')) {
            $this->markTestSkipped('needs iconv or mbstring');
        }
        $twig = new Twig_Environment();
        $twig->setCharset('ISO-8859-1');
        $input = twig_convert_encoding('Äé', 'ISO-8859-1', 'UTF-8');
        $output = twig_convert_encoding(twig_reverse_filter($twig, $input), 'UTF-8', 'ISO-8859-1');
        $this->assertEquals($output, 'éÄ');
    }
 }
--- a/lib/twig/test/Twig/Tests/Extension/SandboxTest.php
+++ b/lib/twig/test/Twig/Tests/Extension/SandboxTest.php
@ -1,209 +0,0 @@
 <?php
 /*
 * This file is part of Twig.
 *
 * (c) Fabien Potencier
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
 class Twig_Tests_Extension_SandboxTest extends PHPUnit_Framework_TestCase
 {
    static protected $params, $templates;
    public function setUp()
    {
        self::$params = array(
            'name' => 'Fabien',
            'obj'  => new FooObject(),
            'arr'  => array('obj' => new FooObject()),
        );
        self::$templates = array(
            '1_basic1' => '{{ obj.foo }}',
            '1_basic2' => '{{ name|upper }}',
            '1_basic3' => '{% if name %}foo{% endif %}',
            '1_basic4' => '{{ obj.bar }}',
            '1_basic5' => '{{ obj }}',
            '1_basic6' => '{{ arr.obj }}',
            '1_basic7' => '{{ cycle(["foo","bar"], 1) }}',
            '1_basic8' => '{{ obj.getfoobar }}{{ obj.getFooBar }}',
            '1_basic'  => '{% if obj.foo %}{{ obj.foo|upper }}{% endif %}',
            '1_layout' => '{% block content %}{% endblock %}',
            '1_child'  => '{% extends "1_layout" %}{% block content %}{{ "a"|json_encode }}{% endblock %}',
        );
    }
    /**
     * @expectedException        Twig_Sandbox_SecurityError
     * @expectedExceptionMessage Filter "json_encode" is not allowed in "1_child".
     */
    public function testSandboxWithInheritance()
    {
        $twig = $this->getEnvironment(true, array(), self::$templates, array('block'));
        $twig->loadTemplate('1_child')->render(array());
    }
    public function testSandboxGloballySet()
    {
        $twig = $this->getEnvironment(false, array(), self::$templates);
        $this->assertEquals('FOO', $twig->loadTemplate('1_basic')->render(self::$params), 'Sandbox does nothing if it is disabled globally');
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('1_basic1')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception if an unallowed method is called');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('1_basic2')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception if an unallowed filter is called');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('1_basic3')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception if an unallowed tag is used in the template');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('1_basic4')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception if an unallowed property is called in the template');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('1_basic5')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception if an unallowed method (__toString()) is called in the template');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('1_basic6')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception if an unallowed method (__toString()) is called in the template');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('1_basic7')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception if an unallowed function is called in the template');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
        $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array('FooObject' => 'foo'));
        FooObject::reset();
        $this->assertEquals('foo', $twig->loadTemplate('1_basic1')->render(self::$params), 'Sandbox allow some methods');
        $this->assertEquals(1, FooObject::$called['foo'], 'Sandbox only calls method once');
        $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array('FooObject' => '__toString'));
        FooObject::reset();
        $this->assertEquals('foo', $twig->loadTemplate('1_basic5')->render(self::$params), 'Sandbox allow some methods');
        $this->assertEquals(1, FooObject::$called['__toString'], 'Sandbox only calls method once');
        $twig = $this->getEnvironment(true, array(), self::$templates, array(), array('upper'));
        $this->assertEquals('FABIEN', $twig->loadTemplate('1_basic2')->render(self::$params), 'Sandbox allow some filters');
        $twig = $this->getEnvironment(true, array(), self::$templates, array('if'));
        $this->assertEquals('foo', $twig->loadTemplate('1_basic3')->render(self::$params), 'Sandbox allow some tags');
        $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array(), array('FooObject' => 'bar'));
        $this->assertEquals('bar', $twig->loadTemplate('1_basic4')->render(self::$params), 'Sandbox allow some properties');
        $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array(), array(), array('cycle'));
        $this->assertEquals('bar', $twig->loadTemplate('1_basic7')->render(self::$params), 'Sandbox allow some functions');
        foreach (array('getfoobar', 'getFoobar', 'getFooBar') as $name) {
            $twig = $this->getEnvironment(true, array(), self::$templates, array(), array(), array('FooObject' => $name));
            FooObject::reset();
            $this->assertEquals('foobarfoobar', $twig->loadTemplate('1_basic8')->render(self::$params), 'Sandbox allow methods in a case-insensitive way');
            $this->assertEquals(2, FooObject::$called['getFooBar'], 'Sandbox only calls method once');
        }
    }
    public function testSandboxLocallySetForAnInclude()
    {
        self::$templates = array(
            '2_basic'    => '{{ obj.foo }}{% include "2_included" %}{{ obj.foo }}',
            '2_included' => '{% if obj.foo %}{{ obj.foo|upper }}{% endif %}',
        );
        $twig = $this->getEnvironment(false, array(), self::$templates);
        $this->assertEquals('fooFOOfoo', $twig->loadTemplate('2_basic')->render(self::$params), 'Sandbox does nothing if disabled globally and sandboxed not used for the include');
        self::$templates = array(
            '3_basic'    => '{{ obj.foo }}{% sandbox %}{% include "3_included" %}{% endsandbox %}{{ obj.foo }}',
            '3_included' => '{% if obj.foo %}{{ obj.foo|upper }}{% endif %}',
        );
        $twig = $this->getEnvironment(true, array(), self::$templates);
        try {
            $twig->loadTemplate('3_basic')->render(self::$params);
            $this->fail('Sandbox throws a SecurityError exception when the included file is sandboxed');
        } catch (Twig_Sandbox_SecurityError $e) {
        }
    }
    public function testMacrosInASandbox()
    {
        $twig = $this->getEnvironment(true, array('autoescape' => true), array('index' => <<<EOF
 {% macro test(text) %}<p>{{ text }}</p>{% endmacro %}
 {{ _self.test('username') }}
 EOF
        ), array('macro'), array('escape'));
        $this->assertEquals('<p>username</p>', $twig->loadTemplate('index')->render(array()));
    }
    protected function getEnvironment($sandboxed, $options, $templates, $tags = array(), $filters = array(), $methods = array(), $properties = array(), $functions = array())
    {
        $loader = new Twig_Loader_Array($templates);
        $twig = new Twig_Environment($loader, array_merge(array('debug' => true, 'cache' => false, 'autoescape' => false), $options));
        $policy = new Twig_Sandbox_SecurityPolicy($tags, $filters, $methods, $properties, $functions);
        $twig->addExtension(new Twig_Extension_Sandbox($policy, $sandboxed));
        return $twig;
    }
 }
 class FooObject
 {
    static public $called = array('__toString' => 0, 'foo' => 0, 'getFooBar' => 0);
    public $bar = 'bar';
    static public function reset()
    {
        self::$called = array('__toString' => 0, 'foo' => 0, 'getFooBar' => 0);
    }
    public function __toString()
    {
        ++self::$called['__toString'];
        return 'foo';
    }
    public function foo()
    {
        ++self::$called['foo'];
        return 'foo';
    }
    public function getFooBar()
    {
        ++self::$called['getFooBar'];
        return 'foobar';
    }
 }
--- a/lib/twig/test/Twig/Tests/FileCachingTest.php
+++ b/lib/twig/test/Twig/Tests/FileCachingTest.php
@ -1,70 +0,0 @@
 <?php
 class Twig_Tests_FileCachingTest extends PHPUnit_Framework_TestCase
 {
    protected $fileName;
    protected $env;
    protected $tmpDir;
    public function setUp()
    {
        $this->tmpDir = sys_get_temp_dir().'/TwigTests';
        if (!file_exists($this->tmpDir)) {
            @mkdir($this->tmpDir, 0777, true);;
        }
        if (!is_writable($this->tmpDir)) {
            $this->markTestSkipped(sprintf('Unable to run the tests as "%s" is not writable.', $this->tmpDir));
        }
        $this->env = new Twig_Environment(new Twig_Loader_String(), array('cache' => $this->tmpDir));
    }
    public function tearDown()
    {
        if ($this->fileName) {
            unlink($this->fileName);
        }
        $this->removeDir($this->tmpDir);
    }
    public function testWritingCacheFiles()
    {
        $name = 'This is just text.';
        $template = $this->env->loadTemplate($name);
        $cacheFileName = $this->env->getCacheFilename($name);
        $this->assertTrue(file_exists($cacheFileName), 'Cache file does not exist.');
        $this->fileName = $cacheFileName;
    }
    public function testClearingCacheFiles()
    {
        $name = 'I will be deleted.';
        $template = $this->env->loadTemplate($name);
        $cacheFileName = $this->env->getCacheFilename($name);
        $this->assertTrue(file_exists($cacheFileName), 'Cache file does not exist.');
        $this->env->clearCacheFiles();
        $this->assertFalse(file_exists($cacheFileName), 'Cache file was not cleared.');
    }
    private function removeDir($target)
    {
        $fp = opendir($target);
        while (false !== $file = readdir($fp)) {
            if (in_array($file, array('.', '..'))) {
                continue;
            }
            if (is_dir($target.'/'.$file)) {
                self::removeDir($target.'/'.$file);
            } else {
                unlink($target.'/'.$file);
            }
        }
        closedir($fp);
        rmdir($target);
    }
 }
--- a/lib/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test
+++ b/lib/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test
@ -1,20 +0,0 @@
 --TEST--
 Exception for an unclosed tag
 --TEMPLATE--
 {% block foo %}
     {% if foo %}
         {% for i in fo %}
         {% endfor %}
 {% endblock %}
 --EXCEPTION--
 Twig_Error_Syntax: Unexpected tag name "endblock" (expecting closing tag for the "if" tag defined near line 4) in "index.twig" at line 16
--- a/lib/twig/test/Twig/Tests/Fixtures/expressions/array.test
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/array.test
@ -1,61 +0,0 @@
 --TEST--
 Twig supports array notation
 --TEMPLATE--
 {# empty array #}
 {{ []|join(',') }}
 {{ [1, 2]|join(',') }}
 {{ ['foo', "bar"]|join(',') }}
 {{ {0: 1, 'foo': 'bar'}|join(',') }}
 {{ {0: 1, 'foo': 'bar'}|keys|join(',') }}
 {{ {0: 1, foo: 'bar'}|join(',') }}
 {{ {0: 1, foo: 'bar'}|keys|join(',') }}
 {# nested arrays #}
 {% set a = [1, 2, [1, 2], {'foo': {'foo': 'bar'}}] %}
 {{ a[2]|join(',') }}
 {{ a[3]["foo"]|join(',') }}
 {# works even if [] is used inside the array #}
 {{ [foo[bar]]|join(',') }}
 {# elements can be any expression #}
 {{ ['foo'|upper, bar|upper, bar == foo]|join(',') }}
 {# arrays can have a trailing , like in PHP #}
 {{
  [
    1,
    2,
  ]|join(',')
 }}
 {# keys can be any expression #}
 {% set a = 1 %}
 {% set b = "foo" %}
 {% set ary = { (a): 'a', (b): 'b', 'c': 'c', (a ~ b): 'd' } %}
 {{ ary|keys|join(',') }}
 {{ ary|join(',') }}
 --DATA--
 return array('bar' => 'bar', 'foo' => array('bar' => 'bar'))
 --EXPECT--
 1,2
 foo,bar
 1,bar
 0,foo
 1,bar
 0,foo
 1,2
 bar
 bar
 FOO,BAR,
 1,2
 1,foo,c,1foo
 a,b,c,d
--- a/Show More
+++ b/Show More