` blocks.
+ #
+ $text = preg_replace_callback('{
+ (?:\n\n|\A\n?)
+ ( # $1 = the code block -- one or more lines, starting with a space/tab
+ (?>
+ [ ]{'.$this->tab_width.'} # Lines must start with a tab or a tab-width of spaces
+ .*\n+
+ )+
+ )
+ ((?=^[ ]{0,'.$this->tab_width.'}\S)|\Z) # Lookahead for non-space at line-start, or end of doc
+ }xm',
+ array(&$this, '_doCodeBlocks_callback'), $text);
+
+ return $text;
+ }
+ function _doCodeBlocks_callback($matches) {
+ $codeblock = $matches[1];
+
+ $codeblock = $this->outdent($codeblock);
+ $codeblock = htmlspecialchars($codeblock, ENT_NOQUOTES);
+
+ # trim leading newlines and trailing newlines
+ $codeblock = preg_replace('/\A\n+|\n+\z/', '', $codeblock);
+
+ $codeblock = "$codeblock\n
";
+ return "\n\n".$this->hashBlock($codeblock)."\n\n";
+ }
+
+
+ function makeCodeSpan($code) {
+ #
+ # Create a code span markup for $code. Called from handleSpanToken.
+ #
+ $code = htmlspecialchars(trim($code), ENT_NOQUOTES);
+ return $this->hashPart("$code
");
+ }
+
+
+ var $em_relist = array(
+ '' => '(?:(? '(?<=\S|^)(? '(?<=\S|^)(? '(?:(? '(?<=\S|^)(? '(?<=\S|^)(? '(?:(? '(?<=\S|^)(? '(?<=\S|^)(?em_relist as $em => $em_re) {
+ foreach ($this->strong_relist as $strong => $strong_re) {
+ # Construct list of allowed token expressions.
+ $token_relist = array();
+ if (isset($this->em_strong_relist["$em$strong"])) {
+ $token_relist[] = $this->em_strong_relist["$em$strong"];
+ }
+ $token_relist[] = $em_re;
+ $token_relist[] = $strong_re;
+
+ # Construct master expression from list.
+ $token_re = '{('. implode('|', $token_relist) .')}';
+ $this->em_strong_prepared_relist["$em$strong"] = $token_re;
+ }
+ }
+ }
+
+ function doItalicsAndBold($text) {
+ $token_stack = array('');
+ $text_stack = array('');
+ $em = '';
+ $strong = '';
+ $tree_char_em = false;
+
+ while (1) {
+ #
+ # Get prepared regular expression for seraching emphasis tokens
+ # in current context.
+ #
+ $token_re = $this->em_strong_prepared_relist["$em$strong"];
+
+ #
+ # Each loop iteration search for the next emphasis token.
+ # Each token is then passed to handleSpanToken.
+ #
+ $parts = preg_split($token_re, $text, 2, PREG_SPLIT_DELIM_CAPTURE);
+ $text_stack[0] .= $parts[0];
+ $token =& $parts[1];
+ $text =& $parts[2];
+
+ if (empty($token)) {
+ # Reached end of text span: empty stack without emitting.
+ # any more emphasis.
+ while ($token_stack[0]) {
+ $text_stack[1] .= array_shift($token_stack);
+ $text_stack[0] .= array_shift($text_stack);
+ }
+ break;
+ }
+
+ $token_len = strlen($token);
+ if ($tree_char_em) {
+ # Reached closing marker while inside a three-char emphasis.
+ if ($token_len == 3) {
+ # Three-char closing marker, close em and strong.
+ array_shift($token_stack);
+ $span = array_shift($text_stack);
+ $span = $this->runSpanGamut($span);
+ $span = "$span ";
+ $text_stack[0] .= $this->hashPart($span);
+ $em = '';
+ $strong = '';
+ } else {
+ # Other closing marker: close one em or strong and
+ # change current token state to match the other
+ $token_stack[0] = str_repeat($token{0}, 3-$token_len);
+ $tag = $token_len == 2 ? "strong" : "em";
+ $span = $text_stack[0];
+ $span = $this->runSpanGamut($span);
+ $span = "<$tag>$span$tag>";
+ $text_stack[0] = $this->hashPart($span);
+ $$tag = ''; # $$tag stands for $em or $strong
+ }
+ $tree_char_em = false;
+ } else if ($token_len == 3) {
+ if ($em) {
+ # Reached closing marker for both em and strong.
+ # Closing strong marker:
+ for ($i = 0; $i < 2; ++$i) {
+ $shifted_token = array_shift($token_stack);
+ $tag = strlen($shifted_token) == 2 ? "strong" : "em";
+ $span = array_shift($text_stack);
+ $span = $this->runSpanGamut($span);
+ $span = "<$tag>$span$tag>";
+ $text_stack[0] .= $this->hashPart($span);
+ $$tag = ''; # $$tag stands for $em or $strong
+ }
+ } else {
+ # Reached opening three-char emphasis marker. Push on token
+ # stack; will be handled by the special condition above.
+ $em = $token{0};
+ $strong = "$em$em";
+ array_unshift($token_stack, $token);
+ array_unshift($text_stack, '');
+ $tree_char_em = true;
+ }
+ } else if ($token_len == 2) {
+ if ($strong) {
+ # Unwind any dangling emphasis marker:
+ if (strlen($token_stack[0]) == 1) {
+ $text_stack[1] .= array_shift($token_stack);
+ $text_stack[0] .= array_shift($text_stack);
+ }
+ # Closing strong marker:
+ array_shift($token_stack);
+ $span = array_shift($text_stack);
+ $span = $this->runSpanGamut($span);
+ $span = "$span ";
+ $text_stack[0] .= $this->hashPart($span);
+ $strong = '';
+ } else {
+ array_unshift($token_stack, $token);
+ array_unshift($text_stack, '');
+ $strong = $token;
+ }
+ } else {
+ # Here $token_len == 1
+ if ($em) {
+ if (strlen($token_stack[0]) == 1) {
+ # Closing emphasis marker:
+ array_shift($token_stack);
+ $span = array_shift($text_stack);
+ $span = $this->runSpanGamut($span);
+ $span = "$span ";
+ $text_stack[0] .= $this->hashPart($span);
+ $em = '';
+ } else {
+ $text_stack[0] .= $token;
+ }
+ } else {
+ array_unshift($token_stack, $token);
+ array_unshift($text_stack, '');
+ $em = $token;
+ }
+ }
+ }
+ return $text_stack[0];
+ }
+
+
+ function doBlockQuotes($text) {
+ $text = preg_replace_callback('/
+ ( # Wrap whole match in $1
+ (?>
+ ^[ ]*>[ ]? # ">" at the start of a line
+ .+\n # rest of the first line
+ (.+\n)* # subsequent consecutive lines
+ \n* # blanks
+ )+
+ )
+ /xm',
+ array(&$this, '_doBlockQuotes_callback'), $text);
+
+ return $text;
+ }
+ function _doBlockQuotes_callback($matches) {
+ $bq = $matches[1];
+ # trim one level of quoting - trim whitespace-only lines
+ $bq = preg_replace('/^[ ]*>[ ]?|^[ ]+$/m', '', $bq);
+ $bq = $this->runBlockGamut($bq); # recurse
+
+ $bq = preg_replace('/^/m', " ", $bq);
+ # These leading spaces cause problem with content,
+ # so we need to fix that:
+ $bq = preg_replace_callback('{(\s*.+? )}sx',
+ array(&$this, '_doBlockQuotes_callback2'), $bq);
+
+ return "\n". $this->hashBlock("\n$bq\n ")."\n\n";
+ }
+ function _doBlockQuotes_callback2($matches) {
+ $pre = $matches[1];
+ $pre = preg_replace('/^ /m', '', $pre);
+ return $pre;
+ }
+
+
+ function formParagraphs($text) {
+ #
+ # Params:
+ # $text - string to process with html tags
+ #
+ # Strip leading and trailing lines:
+ $text = preg_replace('/\A\n+|\n+\z/', '', $text);
+
+ $grafs = preg_split('/\n{2,}/', $text, -1, PREG_SPLIT_NO_EMPTY);
+
+ #
+ # Wrap
tags and unhashify HTML blocks
+ #
+ foreach ($grafs as $key => $value) {
+ if (!preg_match('/^B\x1A[0-9]+B$/', $value)) {
+ # Is a paragraph.
+ $value = $this->runSpanGamut($value);
+ $value = preg_replace('/^([ ]*)/', "
", $value);
+ $value .= "
";
+ $grafs[$key] = $this->unhash($value);
+ }
+ else {
+ # Is a block.
+ # Modify elements of @grafs in-place...
+ $graf = $value;
+ $block = $this->html_hashes[$graf];
+ $graf = $block;
+// if (preg_match('{
+// \A
+// ( # $1 = tag
+//
]*
+// \b
+// markdown\s*=\s* ([\'"]) # $2 = attr quote char
+// 1
+// \2
+// [^>]*
+// >
+// )
+// ( # $3 = contents
+// .*
+// )
+// (
) # $4 = closing tag
+// \z
+// }xs', $block, $matches))
+// {
+// list(, $div_open, , $div_content, $div_close) = $matches;
+//
+// # We can't call Markdown(), because that resets the hash;
+// # that initialization code should be pulled into its own sub, though.
+// $div_content = $this->hashHTMLBlocks($div_content);
+//
+// # Run document gamut methods on the content.
+// foreach ($this->document_gamut as $method => $priority) {
+// $div_content = $this->$method($div_content);
+// }
+//
+// $div_open = preg_replace(
+// '{\smarkdown\s*=\s*([\'"]).+?\1}', '', $div_open);
+//
+// $graf = $div_open . "\n" . $div_content . "\n" . $div_close;
+// }
+ $grafs[$key] = $graf;
+ }
+ }
+
+ return implode("\n\n", $grafs);
+ }
+
+
+ function encodeAttribute($text) {
+ #
+ # Encode text for a double-quoted HTML attribute. This function
+ # is *not* suitable for attributes enclosed in single quotes.
+ #
+ $text = $this->encodeAmpsAndAngles($text);
+ $text = str_replace('"', '"', $text);
+ return $text;
+ }
+
+
+ function encodeAmpsAndAngles($text) {
+ #
+ # Smart processing for ampersands and angle brackets that need to
+ # be encoded. Valid character entities are left alone unless the
+ # no-entities mode is set.
+ #
+ if ($this->no_entities) {
+ $text = str_replace('&', '&', $text);
+ } else {
+ # Ampersand-encoding based entirely on Nat Irons's Amputator
+ # MT plugin:
+ $text = preg_replace('/&(?!#?[xX]?(?:[0-9a-fA-F]+|\w+);)/',
+ '&', $text);;
+ }
+ # Encode remaining <'s
+ $text = str_replace('<', '<', $text);
+
+ return $text;
+ }
+
+
+ function doAutoLinks($text) {
+ $text = preg_replace_callback('{<((https?|ftp|dict):[^\'">\s]+)>}i',
+ array(&$this, '_doAutoLinks_url_callback'), $text);
+
+ # Email addresses:
+ $text = preg_replace_callback('{
+ <
+ (?:mailto:)?
+ (
+ (?:
+ [-!#$%&\'*+/=?^_`.{|}~\w\x80-\xFF]+
+ |
+ ".*?"
+ )
+ \@
+ (?:
+ [-a-z0-9\x80-\xFF]+(\.[-a-z0-9\x80-\xFF]+)*\.[a-z]+
+ |
+ \[[\d.a-fA-F:]+\] # IPv4 & IPv6
+ )
+ )
+ >
+ }xi',
+ array(&$this, '_doAutoLinks_email_callback'), $text);
+
+ return $text;
+ }
+ function _doAutoLinks_url_callback($matches) {
+ $url = $this->encodeAttribute($matches[1]);
+ $link = "$url ";
+ return $this->hashPart($link);
+ }
+ function _doAutoLinks_email_callback($matches) {
+ $address = $matches[1];
+ $link = $this->encodeEmailAddress($address);
+ return $this->hashPart($link);
+ }
+
+
+ function encodeEmailAddress($addr) {
+ #
+ # Input: an email address, e.g. "foo@example.com"
+ #
+ # Output: the email address as a mailto link, with each character
+ # of the address encoded as either a decimal or hex entity, in
+ # the hopes of foiling most address harvesting spam bots. E.g.:
+ #
+ # foo@exampl
+ # e.com
+ #
+ # Based by a filter by Matthew Wickline, posted to BBEdit-Talk.
+ # With some optimizations by Milian Wolff.
+ #
+ $addr = "mailto:" . $addr;
+ $chars = preg_split('/(? $char) {
+ $ord = ord($char);
+ # Ignore non-ascii chars.
+ if ($ord < 128) {
+ $r = ($seed * (1 + $key)) % 100; # Pseudo-random function.
+ # roughly 10% raw, 45% hex, 45% dec
+ # '@' *must* be encoded. I insist.
+ if ($r > 90 && $char != '@') /* do nothing */;
+ else if ($r < 45) $chars[$key] = ''.dechex($ord).';';
+ else $chars[$key] = ''.$ord.';';
+ }
+ }
+
+ $addr = implode('', $chars);
+ $text = implode('', array_slice($chars, 7)); # text without `mailto:`
+ $addr = "$text ";
+
+ return $addr;
+ }
+
+
+ function parseSpan($str) {
+ #
+ # Take the string $str and parse it into tokens, hashing embeded HTML,
+ # escaped characters and handling code spans.
+ #
+ $output = '';
+
+ $span_re = '{
+ (
+ \\\\'.$this->escape_chars_re.'
+ |
+ (?no_markup ? '' : '
+ |
+ # comment
+ |
+ <\?.*?\?> | <%.*?%> # processing instruction
+ |
+ <[/!$]?[-a-zA-Z0-9:_]+ # regular tags
+ (?>
+ \s
+ (?>[^"\'>]+|"[^"]*"|\'[^\']*\')*
+ )?
+ >
+ ').'
+ )
+ }xs';
+
+ while (1) {
+ #
+ # Each loop iteration seach for either the next tag, the next
+ # openning code span marker, or the next escaped character.
+ # Each token is then passed to handleSpanToken.
+ #
+ $parts = preg_split($span_re, $str, 2, PREG_SPLIT_DELIM_CAPTURE);
+
+ # Create token from text preceding tag.
+ if ($parts[0] != "") {
+ $output .= $parts[0];
+ }
+
+ # Check if we reach the end.
+ if (isset($parts[1])) {
+ $output .= $this->handleSpanToken($parts[1], $parts[2]);
+ $str = $parts[2];
+ }
+ else {
+ break;
+ }
+ }
+
+ return $output;
+ }
+
+
+ function handleSpanToken($token, &$str) {
+ #
+ # Handle $token provided by parseSpan by determining its nature and
+ # returning the corresponding value that should replace it.
+ #
+ switch ($token{0}) {
+ case "\\":
+ return $this->hashPart("". ord($token{1}). ";");
+ case "`":
+ # Search for end marker in remaining text.
+ if (preg_match('/^(.*?[^`])'.preg_quote($token).'(?!`)(.*)$/sm',
+ $str, $matches))
+ {
+ $str = $matches[2];
+ $codespan = $this->makeCodeSpan($matches[1]);
+ return $this->hashPart($codespan);
+ }
+ return $token; // return as text since no ending marker found.
+ default:
+ return $this->hashPart($token);
+ }
+ }
+
+
+ function outdent($text) {
+ #
+ # Remove one level of line-leading tabs or spaces
+ #
+ return preg_replace('/^(\t|[ ]{1,'.$this->tab_width.'})/m', '', $text);
+ }
+
+
+ # String length function for detab. `_initDetab` will create a function to
+ # hanlde UTF-8 if the default function does not exist.
+ var $utf8_strlen = 'mb_strlen';
+
+ function detab($text) {
+ #
+ # Replace tabs with the appropriate amount of space.
+ #
+ # For each line we separate the line in blocks delemited by
+ # tab characters. Then we reconstruct every line by adding the
+ # appropriate number of space between each blocks.
+
+ $text = preg_replace_callback('/^.*\t.*$/m',
+ array(&$this, '_detab_callback'), $text);
+
+ return $text;
+ }
+ function _detab_callback($matches) {
+ $line = $matches[0];
+ $strlen = $this->utf8_strlen; # strlen function for UTF-8.
+
+ # Split in blocks.
+ $blocks = explode("\t", $line);
+ # Add each blocks to the line.
+ $line = $blocks[0];
+ unset($blocks[0]); # Do not add first block twice.
+ foreach ($blocks as $block) {
+ # Calculate amount of space, insert spaces, insert block.
+ $amount = $this->tab_width -
+ $strlen($line, 'UTF-8') % $this->tab_width;
+ $line .= str_repeat(" ", $amount) . $block;
+ }
+ return $line;
+ }
+ function _initDetab() {
+ #
+ # Check for the availability of the function in the `utf8_strlen` property
+ # (initially `mb_strlen`). If the function is not available, create a
+ # function that will loosely count the number of UTF-8 characters with a
+ # regular expression.
+ #
+ if (function_exists($this->utf8_strlen)) return;
+ $this->utf8_strlen = create_function('$text', 'return preg_match_all(
+ "/[\\\\x00-\\\\xBF]|[\\\\xC0-\\\\xFF][\\\\x80-\\\\xBF]*/",
+ $text, $m);');
+ }
+
+
+ function unhash($text) {
+ #
+ # Swap back in all the tags hashed by _HashHTMLBlocks.
+ #
+ return preg_replace_callback('/(.)\x1A[0-9]+\1/',
+ array(&$this, '_unhash_callback'), $text);
+ }
+ function _unhash_callback($matches) {
+ return $this->html_hashes[$matches[0]];
+ }
+
+}
+
+/*
+
+PHP Markdown
+============
+
+Description
+-----------
+
+This is a PHP translation of the original Markdown formatter written in
+Perl by John Gruber.
+
+Markdown is a text-to-HTML filter; it translates an easy-to-read /
+easy-to-write structured text format into HTML. Markdown's text format
+is most similar to that of plain text email, and supports features such
+as headers, *emphasis*, code blocks, blockquotes, and links.
+
+Markdown's syntax is designed not as a generic markup language, but
+specifically to serve as a front-end to (X)HTML. You can use span-level
+HTML tags anywhere in a Markdown document, and you can use block level
+HTML tags (like and
as well).
+
+For more information about Markdown's syntax, see:
+
+
+
+
+Bugs
+----
+
+To file bug reports please send email to:
+
+
+
+Please include with your report: (1) the example input; (2) the output you
+expected; (3) the output Markdown actually produced.
+
+
+Version History
+---------------
+
+See the readme file for detailed release notes for this version.
+
+
+Copyright and License
+---------------------
+
+PHP Markdown
+Copyright (c) 2004-2009 Michel Fortin
+
+All rights reserved.
+
+Based on Markdown
+Copyright (c) 2003-2006 John Gruber
+
+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.
+
+* Neither the name "Markdown" nor the names of its contributors may
+ be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+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.
+
+*/
+?>
\ No newline at end of file
diff --git a/lib/pico.php b/lib/pico.php
new file mode 100644
index 0000000..ee7c919
--- /dev/null
+++ b/lib/pico.php
@@ -0,0 +1,114 @@
+read_file_meta($content);
+ $content = preg_replace('#/\*.+?\*/#s', '', $content); // Remove comments and meta
+ $content = $this->parse_content($content);
+
+ // Load the settings
+ $settings = $this->get_config();
+ $env = array('autoescape' => false);
+ if($settings['enable_cache']) $env['cache'] = CACHE_DIR;
+
+ // Load the theme
+ Twig_Autoloader::register();
+ $loader = new Twig_Loader_Filesystem(THEMES_DIR . $settings['theme']);
+ $twig = new Twig_Environment($loader, $env);
+ echo $twig->render('index.html', array(
+ 'config' => $settings,
+ 'base_dir' => rtrim(ROOT_DIR, '/'),
+ 'base_url' => $settings['base_url'],
+ 'theme_dir' => THEMES_DIR . $settings['theme'],
+ 'theme_url' => $settings['base_url'] .'/'. basename(THEMES_DIR) .'/'. $settings['theme'],
+ 'site_title' => $settings['site_title'],
+ 'meta' => $meta,
+ 'content' => $content
+ ));
+ }
+
+ function parse_content($content)
+ {
+ $content = str_replace('%base_url%', $this->base_url(), $content);
+ $content = Markdown($content);
+
+ return $content;
+ }
+
+ function read_file_meta($content)
+ {
+ $headers = array(
+ 'title' => 'Title',
+ 'description' => 'Description',
+ 'robots' => 'Robots'
+ );
+
+ foreach ($headers as $field => $regex){
+ if (preg_match('/^[ \t\/*#@]*' . preg_quote($regex, '/') . ':(.*)$/mi', $content, $match) && $match[1]){
+ $headers[ $field ] = trim(preg_replace("/\s*(?:\*\/|\?>).*/", '', $match[1]));
+ } else {
+ $headers[ $field ] = '';
+ }
+ }
+
+ return $headers;
+ }
+
+ function get_config()
+ {
+ global $config;
+
+ $defaults = array(
+ 'site_title' => 'Pico',
+ 'base_url' => $this->base_url(),
+ 'theme' => 'default',
+ 'enable_cache' => false
+ );
+
+ foreach($defaults as $key=>$val){
+ if(isset($config[$key]) && $config[$key]) $defaults[$key] = $config[$key];
+ }
+
+ return $defaults;
+ }
+
+ function base_url()
+ {
+ global $config;
+ if(isset($config['base_url']) && $config['base_url']) return $config['base_url'];
+
+ $url = '';
+ $request_url = (isset($_SERVER['REQUEST_URI'])) ? $_SERVER['REQUEST_URI'] : '';
+ $script_url = (isset($_SERVER['PHP_SELF'])) ? $_SERVER['PHP_SELF'] : '';
+ if($request_url != $script_url) $url = trim(preg_replace('/'. str_replace('/', '\/', str_replace('index.php', '', $script_url)) .'/', '', $request_url, 1), '/');
+
+ $protocol = $_SERVER['HTTPS'] ? "https" : "http";
+ return rtrim(str_replace($url, '', $protocol . "://" . $_SERVER['HTTP_HOST'] . $_SERVER['REQUEST_URI']), '/');
+ }
+
+}
+
+?>
\ No newline at end of file
diff --git a/lib/twig/AUTHORS b/lib/twig/AUTHORS
new file mode 100755
index 0000000..eb5db05
--- /dev/null
+++ b/lib/twig/AUTHORS
@@ -0,0 +1,9 @@
+Twig is written and maintained by the Twig Team:
+
+Lead Developer:
+
+- Fabien Potencier
+
+Project Founder:
+
+- Armin Ronacher
diff --git a/lib/twig/CHANGELOG b/lib/twig/CHANGELOG
new file mode 100755
index 0000000..7521789
--- /dev/null
+++ b/lib/twig/CHANGELOG
@@ -0,0 +1,474 @@
+* 1.6.4 (2012-04-02)
+
+ * fixed PHP notice in Twig_Error::guessTemplateLine() introduced in 1.6.3
+ * fixed performance when compiling large files
+ * optimized parent template creation when the template does not use dynamic inheritance
+
+* 1.6.3 (2012-03-22)
+
+ * fixed usage of Z_ADDREF_P for PHP 5.2 in the C extension
+ * fixed compilation of numeric values used in templates when using a locale where the decimal separator is not a dot
+ * made the strategy used to guess the real template file name and line number in exception messages much faster and more accurate
+
+* 1.6.2 (2012-03-18)
+
+ * fixed sandbox mode when used with inheritance
+ * added preserveKeys support for the slice filter
+ * fixed the date filter when a DateTime instance is passed with a specific timezone
+ * added a trim filter
+
+* 1.6.1 (2012-02-29)
+
+ * fixed Twig C extension
+ * removed the creation of Twig_Markup instances when not needed
+ * added a way to set the default global timezone for dates
+ * fixed the slice filter on strings when the length is not specified
+ * fixed the creation of the cache directory in case of a race condition
+
+* 1.6.0 (2012-02-04)
+
+ * fixed raw blocks when used with the whitespace trim option
+ * made a speed optimization to macro calls when imported via the "from" tag
+ * fixed globals, parsers, visitors, filters, tests, and functions management in Twig_Environment when a new one or new extension is added
+ * fixed the attribute function when passing arguments
+ * added slice notation support for the [] operator (syntactic sugar for the slice operator)
+ * added a slice filter
+ * added string support for the reverse filter
+ * fixed the empty test and the length filter for Twig_Markup instances
+ * added a date function to ease date comparison
+ * fixed unary operators precedence
+ * added recursive parsing support in the parser
+ * added string and integer handling for the random function
+
+* 1.5.1 (2012-01-05)
+
+ * fixed a regression when parsing strings
+
+* 1.5.0 (2012-01-04)
+
+ * added Traversable objects support for the join filter
+
+* 1.5.0-RC2 (2011-12-30)
+
+ * added a way to set the default global date interval format
+ * fixed the date filter for DateInterval instances (setTimezone() does not exist for them)
+ * refactored Twig_Template::display() to ease its extension
+ * added a number_format filter
+
+* 1.5.0-RC1 (2011-12-26)
+
+ * removed the need to quote hash keys
+ * allowed hash keys to be any expression
+ * added a do tag
+ * added a flush tag
+ * added support for dynamically named filters and functions
+ * added a dump function to help debugging templates
+ * added a nl2br filter
+ * added a random function
+ * added a way to change the default format for the date filter
+ * fixed the lexer when an operator ending with a letter ends a line
+ * added string interpolation support
+ * enhanced exceptions for unknown filters, functions, tests, and tags
+
+* 1.4.0 (2011-12-07)
+
+ * fixed lexer when using big numbers (> PHP_INT_MAX)
+ * added missing preserveKeys argument to the reverse filter
+ * fixed macros containing filter tag calls
+
+* 1.4.0-RC2 (2011-11-27)
+
+ * removed usage of Reflection in Twig_Template::getAttribute()
+ * added a C extension that can optionally replace Twig_Template::getAttribute()
+ * added negative timestamp support to the date filter
+
+* 1.4.0-RC1 (2011-11-20)
+
+ * optimized variable access when using PHP 5.4
+ * changed the precedence of the .. operator to be more consistent with languages that implements such a feature like Ruby
+ * added an Exception to Twig_Loader_Array::isFresh() method when the template does not exist to be consistent with other loaders
+ * added Twig_Function_Node to allow more complex functions to have their own Node class
+ * added Twig_Filter_Node to allow more complex filters to have their own Node class
+ * added Twig_Test_Node to allow more complex tests to have their own Node class
+ * added a better error message when a template is empty but contain a BOM
+ * fixed "in" operator for empty strings
+ * fixed the "defined" test and the "default" filter (now works with more than one call (foo.bar.foo) and for both values of the strict_variables option)
+ * changed the way extensions are loaded (addFilter/addFunction/addGlobal/addTest/addNodeVisitor/addTokenParser/addExtension can now be called in any order)
+ * added Twig_Environment::display()
+ * made the escape filter smarter when the encoding is not supported by PHP
+ * added a convert_encoding filter
+ * moved all node manipulations outside the compile() Node method
+ * made several speed optimizations
+
+* 1.3.0 (2011-10-08)
+
+no changes
+
+* 1.3.0-RC1 (2011-10-04)
+
+ * added an optimization for the parent() function
+ * added cache reloading when auto_reload is true and an extension has been modified
+ * added the possibility to force the escaping of a string already marked as safe (instance of Twig_Markup)
+ * allowed empty templates to be used as traits
+ * added traits support for the "parent" function
+
+* 1.2.0 (2011-09-13)
+
+no changes
+
+* 1.2.0-RC1 (2011-09-10)
+
+ * enhanced the exception when a tag remains unclosed
+ * added support for empty Countable objects for the "empty" test
+ * fixed algorithm that determines if a template using inheritance is valid (no output between block definitions)
+ * added better support for encoding problems when escaping a string (available as of PHP 5.4)
+ * added a way to ignore a missing template when using the "include" tag ({% include "foo" ignore missing %})
+ * added support for an array of templates to the "include" and "extends" tags ({% include ['foo', 'bar'] %})
+ * added support for bitwise operators in expressions
+ * added the "attribute" function to allow getting dynamic attributes on variables
+ * added Twig_Loader_Chain
+ * added Twig_Loader_Array::setTemplate()
+ * added an optimization for the set tag when used to capture a large chunk of static text
+ * changed name regex to match PHP one "[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*" (works for blocks, tags, functions, filters, and macros)
+ * removed the possibility to use the "extends" tag from a block
+ * added "if" modifier support to "for" loops
+
+* 1.1.2 (2011-07-30)
+
+ * fixed json_encode filter on PHP 5.2
+ * fixed regression introduced in 1.1.1 ({{ block(foo|lower) }})
+ * fixed inheritance when using conditional parents
+ * fixed compilation of templates when the body of a child template is not empty
+ * fixed output when a macro throws an exception
+ * fixed a parsing problem when a large chunk of text is enclosed in a comment tag
+ * added PHPDoc for all Token parsers and Core extension functions
+
+* 1.1.1 (2011-07-17)
+
+ * added a performance optimization in the Optimizer (also helps to lower the number of nested level calls)
+ * made some performance improvement for some edge cases
+
+* 1.1.0 (2011-06-28)
+
+ * fixed json_encode filter
+
+* 1.1.0-RC3 (2011-06-24)
+
+ * fixed method case-sensitivity when using the sandbox mode
+ * added timezone support for the date filter
+ * fixed possible security problems with NUL bytes
+
+* 1.1.0-RC2 (2011-06-16)
+
+ * added an exception when the template passed to "use" is not a string
+ * made 'a.b is defined' not throw an exception if a is not defined (in strict mode)
+ * added {% line \d+ %} directive
+
+* 1.1.0-RC1 (2011-05-28)
+
+Flush your cache after upgrading.
+
+ * fixed date filter when using a timestamp
+ * fixed the defined test for some cases
+ * fixed a parsing problem when a large chunk of text is enclosed in a raw tag
+ * added support for horizontal reuse of template blocks (see docs for more information)
+ * added whitespace control modifier to all tags (see docs for more information)
+ * added null as an alias for none (the null test is also an alias for the none test now)
+ * made TRUE, FALSE, NONE equivalent to their lowercase counterparts
+ * wrapped all compilation and runtime exceptions with Twig_Error_Runtime and added logic to guess the template name and line
+ * moved display() method to Twig_Template (generated templates should now use doDisplay() instead)
+
+* 1.0.0 (2011-03-27)
+
+ * fixed output when using mbstring
+ * fixed duplicate call of methods when using the sandbox
+ * made the charset configurable for the escape filter
+
+* 1.0.0-RC2 (2011-02-21)
+
+ * changed the way {% set %} works when capturing (the content is now marked as safe)
+ * added support for macro name in the endmacro tag
+ * make Twig_Error compatible with PHP 5.3.0 >
+ * fixed an infinite loop on some Windows configurations
+ * fixed the "length" filter for numbers
+ * fixed Template::getAttribute() as properties in PHP are case sensitive
+ * removed coupling between Twig_Node and Twig_Template
+ * fixed the ternary operator precedence rule
+
+* 1.0.0-RC1 (2011-01-09)
+
+Backward incompatibilities:
+
+ * the "items" filter, which has been deprecated for quite a long time now, has been removed
+ * the "range" filter has been converted to a function: 0|range(10) -> range(0, 10)
+ * the "constant" filter has been converted to a function: {{ some_date|date('DATE_W3C'|constant) }} -> {{ some_date|date(constant('DATE_W3C')) }}
+ * the "cycle" filter has been converted to a function: {{ ['odd', 'even']|cycle(i) }} -> {{ cycle(['odd', 'even'], i) }}
+ * the "for" tag does not support "joined by" anymore
+ * the "autoescape" first argument is now "true"/"false" (instead of "on"/"off")
+ * the "parent" tag has been replaced by a "parent" function ({{ parent() }} instead of {% parent %})
+ * the "display" tag has been replaced by a "block" function ({{ block('title') }} instead of {% display title %})
+ * removed the grammar and simple token parser (moved to the Twig Extensions repository)
+
+Changes:
+
+ * added "needs_context" option for filters and functions (the context is then passed as a first argument)
+ * added global variables support
+ * made macros return their value instead of echoing directly (fixes calling a macro in sandbox mode)
+ * added the "from" tag to import macros as functions
+ * added support for functions (a function is just syntactic sugar for a getAttribute() call)
+ * made macros callable when sandbox mode is enabled
+ * added an exception when a macro uses a reserved name
+ * the "default" filter now uses the "empty" test instead of just checking for null
+ * added the "empty" test
+
+* 0.9.10 (2010-12-16)
+
+Backward incompatibilities:
+
+ * The Escaper extension is enabled by default, which means that all displayed
+ variables are now automatically escaped. You can revert to the previous
+ behavior by removing the extension via $env->removeExtension('escaper')
+ or just set the 'autoescape' option to 'false'.
+ * removed the "without loop" attribute for the "for" tag (not needed anymore
+ as the Optimizer take care of that for most cases)
+ * arrays and hashes have now a different syntax
+ * arrays keep the same syntax with square brackets: [1, 2]
+ * hashes now use curly braces (["a": "b"] should now be written as {"a": "b"})
+ * support for "arrays with keys" and "hashes without keys" is not supported anymore ([1, "foo": "bar"] or {"foo": "bar", 1})
+ * the i18n extension is now part of the Twig Extensions repository
+
+Changes:
+
+ * added the merge filter
+ * removed 'is_escaper' option for filters (a left over from the previous version) -- you must use 'is_safe' now instead
+ * fixed usage of operators as method names (like is, in, and not)
+ * changed the order of execution for node visitors
+ * fixed default() filter behavior when used with strict_variables set to on
+ * fixed filesystem loader compatibility with PHAR files
+ * enhanced error messages when an unexpected token is parsed in an expression
+ * fixed filename not being added to syntax error messages
+ * added the autoescape option to enable/disable autoescaping
+ * removed the newline after a comment (mimicks PHP behavior)
+ * added a syntax error exception when parent block is used on a template that does not extend another one
+ * made the Escaper extension enabled by default
+ * fixed sandbox extension when used with auto output escaping
+ * fixed escaper when wrapping a Twig_Node_Print (the original class must be preserved)
+ * added an Optimizer extension (enabled by default; optimizes "for" loops and "raw" filters)
+ * added priority to node visitors
+
+* 0.9.9 (2010-11-28)
+
+Backward incompatibilities:
+ * the self special variable has been renamed to _self
+ * the odd and even filters are now tests:
+ {{ foo|odd }} must now be written {{ foo is odd }}
+ * the "safe" filter has been renamed to "raw"
+ * in Node classes,
+ sub-nodes are now accessed via getNode() (instead of property access)
+ attributes via getAttribute() (instead of array access)
+ * the urlencode filter had been renamed to url_encode
+ * the include tag now merges the passed variables with the current context by default
+ (the old behavior is still possible by adding the "only" keyword)
+ * moved Exceptions to Twig_Error_* (Twig_SyntaxError/Twig_RuntimeError are now Twig_Error_Syntax/Twig_Error_Runtime)
+ * removed support for {{ 1 < i < 3 }} (use {{ i > 1 and i < 3 }} instead)
+ * the "in" filter has been removed ({{ a|in(b) }} should now be written {{ a in b }})
+
+Changes:
+ * added file and line to Twig_Error_Runtime exceptions thrown from Twig_Template
+ * changed trans tag to accept any variable for the plural count
+ * fixed sandbox mode (__toString() method check was not enforced if called implicitly from complex statements)
+ * added the ** (power) operator
+ * changed the algorithm used for parsing expressions
+ * added the spaceless tag
+ * removed trim_blocks option
+ * added support for is*() methods for attributes (foo.bar now looks for foo->getBar() or foo->isBar())
+ * changed all exceptions to extend Twig_Error
+ * fixed unary expressions ({{ not(1 or 0) }})
+ * fixed child templates (with an extend tag) that uses one or more imports
+ * added support for {{ 1 not in [2, 3] }} (more readable than the current {{ not (1 in [2, 3]) }})
+ * escaping has been rewritten
+ * the implementation of template inheritance has been rewritten
+ (blocks can now be called individually and still work with inheritance)
+ * fixed error handling for if tag when a syntax error occurs within a subparse process
+ * added a way to implement custom logic for resolving token parsers given a tag name
+ * fixed js escaper to be stricter (now uses a whilelist-based js escaper)
+ * added the following filers: "constant", "trans", "replace", "json_encode"
+ * added a "constant" test
+ * fixed objects with __toString() not being autoescaped
+ * fixed subscript expressions when calling __call() (methods now keep the case)
+ * added "test" feature (accessible via the "is" operator)
+ * removed the debug tag (should be done in an extension)
+ * fixed trans tag when no vars are used in plural form
+ * fixed race condition when writing template cache
+ * added the special _charset variable to reference the current charset
+ * added the special _context variable to reference the current context
+ * renamed self to _self (to avoid conflict)
+ * fixed Twig_Template::getAttribute() for protected properties
+
+* 0.9.8 (2010-06-28)
+
+Backward incompatibilities:
+ * the trans tag plural count is now attached to the plural tag:
+ old: `{% trans count %}...{% plural %}...{% endtrans %}`
+ new: `{% trans %}...{% plural count %}...{% endtrans %}`
+
+ * added a way to translate strings coming from a variable ({% trans var %})
+ * fixed trans tag when used with the Escaper extension
+ * fixed default cache umask
+ * removed Twig_Template instances from the debug tag output
+ * fixed objects with __isset() defined
+ * fixed set tag when used with a capture
+ * fixed type hinting for Twig_Environment::addFilter() method
+
+* 0.9.7 (2010-06-12)
+
+Backward incompatibilities:
+ * changed 'as' to '=' for the set tag ({% set title as "Title" %} must now be {% set title = "Title" %})
+ * removed the sandboxed attribute of the include tag (use the new sandbox tag instead)
+ * refactored the Node system (if you have custom nodes, you will have to update them to use the new API)
+
+ * added self as a special variable that refers to the current template (useful for importing macros from the current template)
+ * added Twig_Template instance support to the include tag
+ * added support for dynamic and conditional inheritance ({% extends some_var %} and {% extends standalone ? "minimum" : "base" %})
+ * added a grammar sub-framework to ease the creation of custom tags
+ * fixed the for tag for large arrays (some loop variables are now only available for arrays and objects that implement the Countable interface)
+ * removed the Twig_Resource::resolveMissingFilter() method
+ * fixed the filter tag which did not apply filtering to included files
+ * added a bunch of unit tests
+ * added a bunch of phpdoc
+ * added a sandbox tag in the sandbox extension
+ * changed the date filter to support any date format supported by DateTime
+ * added strict_variable setting to throw an exception when an invalid variable is used in a template (disabled by default)
+ * added the lexer, parser, and compiler as arguments to the Twig_Environment constructor
+ * changed the cache option to only accepts an explicit path to a cache directory or false
+ * added a way to add token parsers, filters, and visitors without creating an extension
+ * added three interfaces: Twig_NodeInterface, Twig_TokenParserInterface, and Twig_FilterInterface
+ * changed the generated code to match the new coding standards
+ * fixed sandbox mode (__toString() method check was not enforced if called implicitly from a simple statement like {{ article }})
+ * added an exception when a child template has a non-empty body (as it is always ignored when rendering)
+
+* 0.9.6 (2010-05-12)
+
+ * fixed variables defined outside a loop and for which the value changes in a for loop
+ * fixed the test suite for PHP 5.2 and older versions of PHPUnit
+ * added support for __call() in expression resolution
+ * fixed node visiting for macros (macros are now visited by visitors as any other node)
+ * fixed nested block definitions with a parent call (rarely useful but nonetheless supported now)
+ * added the cycle filter
+ * fixed the Lexer when mbstring.func_overload is used with an mbstring.internal_encoding different from ASCII
+ * added a long-syntax for the set tag ({% set foo %}...{% endset %})
+ * unit tests are now powered by PHPUnit
+ * added support for gettext via the `i18n` extension
+ * fixed twig_capitalize_string_filter() and fixed twig_length_filter() when used with UTF-8 values
+ * added a more useful exception if an if tag is not closed properly
+ * added support for escaping strategy in the autoescape tag
+ * fixed lexer when a template has a big chunk of text between/in a block
+
+* 0.9.5 (2010-01-20)
+
+As for any new release, don't forget to remove all cached templates after
+upgrading.
+
+If you have defined custom filters, you MUST upgrade them for this release. To
+upgrade, replace "array" with "new Twig_Filter_Function", and replace the
+environment constant by the "needs_environment" option:
+
+ // before
+ 'even' => array('twig_is_even_filter', false),
+ 'escape' => array('twig_escape_filter', true),
+
+ // after
+ 'even' => new Twig_Filter_Function('twig_is_even_filter'),
+ 'escape' => new Twig_Filter_Function('twig_escape_filter', array('needs_environment' => true)),
+
+If you have created NodeTransformer classes, you will need to upgrade them to
+the new interface (please note that the interface is not yet considered
+stable).
+
+ * fixed list nodes that did not extend the Twig_NodeListInterface
+ * added the "without loop" option to the for tag (it disables the generation of the loop variable)
+ * refactored node transformers to node visitors
+ * fixed automatic-escaping for blocks
+ * added a way to specify variables to pass to an included template
+ * changed the automatic-escaping rules to be more sensible and more configurable in custom filters (the documentation lists all the rules)
+ * improved the filter system to allow object methods to be used as filters
+ * changed the Array and String loaders to actually make use of the cache mechanism
+ * included the default filter function definitions in the extension class files directly (Core, Escaper)
+ * added the // operator (like the floor() PHP function)
+ * added the .. operator (as a syntactic sugar for the range filter when the step is 1)
+ * added the in operator (as a syntactic sugar for the in filter)
+ * added the following filters in the Core extension: in, range
+ * added support for arrays (same behavior as in PHP, a mix between lists and dictionaries, arrays and hashes)
+ * enhanced some error messages to provide better feedback in case of parsing errors
+
+* 0.9.4 (2009-12-02)
+
+If you have custom loaders, you MUST upgrade them for this release: The
+Twig_Loader base class has been removed, and the Twig_LoaderInterface has also
+been changed (see the source code for more information or the documentation).
+
+ * added support for DateTime instances for the date filter
+ * fixed loop.last when the array only has one item
+ * made it possible to insert newlines in tag and variable blocks
+ * fixed a bug when a literal '\n' were present in a template text
+ * fixed bug when the filename of a template contains */
+ * refactored loaders
+
+* 0.9.3 (2009-11-11)
+
+This release is NOT backward compatible with the previous releases.
+
+ The loaders do not take the cache and autoReload arguments anymore. Instead,
+ the Twig_Environment class has two new options: cache and auto_reload.
+ Upgrading your code means changing this kind of code:
+
+ $loader = new Twig_Loader_Filesystem('/path/to/templates', '/path/to/compilation_cache', true);
+ $twig = new Twig_Environment($loader);
+
+ to something like this:
+
+ $loader = new Twig_Loader_Filesystem('/path/to/templates');
+ $twig = new Twig_Environment($loader, array(
+ 'cache' => '/path/to/compilation_cache',
+ 'auto_reload' => true,
+ ));
+
+ * deprecated the "items" filter as it is not needed anymore
+ * made cache and auto_reload options of Twig_Environment instead of arguments of Twig_Loader
+ * optimized template loading speed
+ * removed output when an error occurs in a template and render() is used
+ * made major speed improvements for loops (up to 300% on even the smallest loops)
+ * added properties as part of the sandbox mode
+ * added public properties support (obj.item can now be the item property on the obj object)
+ * extended set tag to support expression as value ({% set foo as 'foo' ~ 'bar' %} )
+ * fixed bug when \ was used in HTML
+
+* 0.9.2 (2009-10-29)
+
+ * made some speed optimizations
+ * changed the cache extension to .php
+ * added a js escaping strategy
+ * added support for short block tag
+ * changed the filter tag to allow chained filters
+ * made lexer more flexible as you can now change the default delimiters
+ * added set tag
+ * changed default directory permission when cache dir does not exist (more secure)
+ * added macro support
+ * changed filters first optional argument to be a Twig_Environment instance instead of a Twig_Template instance
+ * made Twig_Autoloader::autoload() a static method
+ * avoid writing template file if an error occurs
+ * added $ escaping when outputting raw strings
+ * enhanced some error messages to ease debugging
+ * fixed empty cache files when the template contains an error
+
+* 0.9.1 (2009-10-14)
+
+ * fixed a bug in PHP 5.2.6
+ * fixed numbers with one than one decimal
+ * added support for method calls with arguments ({{ foo.bar('a', 43) }})
+ * made small speed optimizations
+ * made minor tweaks to allow better extensibility and flexibility
+
+* 0.9.0 (2009-10-12)
+
+ * Initial release
diff --git a/lib/twig/LICENSE b/lib/twig/LICENSE
new file mode 100755
index 0000000..5063d8d
--- /dev/null
+++ b/lib/twig/LICENSE
@@ -0,0 +1,31 @@
+Copyright (c) 2009 by the Twig Team, see AUTHORS for more details.
+
+Some 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.
+
+ * The names of the contributors may not be used to endorse or
+ promote products derived from this software without specific
+ prior written permission.
+
+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.
diff --git a/lib/twig/README.markdown b/lib/twig/README.markdown
new file mode 100755
index 0000000..832394b
--- /dev/null
+++ b/lib/twig/README.markdown
@@ -0,0 +1,15 @@
+Twig, the flexible, fast, and secure template language for PHP
+==============================================================
+
+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.
+
+More Information
+----------------
+
+Read the [documentation][1] for more information.
+
+[1]: http://twig.sensiolabs.org/documentation
\ No newline at end of file
diff --git a/lib/twig/bin/create_pear_package.php b/lib/twig/bin/create_pear_package.php
new file mode 100755
index 0000000..4899927
--- /dev/null
+++ b/lib/twig/bin/create_pear_package.php
@@ -0,0 +1,42 @@
+ 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'] .= ' '."\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;
+}
diff --git a/lib/twig/composer.json b/lib/twig/composer.json
new file mode 100755
index 0000000..87662b8
--- /dev/null
+++ b/lib/twig/composer.json
@@ -0,0 +1,27 @@
+{
+ "name": "twig/twig",
+ "type": "library",
+ "description": "Twig, the flexible, fast, and secure template language for PHP",
+ "keywords": ["templating"],
+ "homepage": "http://twig.sensiolabs.org",
+ "version": "1.6.4",
+ "license": "BSD",
+ "authors": [
+ {
+ "name": "Fabien Potencier",
+ "email": "fabien@symfony.com"
+ },
+ {
+ "name": "Armin Ronacher",
+ "email": "armin.ronacher@active-4.com"
+ }
+ ],
+ "require": {
+ "php": ">=5.2.4"
+ },
+ "autoload": {
+ "psr-0" : {
+ "Twig_" : "lib/"
+ }
+ }
+}
diff --git a/lib/twig/doc/advanced.rst b/lib/twig/doc/advanced.rst
new file mode 100755
index 0000000..e82a521
--- /dev/null
+++ b/lib/twig/doc/advanced.rst
@@ -0,0 +1,489 @@
+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
+
+
+
+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
+
+
+
+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
+
+
+
+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
diff --git a/lib/twig/doc/api.rst b/lib/twig/doc/api.rst
new file mode 100755
index 0000000..864585e
--- /dev/null
+++ b/lib/twig/doc/api.rst
@@ -0,0 +1,479 @@
+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 " }} {# won't be escaped #}
+
+ {% set text = "Twig " %}
+ {{ 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 " : " Twig" }} {# won't be escaped #}
+
+ {% set text = "Twig " %}
+ {{ foo ? text : " Twig" }} {# will be escaped #}
+
+ {% set text = "Twig " %}
+ {{ foo ? text|raw : " Twig" }} {# won't be escaped #}
+
+ {% set text = "Twig " %}
+ {{ foo ? text|escape : " 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.
diff --git a/lib/twig/doc/coding_standards.rst b/lib/twig/doc/coding_standards.rst
new file mode 100755
index 0000000..e0aab35
--- /dev/null
+++ b/lib/twig/doc/coding_standards.rst
@@ -0,0 +1,101 @@
+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 %}
diff --git a/lib/twig/doc/extensions.rst b/lib/twig/doc/extensions.rst
new file mode 100755
index 0000000..f4dd481
--- /dev/null
+++ b/lib/twig/doc/extensions.rst
@@ -0,0 +1,328 @@
+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
diff --git a/lib/twig/doc/filters/capitalize.rst b/lib/twig/doc/filters/capitalize.rst
new file mode 100755
index 0000000..10546a1
--- /dev/null
+++ b/lib/twig/doc/filters/capitalize.rst
@@ -0,0 +1,11 @@
+``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' #}
diff --git a/lib/twig/doc/filters/convert_encoding.rst b/lib/twig/doc/filters/convert_encoding.rst
new file mode 100755
index 0000000..be40b0d
--- /dev/null
+++ b/lib/twig/doc/filters/convert_encoding.rst
@@ -0,0 +1,22 @@
+``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
diff --git a/lib/twig/doc/filters/date.rst b/lib/twig/doc/filters/date.rst
new file mode 100755
index 0000000..9833f03
--- /dev/null
+++ b/lib/twig/doc/filters/date.rst
@@ -0,0 +1,65 @@
+``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") }}
diff --git a/lib/twig/doc/filters/default.rst b/lib/twig/doc/filters/default.rst
new file mode 100755
index 0000000..4055ead
--- /dev/null
+++ b/lib/twig/doc/filters/default.rst
@@ -0,0 +1,28 @@
+``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.
diff --git a/lib/twig/doc/filters/escape.rst b/lib/twig/doc/filters/escape.rst
new file mode 100755
index 0000000..dd927b4
--- /dev/null
+++ b/lib/twig/doc/filters/escape.rst
@@ -0,0 +1,30 @@
+``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
diff --git a/lib/twig/doc/filters/format.rst b/lib/twig/doc/filters/format.rst
new file mode 100755
index 0000000..fd5b18d
--- /dev/null
+++ b/lib/twig/doc/filters/format.rst
@@ -0,0 +1,16 @@
+``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`
diff --git a/lib/twig/doc/filters/index.rst b/lib/twig/doc/filters/index.rst
new file mode 100755
index 0000000..db2b39f
--- /dev/null
+++ b/lib/twig/doc/filters/index.rst
@@ -0,0 +1,29 @@
+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
diff --git a/lib/twig/doc/filters/join.rst b/lib/twig/doc/filters/join.rst
new file mode 100755
index 0000000..eec2045
--- /dev/null
+++ b/lib/twig/doc/filters/join.rst
@@ -0,0 +1,18 @@
+``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 #}
diff --git a/lib/twig/doc/filters/json_encode.rst b/lib/twig/doc/filters/json_encode.rst
new file mode 100755
index 0000000..c7d19b3
--- /dev/null
+++ b/lib/twig/doc/filters/json_encode.rst
@@ -0,0 +1,14 @@
+``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
diff --git a/lib/twig/doc/filters/keys.rst b/lib/twig/doc/filters/keys.rst
new file mode 100755
index 0000000..e4f090c
--- /dev/null
+++ b/lib/twig/doc/filters/keys.rst
@@ -0,0 +1,11 @@
+``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 %}
diff --git a/lib/twig/doc/filters/length.rst b/lib/twig/doc/filters/length.rst
new file mode 100755
index 0000000..f79b9bd
--- /dev/null
+++ b/lib/twig/doc/filters/length.rst
@@ -0,0 +1,12 @@
+``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 %}
+
diff --git a/lib/twig/doc/filters/lower.rst b/lib/twig/doc/filters/lower.rst
new file mode 100755
index 0000000..ef9faa9
--- /dev/null
+++ b/lib/twig/doc/filters/lower.rst
@@ -0,0 +1,10 @@
+``lower``
+=========
+
+The ``lower`` filter converts a value to lowercase:
+
+.. code-block:: jinja
+
+ {{ 'WELCOME'|lower }}
+
+ {# outputs 'welcome' #}
diff --git a/lib/twig/doc/filters/merge.rst b/lib/twig/doc/filters/merge.rst
new file mode 100755
index 0000000..4348e7a
--- /dev/null
+++ b/lib/twig/doc/filters/merge.rst
@@ -0,0 +1,41 @@
+``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' } #}
diff --git a/lib/twig/doc/filters/nl2br.rst b/lib/twig/doc/filters/nl2br.rst
new file mode 100755
index 0000000..694c672
--- /dev/null
+++ b/lib/twig/doc/filters/nl2br.rst
@@ -0,0 +1,22 @@
+``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.
+ You will like it too.
+
+ #}
+
+.. note::
+
+ The ``nl2br`` filter pre-escapes the input before applying the
+ transformation.
diff --git a/lib/twig/doc/filters/number_format.rst b/lib/twig/doc/filters/number_format.rst
new file mode 100755
index 0000000..ccc8f2f
--- /dev/null
+++ b/lib/twig/doc/filters/number_format.rst
@@ -0,0 +1,38 @@
+``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
diff --git a/lib/twig/doc/filters/raw.rst b/lib/twig/doc/filters/raw.rst
new file mode 100755
index 0000000..434dd24
--- /dev/null
+++ b/lib/twig/doc/filters/raw.rst
@@ -0,0 +1,12 @@
+``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 %}
diff --git a/lib/twig/doc/filters/replace.rst b/lib/twig/doc/filters/replace.rst
new file mode 100755
index 0000000..cc603fa
--- /dev/null
+++ b/lib/twig/doc/filters/replace.rst
@@ -0,0 +1,14 @@
+``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`
diff --git a/lib/twig/doc/filters/reverse.rst b/lib/twig/doc/filters/reverse.rst
new file mode 100755
index 0000000..54fafb4
--- /dev/null
+++ b/lib/twig/doc/filters/reverse.rst
@@ -0,0 +1,23 @@
+``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
diff --git a/lib/twig/doc/filters/slice.rst b/lib/twig/doc/filters/slice.rst
new file mode 100755
index 0000000..80a4293
--- /dev/null
+++ b/lib/twig/doc/filters/slice.rst
@@ -0,0 +1,57 @@
+``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
diff --git a/lib/twig/doc/filters/sort.rst b/lib/twig/doc/filters/sort.rst
new file mode 100755
index 0000000..0e330d2
--- /dev/null
+++ b/lib/twig/doc/filters/sort.rst
@@ -0,0 +1,17 @@
+``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
diff --git a/lib/twig/doc/filters/striptags.rst b/lib/twig/doc/filters/striptags.rst
new file mode 100755
index 0000000..5ccca45
--- /dev/null
+++ b/lib/twig/doc/filters/striptags.rst
@@ -0,0 +1,15 @@
+``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
diff --git a/lib/twig/doc/filters/title.rst b/lib/twig/doc/filters/title.rst
new file mode 100755
index 0000000..c5a318e
--- /dev/null
+++ b/lib/twig/doc/filters/title.rst
@@ -0,0 +1,11 @@
+``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' #}
diff --git a/lib/twig/doc/filters/trim.rst b/lib/twig/doc/filters/trim.rst
new file mode 100755
index 0000000..f1215f6
--- /dev/null
+++ b/lib/twig/doc/filters/trim.rst
@@ -0,0 +1,24 @@
+``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
diff --git a/lib/twig/doc/filters/upper.rst b/lib/twig/doc/filters/upper.rst
new file mode 100755
index 0000000..561cebe
--- /dev/null
+++ b/lib/twig/doc/filters/upper.rst
@@ -0,0 +1,10 @@
+``upper``
+=========
+
+The ``upper`` filter converts a value to uppercase:
+
+.. code-block:: jinja
+
+ {{ 'welcome'|upper }}
+
+ {# outputs 'WELCOME' #}
diff --git a/lib/twig/doc/filters/url_encode.rst b/lib/twig/doc/filters/url_encode.rst
new file mode 100755
index 0000000..c141f3b
--- /dev/null
+++ b/lib/twig/doc/filters/url_encode.rst
@@ -0,0 +1,14 @@
+``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
diff --git a/lib/twig/doc/functions/attribute.rst b/lib/twig/doc/functions/attribute.rst
new file mode 100755
index 0000000..3051bda
--- /dev/null
+++ b/lib/twig/doc/functions/attribute.rst
@@ -0,0 +1,18 @@
+``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.
diff --git a/lib/twig/doc/functions/block.rst b/lib/twig/doc/functions/block.rst
new file mode 100755
index 0000000..fd571ef
--- /dev/null
+++ b/lib/twig/doc/functions/block.rst
@@ -0,0 +1,15 @@
+``block``
+=========
+
+When a template uses inheritance and if you want to print a block multiple
+times, use the ``block`` function:
+
+.. code-block:: jinja
+
+ {% block title %}{% endblock %}
+
+ {{ block('title') }}
+
+ {% block body %}{% endblock %}
+
+.. seealso:: :doc:`extends<../tags/extends>`, :doc:`parent<../functions/parent>`
diff --git a/lib/twig/doc/functions/constant.rst b/lib/twig/doc/functions/constant.rst
new file mode 100755
index 0000000..5b247b3
--- /dev/null
+++ b/lib/twig/doc/functions/constant.rst
@@ -0,0 +1,9 @@
+``constant``
+============
+
+``constant`` returns the constant value for a given string:
+
+.. code-block:: jinja
+
+ {{ some_date|date(constant('DATE_W3C')) }}
+ {{ constant('Namespace\\Classname::CONSTANT_NAME') }}
diff --git a/lib/twig/doc/functions/cycle.rst b/lib/twig/doc/functions/cycle.rst
new file mode 100755
index 0000000..fe11d68
--- /dev/null
+++ b/lib/twig/doc/functions/cycle.rst
@@ -0,0 +1,20 @@
+``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 %}
diff --git a/lib/twig/doc/functions/date.rst b/lib/twig/doc/functions/date.rst
new file mode 100755
index 0000000..c1a011c
--- /dev/null
+++ b/lib/twig/doc/functions/date.rst
@@ -0,0 +1,46 @@
+``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
diff --git a/lib/twig/doc/functions/dump.rst b/lib/twig/doc/functions/dump.rst
new file mode 100755
index 0000000..5f27b4b
--- /dev/null
+++ b/lib/twig/doc/functions/dump.rst
@@ -0,0 +1,58 @@
+``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
+
+
+ {{ dump(user) }}
+
+
+.. 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
diff --git a/lib/twig/doc/functions/index.rst b/lib/twig/doc/functions/index.rst
new file mode 100755
index 0000000..3315528
--- /dev/null
+++ b/lib/twig/doc/functions/index.rst
@@ -0,0 +1,15 @@
+Functions
+=========
+
+.. toctree::
+ :maxdepth: 1
+
+ range
+ cycle
+ constant
+ random
+ attribute
+ block
+ parent
+ dump
+ date
diff --git a/lib/twig/doc/functions/parent.rst b/lib/twig/doc/functions/parent.rst
new file mode 100755
index 0000000..f5bd200
--- /dev/null
+++ b/lib/twig/doc/functions/parent.rst
@@ -0,0 +1,20 @@
+``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 %}
+ Table Of Contents
+ ...
+ {{ 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>`
diff --git a/lib/twig/doc/functions/random.rst b/lib/twig/doc/functions/random.rst
new file mode 100755
index 0000000..104493d
--- /dev/null
+++ b/lib/twig/doc/functions/random.rst
@@ -0,0 +1,24 @@
+``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
diff --git a/lib/twig/doc/functions/range.rst b/lib/twig/doc/functions/range.rst
new file mode 100755
index 0000000..c9bdd96
--- /dev/null
+++ b/lib/twig/doc/functions/range.rst
@@ -0,0 +1,38 @@
+``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
diff --git a/lib/twig/doc/hacking.rst b/lib/twig/doc/hacking.rst
new file mode 100755
index 0000000..0a82b6c
--- /dev/null
+++ b/lib/twig/doc/hacking.rst
@@ -0,0 +1,184 @@
+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();
+ }
diff --git a/lib/twig/doc/index.rst b/lib/twig/doc/index.rst
new file mode 100755
index 0000000..55517ea
--- /dev/null
+++ b/lib/twig/doc/index.rst
@@ -0,0 +1,18 @@
+Twig
+====
+
+.. toctree::
+ :maxdepth: 2
+
+ intro
+ templates
+ api
+ advanced
+ extensions
+ hacking
+ recipes
+ coding_standards
+ tags/index
+ filters/index
+ functions/index
+ tests/index
diff --git a/lib/twig/doc/intro.rst b/lib/twig/doc/intro.rst
new file mode 100755
index 0000000..06eabd8
--- /dev/null
+++ b/lib/twig/doc/intro.rst
@@ -0,0 +1,153 @@
+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
diff --git a/lib/twig/doc/recipes.rst b/lib/twig/doc/recipes.rst
new file mode 100755
index 0000000..0335335
--- /dev/null
+++ b/lib/twig/doc/recipes.rst
@@ -0,0 +1,301 @@
+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
diff --git a/lib/twig/doc/tags/autoescape.rst b/lib/twig/doc/tags/autoescape.rst
new file mode 100755
index 0000000..89c0420
--- /dev/null
+++ b/lib/twig/doc/tags/autoescape.rst
@@ -0,0 +1,43 @@
+``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` 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.
diff --git a/lib/twig/doc/tags/block.rst b/lib/twig/doc/tags/block.rst
new file mode 100755
index 0000000..e380482
--- /dev/null
+++ b/lib/twig/doc/tags/block.rst
@@ -0,0 +1,11 @@
+``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>`
diff --git a/lib/twig/doc/tags/do.rst b/lib/twig/doc/tags/do.rst
new file mode 100755
index 0000000..eca63d0
--- /dev/null
+++ b/lib/twig/doc/tags/do.rst
@@ -0,0 +1,12 @@
+``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 %}
diff --git a/lib/twig/doc/tags/extends.rst b/lib/twig/doc/tags/extends.rst
new file mode 100755
index 0000000..8d64436
--- /dev/null
+++ b/lib/twig/doc/tags/extends.rst
@@ -0,0 +1,187 @@
+``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`.
+
+Let's define a base template, ``base.html``, which defines a simple HTML
+skeleton document:
+
+.. code-block:: html+jinja
+
+
+
+
+ {% block head %}
+
+ {% block title %}{% endblock %} - My Webpage
+ {% endblock %}
+
+
+ {% block content %}{% endblock %}
+
+
+
+
+In this example, the :doc:`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() }}
+
+ {% endblock %}
+ {% block content %}
+ Index
+
+ Welcome on my awesome homepage.
+
+ {% 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
+
+ {% block title %}{% endblock %}
+ {{ block('title') }}
+ {% 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 %}
+ Table Of Contents
+ ...
+ {{ 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 %}
+ {% block loop_item %}{{ item }}{% endblock %}
+ {% 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>`
diff --git a/lib/twig/doc/tags/filter.rst b/lib/twig/doc/tags/filter.rst
new file mode 100755
index 0000000..82ca5c6
--- /dev/null
+++ b/lib/twig/doc/tags/filter.rst
@@ -0,0 +1,21 @@
+``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 %}
+ SOME TEXT
+ {% endfilter %}
+
+ {# outputs "<strong>some text</strong>" #}
diff --git a/lib/twig/doc/tags/flush.rst b/lib/twig/doc/tags/flush.rst
new file mode 100755
index 0000000..55ef593
--- /dev/null
+++ b/lib/twig/doc/tags/flush.rst
@@ -0,0 +1,17 @@
+``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
diff --git a/lib/twig/doc/tags/for.rst b/lib/twig/doc/tags/for.rst
new file mode 100755
index 0000000..57cbddb
--- /dev/null
+++ b/lib/twig/doc/tags/for.rst
@@ -0,0 +1,149 @@
+``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
+
+ Members
+
+ {% for user in users %}
+ {{ user.username|e }}
+ {% endfor %}
+
+
+.. 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
+
+
+ {% for user in users if user.active %}
+ {{ user.username|e }}
+ {% endfor %}
+
+
+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
+
+
+ {% for user in users %}
+ {{ user.username|e }}
+ {% else %}
+ no user found
+ {% endfor %}
+
+
+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
+
+ Members
+
+ {% for key in users|keys %}
+ {{ key }}
+ {% endfor %}
+
+
+Iterating over Keys and Values
+------------------------------
+
+You can also access both keys and values:
+
+.. code-block:: jinja
+
+ Members
+
+ {% for key, user in users %}
+ {{ key }}: {{ user.username|e }}
+ {% endfor %}
+
diff --git a/lib/twig/doc/tags/from.rst b/lib/twig/doc/tags/from.rst
new file mode 100755
index 0000000..5337a23
--- /dev/null
+++ b/lib/twig/doc/tags/from.rst
@@ -0,0 +1,8 @@
+``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>`
diff --git a/lib/twig/doc/tags/if.rst b/lib/twig/doc/tags/if.rst
new file mode 100755
index 0000000..14e12b1
--- /dev/null
+++ b/lib/twig/doc/tags/if.rst
@@ -0,0 +1,43 @@
+``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 %}
+ Our website is in maintenance mode. Please, come back later.
+ {% endif %}
+
+You can also test if an array is not empty:
+
+.. code-block:: jinja
+
+ {% if users %}
+
+ {% for user in users %}
+ {{ user.username|e }}
+ {% endfor %}
+
+ {% 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 %}
diff --git a/lib/twig/doc/tags/import.rst b/lib/twig/doc/tags/import.rst
new file mode 100755
index 0000000..8d47b36
--- /dev/null
+++ b/lib/twig/doc/tags/import.rst
@@ -0,0 +1,79 @@
+``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) %}
+
+ {% endmacro %}
+
+ {% macro textarea(name, value, rows) %}
+
+ {% 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 %}
+
+
+ Username
+ {{ forms.input('username') }}
+ Password
+ {{ forms.input('password', null, 'password') }}
+
+ {{ forms.textarea('comment') }}
+
+Alternatively you can import names from the template into the current
+namespace:
+
+.. code-block:: jinja
+
+ {% from 'forms.html' import input as input_field, textarea %}
+
+
+ Username
+ {{ input_field('username') }}
+ Password
+ {{ input_field('password', '', 'password') }}
+
+ {{ textarea('comment') }}
+
+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) %}
+
+ {% endmacro %}
+
+ {{ _self.textarea('comment') }}
+
+But you can still create an alias by importing from the ``_self`` variable:
+
+.. code-block:: jinja
+
+ {# index.html template #}
+
+ {% macro textarea(name, value, rows) %}
+
+ {% endmacro %}
+
+ {% import _self as forms %}
+
+ {{ forms.textarea('comment') }}
+
+.. seealso:: :doc:`macro<../tags/macro>`, :doc:`from<../tags/from>`
diff --git a/lib/twig/doc/tags/include.rst b/lib/twig/doc/tags/include.rst
new file mode 100755
index 0000000..7bba404
--- /dev/null
+++ b/lib/twig/doc/tags/include.rst
@@ -0,0 +1,86 @@
+``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.
diff --git a/lib/twig/doc/tags/index.rst b/lib/twig/doc/tags/index.rst
new file mode 100755
index 0000000..e44e93d
--- /dev/null
+++ b/lib/twig/doc/tags/index.rst
@@ -0,0 +1,22 @@
+Tags
+====
+
+.. toctree::
+ :maxdepth: 1
+
+ for
+ if
+ macro
+ filter
+ set
+ extends
+ block
+ include
+ import
+ from
+ use
+ spaceless
+ autoescape
+ raw
+ flush
+ do
diff --git a/lib/twig/doc/tags/macro.rst b/lib/twig/doc/tags/macro.rst
new file mode 100755
index 0000000..3d920e3
--- /dev/null
+++ b/lib/twig/doc/tags/macro.rst
@@ -0,0 +1,91 @@
+``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) %}
+
+ {% 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
+
+ {{ forms.input('username') }}
+ {{ forms.input('password', null, 'password') }}
+
+If macros are defined and used in the same template, you can use the
+special ``_self`` variable, without importing them:
+
+.. code-block:: jinja
+
+ {{ _self.input('username') }}
+
+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) %}
+
+ {% endmacro %}
+
+ {% macro wrapped_input(name, value, type, size) %}
+
+ {{ _self.input(name, value, type, size) }}
+
+ {% 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) %}
+
+ {% endmacro %}
+
+ {# shortcuts.html #}
+
+ {% macro wrapped_input(name, value, type, size) %}
+ {% import "forms.html" as forms %}
+
+ {{ forms.input(name, value, type, size) }}
+
+ {% endmacro %}
+
+.. seealso:: :doc:`from<../tags/from>`, :doc:`import<../tags/import>`
diff --git a/lib/twig/doc/tags/raw.rst b/lib/twig/doc/tags/raw.rst
new file mode 100755
index 0000000..4136c70
--- /dev/null
+++ b/lib/twig/doc/tags/raw.rst
@@ -0,0 +1,16 @@
+``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 %}
+
+ {% for item in seq %}
+ {{ item }}
+ {% endfor %}
+
+ {% endraw %}
diff --git a/lib/twig/doc/tags/set.rst b/lib/twig/doc/tags/set.rst
new file mode 100755
index 0000000..15090e7
--- /dev/null
+++ b/lib/twig/doc/tags/set.rst
@@ -0,0 +1,32 @@
+``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 %}
+
+ {% endset %}
+
+.. caution::
+
+ If you enable automatic output escaping, Twig will only consider the
+ content to be safe when capturing chunks of text.
diff --git a/lib/twig/doc/tags/spaceless.rst b/lib/twig/doc/tags/spaceless.rst
new file mode 100755
index 0000000..12e77b2
--- /dev/null
+++ b/lib/twig/doc/tags/spaceless.rst
@@ -0,0 +1,37 @@
+``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 %}
+
+ foo
+
+ {% endspaceless %}
+
+ {# output will be foo
#}
+
+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.
diff --git a/lib/twig/doc/tags/use.rst b/lib/twig/doc/tags/use.rst
new file mode 100755
index 0000000..085f916
--- /dev/null
+++ b/lib/twig/doc/tags/use.rst
@@ -0,0 +1,123 @@
+``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.
diff --git a/lib/twig/doc/templates.rst b/lib/twig/doc/templates.rst
new file mode 100755
index 0000000..bcd0ead
--- /dev/null
+++ b/lib/twig/doc/templates.rst
@@ -0,0 +1,719 @@
+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
+
+
+
+
+ My Webpage
+
+
+
+
+ My Webpage
+ {{ a_variable }}
+
+
+
+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` 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` 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` tag:
+
+.. code-block:: jinja
+
+ {% filter upper %}
+ This text becomes uppercase
+ {% endfilter %}
+
+Go to the :doc:`filters` 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` 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` tag:
+
+.. code-block:: jinja
+
+ Members
+
+ {% for user in users %}
+ {{ user.username|e }}
+ {% endfor %}
+
+
+The :doc:`if` tag can be used to test an expression:
+
+.. code-block:: jinja
+
+ {% if users|length > 0 %}
+
+ {% for user in users %}
+ {{ user.username|e }}
+ {% endfor %}
+
+ {% endif %}
+
+Go to the :doc:`tags` 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` 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
+
+
+
+
+ {% block head %}
+
+ {% block title %}{% endblock %} - My Webpage
+ {% endblock %}
+
+
+ {% block content %}{% endblock %}
+
+
+
+
+In this example, the :doc:`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() }}
+
+ {% endblock %}
+ {% block content %}
+ Index
+
+ Welcome on my awesome homepage.
+
+ {% endblock %}
+
+The :doc:`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` function. This gives back the results of the
+parent block:
+
+.. code-block:: jinja
+
+ {% block sidebar %}
+ Table Of Contents
+ ...
+ {{ parent() }}
+ {% endblock %}
+
+.. tip::
+
+ The documentation page for the :doc:`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` 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` 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`
+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`.
+
+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` tag. Here is a small
+example of a macro that renders a form element:
+
+.. code-block:: jinja
+
+ {% macro input(name, value, type, size) %}
+
+ {% endmacro %}
+
+Macros can be defined in any template, and need to be "imported" before being
+used via the :doc:`import` tag:
+
+.. code-block:: jinja
+
+ {% import "forms.html" as forms %}
+
+ {{ forms.input('username') }}
+
+Alternatively you can import names from the template into the current
+namespace via the :doc:`from` tag:
+
+.. code-block:: jinja
+
+ {% from 'forms.html' import input as input_field, textarea %}
+
+
+ Username
+ {{ input_field('username') }}
+ Password
+ {{ input_field('password', type='password') }}
+
+ {{ textarea('comment') }}
+
+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` 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`
+ 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 %}
+
+ foo
+
+ {% endspaceless %}
+
+ {# output will be foo
#}
+
+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' %}
+ {{- value }}
+
+ {# outputs 'no spaces ' #}
+
+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
diff --git a/lib/twig/doc/tests/constant.rst b/lib/twig/doc/tests/constant.rst
new file mode 100755
index 0000000..7970933
--- /dev/null
+++ b/lib/twig/doc/tests/constant.rst
@@ -0,0 +1,11 @@
+``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 %}
diff --git a/lib/twig/doc/tests/defined.rst b/lib/twig/doc/tests/defined.rst
new file mode 100755
index 0000000..702ce72
--- /dev/null
+++ b/lib/twig/doc/tests/defined.rst
@@ -0,0 +1,30 @@
+``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 %}
diff --git a/lib/twig/doc/tests/divisibleby.rst b/lib/twig/doc/tests/divisibleby.rst
new file mode 100755
index 0000000..9b0b964
--- /dev/null
+++ b/lib/twig/doc/tests/divisibleby.rst
@@ -0,0 +1,10 @@
+``divisibleby``
+===============
+
+``divisibleby`` checks if a variable is divisible by a number:
+
+.. code-block:: jinja
+
+ {% if loop.index is divisibleby(3) %}
+ ...
+ {% endif %}
diff --git a/lib/twig/doc/tests/empty.rst b/lib/twig/doc/tests/empty.rst
new file mode 100755
index 0000000..0d1eb32
--- /dev/null
+++ b/lib/twig/doc/tests/empty.rst
@@ -0,0 +1,11 @@
+``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 %}
diff --git a/lib/twig/doc/tests/even.rst b/lib/twig/doc/tests/even.rst
new file mode 100755
index 0000000..6ab5cc3
--- /dev/null
+++ b/lib/twig/doc/tests/even.rst
@@ -0,0 +1,10 @@
+``even``
+========
+
+``even`` returns ``true`` if the given number is even:
+
+.. code-block:: jinja
+
+ {{ var is even }}
+
+.. seealso:: :doc:`odd<../tests/odd>`
diff --git a/lib/twig/doc/tests/index.rst b/lib/twig/doc/tests/index.rst
new file mode 100755
index 0000000..b16edc5
--- /dev/null
+++ b/lib/twig/doc/tests/index.rst
@@ -0,0 +1,14 @@
+Tests
+=====
+
+.. toctree::
+ :maxdepth: 1
+
+ divisibleby
+ null
+ even
+ odd
+ sameas
+ constant
+ defined
+ empty
diff --git a/lib/twig/doc/tests/null.rst b/lib/twig/doc/tests/null.rst
new file mode 100755
index 0000000..44eec62
--- /dev/null
+++ b/lib/twig/doc/tests/null.rst
@@ -0,0 +1,12 @@
+``null``
+========
+
+``null`` returns ``true`` if the variable is ``null``:
+
+.. code-block:: jinja
+
+ {{ var is null }}
+
+.. note::
+
+ ``none`` is an alias for ``null``.
diff --git a/lib/twig/doc/tests/odd.rst b/lib/twig/doc/tests/odd.rst
new file mode 100755
index 0000000..9eece77
--- /dev/null
+++ b/lib/twig/doc/tests/odd.rst
@@ -0,0 +1,10 @@
+``odd``
+=======
+
+``odd`` returns ``true`` if the given number is odd:
+
+.. code-block:: jinja
+
+ {{ var is odd }}
+
+.. seealso:: :doc:`even<../tests/even>`
diff --git a/lib/twig/doc/tests/sameas.rst b/lib/twig/doc/tests/sameas.rst
new file mode 100755
index 0000000..efb15c3
--- /dev/null
+++ b/lib/twig/doc/tests/sameas.rst
@@ -0,0 +1,11 @@
+``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 %}
diff --git a/lib/twig/ext/twig/.gitignore b/lib/twig/ext/twig/.gitignore
new file mode 100755
index 0000000..56ea76c
--- /dev/null
+++ b/lib/twig/ext/twig/.gitignore
@@ -0,0 +1,30 @@
+*.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
diff --git a/lib/twig/ext/twig/LICENSE b/lib/twig/ext/twig/LICENSE
new file mode 100755
index 0000000..66b8bb4
--- /dev/null
+++ b/lib/twig/ext/twig/LICENSE
@@ -0,0 +1,22 @@
+Copyright (c) 2011, Derick Rethans
+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.
diff --git a/lib/twig/ext/twig/config.m4 b/lib/twig/ext/twig/config.m4
new file mode 100755
index 0000000..83486be
--- /dev/null
+++ b/lib/twig/ext/twig/config.m4
@@ -0,0 +1,8 @@
+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
diff --git a/lib/twig/ext/twig/config.w32 b/lib/twig/ext/twig/config.w32
new file mode 100755
index 0000000..cb287b9
--- /dev/null
+++ b/lib/twig/ext/twig/config.w32
@@ -0,0 +1,8 @@
+// vim:ft=javascript
+
+ARG_ENABLE("twig", "Twig support", "no");
+
+if (PHP_TWIG != "no") {
+ AC_DEFINE('HAVE_TWIG', 1);
+ EXTENSION('twig', 'twig.c');
+}
diff --git a/lib/twig/ext/twig/php_twig.h b/lib/twig/ext/twig/php_twig.h
new file mode 100755
index 0000000..752dd82
--- /dev/null
+++ b/lib/twig/ext/twig/php_twig.h
@@ -0,0 +1,49 @@
+/*
+ +----------------------------------------------------------------------+
+ | 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 |
+ +----------------------------------------------------------------------+
+ */
+
+#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
diff --git a/lib/twig/ext/twig/twig.c b/lib/twig/ext/twig/twig.c
new file mode 100755
index 0000000..880b964
--- /dev/null
+++ b/lib/twig/ext/twig/twig.c
@@ -0,0 +1,1025 @@
+/*
+ +----------------------------------------------------------------------+
+ | 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 |
+ +----------------------------------------------------------------------+
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "php.h"
+#include "php_ini.h"
+#include "ext/standard/info.h"
+#include "php_twig.h"
+#include "ext/standard/php_string.h"
+#include "ext/standard/php_smart_str.h"
+
+#include "Zend/zend_object_handlers.h"
+#include "Zend/zend_interfaces.h"
+#include "Zend/zend_exceptions.h"
+
+#ifndef Z_ADDREF_P
+#define Z_ADDREF_P(pz) (pz)->refcount++
+#endif
+
+ZEND_BEGIN_ARG_INFO_EX(twig_template_get_attribute_args, ZEND_SEND_BY_VAL, ZEND_RETURN_VALUE, 6)
+ ZEND_ARG_INFO(0, template)
+ ZEND_ARG_INFO(0, object)
+ ZEND_ARG_INFO(0, item)
+ ZEND_ARG_INFO(0, arguments)
+ ZEND_ARG_INFO(0, type)
+ ZEND_ARG_INFO(0, isDefinedTest)
+ZEND_END_ARG_INFO()
+
+zend_function_entry twig_functions[] = {
+ PHP_FE(twig_template_get_attributes, twig_template_get_attribute_args)
+ {NULL, NULL, NULL}
+};
+
+
+zend_module_entry twig_module_entry = {
+#if ZEND_MODULE_API_NO >= 20010901
+ STANDARD_MODULE_HEADER,
+#endif
+ "twig",
+ twig_functions,
+ PHP_MINIT(twig),
+ PHP_MSHUTDOWN(twig),
+ PHP_RINIT(twig),
+ PHP_RSHUTDOWN(twig),
+ PHP_MINFO(twig),
+#if ZEND_MODULE_API_NO >= 20010901
+ PHP_TWIG_VERSION,
+#endif
+ STANDARD_MODULE_PROPERTIES
+};
+
+
+#ifdef COMPILE_DL_TWIG
+ZEND_GET_MODULE(twig)
+#endif
+
+PHP_INI_BEGIN()
+PHP_INI_END()
+
+PHP_MINIT_FUNCTION(twig)
+{
+ REGISTER_INI_ENTRIES();
+
+ return SUCCESS;
+}
+
+
+PHP_MSHUTDOWN_FUNCTION(twig)
+{
+ UNREGISTER_INI_ENTRIES();
+
+ return SUCCESS;
+}
+
+
+
+PHP_RINIT_FUNCTION(twig)
+{
+ return SUCCESS;
+}
+
+
+
+PHP_RSHUTDOWN_FUNCTION(twig)
+{
+ return SUCCESS;
+}
+
+
+PHP_MINFO_FUNCTION(twig)
+{
+ php_info_print_table_start();
+ php_info_print_table_header(2, "Twig support", "enabled");
+ php_info_print_table_row(2, "Version", PHP_TWIG_VERSION);
+ php_info_print_table_end();
+
+ DISPLAY_INI_ENTRIES();
+
+}
+
+int TWIG_ARRAY_KEY_EXISTS(zval *array, char* key, int key_len)
+{
+ if (Z_TYPE_P(array) != IS_ARRAY) {
+ return 0;
+ }
+ return zend_symtable_exists(Z_ARRVAL_P(array), key, key_len + 1);
+}
+
+int TWIG_INSTANCE_OF(zval *object, zend_class_entry *interface TSRMLS_DC)
+{
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ return 0;
+ }
+ return instanceof_function(Z_OBJCE_P(object), interface TSRMLS_CC);
+}
+
+int TWIG_INSTANCE_OF_USERLAND(zval *object, char *interface TSRMLS_DC)
+{
+ zend_class_entry **pce;
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ return 0;
+ }
+ if (zend_lookup_class(interface, strlen(interface), &pce TSRMLS_CC) == FAILURE) {
+ return 0;
+ }
+ return instanceof_function(Z_OBJCE_P(object), *pce TSRMLS_CC);
+}
+
+zval *TWIG_GET_ARRAYOBJECT_ELEMENT(zval *object, zval *offset TSRMLS_DC)
+{
+ zend_class_entry *ce = Z_OBJCE_P(object);
+ zval *retval;
+
+ if (Z_TYPE_P(object) == IS_OBJECT) {
+ SEPARATE_ARG_IF_REF(offset);
+ zend_call_method_with_1_params(&object, ce, NULL, "offsetget", &retval, offset);
+
+ zval_ptr_dtor(&offset);
+
+ if (!retval) {
+ if (!EG(exception)) {
+ zend_error(E_ERROR, "Undefined offset for object of type %s used as array", ce->name);
+ }
+ return NULL;
+ }
+
+ return retval;
+ }
+ return NULL;
+}
+
+int TWIG_ISSET_ARRAYOBJECT_ELEMENT(zval *object, zval *offset TSRMLS_DC)
+{
+ zend_class_entry *ce = Z_OBJCE_P(object);
+ zval *retval;
+
+ if (Z_TYPE_P(object) == IS_OBJECT) {
+ SEPARATE_ARG_IF_REF(offset);
+ zend_call_method_with_1_params(&object, ce, NULL, "offsetexists", &retval, offset);
+
+ zval_ptr_dtor(&offset);
+
+ if (!retval) {
+ if (!EG(exception)) {
+ zend_error(E_ERROR, "Undefined offset for object of type %s used as array", ce->name);
+ }
+ return 0;
+ }
+
+ return (retval && Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval));
+ }
+ return 0;
+}
+
+char *TWIG_STRTOLOWER(const char *str, int str_len)
+{
+ char *item_dup;
+
+ item_dup = estrndup(str, str_len);
+ php_strtolower(item_dup, str_len);
+ return item_dup;
+}
+
+zval *TWIG_CALL_USER_FUNC_ARRAY(zval *object, char *function, zval *arguments TSRMLS_DC)
+{
+ zend_fcall_info fci;
+ zval ***args = NULL;
+ int arg_count = 0;
+ HashTable *table;
+ HashPosition pos;
+ int i = 0;
+ zval *retval_ptr;
+ zval *zfunction;
+
+ if (arguments) {
+ table = HASH_OF(arguments);
+ args = safe_emalloc(sizeof(zval **), table->nNumOfElements, 0);
+
+ zend_hash_internal_pointer_reset_ex(table, &pos);
+
+ while (zend_hash_get_current_data_ex(table, (void **)&args[i], &pos) == SUCCESS) {
+ i++;
+ zend_hash_move_forward_ex(table, &pos);
+ }
+ arg_count = table->nNumOfElements;
+ }
+
+ MAKE_STD_ZVAL(zfunction);
+ ZVAL_STRING(zfunction, function, 1);
+ fci.size = sizeof(fci);
+ fci.function_table = EG(function_table);
+ fci.function_name = zfunction;
+ fci.symbol_table = NULL;
+#if PHP_VERSION_ID >= 50300
+ fci.object_ptr = object;
+#else
+ fci.object_pp = &object;
+#endif
+ fci.retval_ptr_ptr = &retval_ptr;
+ fci.param_count = arg_count;
+ fci.params = args;
+ fci.no_separation = 0;
+
+ if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
+ zval_dtor(zfunction);
+ efree(zfunction);
+ zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Could not execute %s::%s()", zend_get_class_entry(object TSRMLS_CC)->name, function TSRMLS_CC);
+ }
+
+ if (args) {
+ efree(fci.params);
+ }
+ zval_dtor(zfunction);
+ efree(zfunction);
+ return retval_ptr;
+}
+
+int TWIG_CALL_BOOLEAN(zval *object, char *functionName TSRMLS_DC)
+{
+ zval *ret;
+ int res;
+
+ ret = TWIG_CALL_USER_FUNC_ARRAY(object, functionName, NULL TSRMLS_CC);
+ res = Z_LVAL_P(ret);
+ zval_ptr_dtor(&ret);
+ return res;
+}
+
+zval *TWIG_GET_STATIC_PROPERTY(zval *class, char *prop_name TSRMLS_DC)
+{
+ zval **tmp_zval;
+ zend_class_entry *ce;
+
+ if (class == NULL || Z_TYPE_P(class) != IS_OBJECT) {
+ return NULL;
+ }
+
+ ce = zend_get_class_entry(class TSRMLS_CC);
+#if PHP_VERSION_ID >= 50400
+ tmp_zval = zend_std_get_static_property(ce, prop_name, strlen(prop_name), 0, NULL TSRMLS_CC);
+#else
+ tmp_zval = zend_std_get_static_property(ce, prop_name, strlen(prop_name), 0 TSRMLS_CC);
+#endif
+ return *tmp_zval;
+}
+
+zval *TWIG_GET_ARRAY_ELEMENT_ZVAL(zval *class, zval *prop_name TSRMLS_DC)
+{
+ zval **tmp_zval;
+ char *tmp_name;
+
+ if (class == NULL || Z_TYPE_P(class) != IS_ARRAY || Z_TYPE_P(prop_name) != IS_STRING) {
+ if (class != NULL && Z_TYPE_P(class) == IS_OBJECT && TWIG_INSTANCE_OF(class, zend_ce_arrayaccess TSRMLS_CC)) {
+ // array access object
+ return TWIG_GET_ARRAYOBJECT_ELEMENT(class, prop_name TSRMLS_CC);
+ }
+ return NULL;
+ }
+
+ convert_to_string(prop_name);
+ tmp_name = Z_STRVAL_P(prop_name);
+ if (zend_symtable_find(HASH_OF(class), tmp_name, strlen(tmp_name)+1, (void**) &tmp_zval) == SUCCESS) {
+ return *tmp_zval;
+ }
+ return NULL;
+}
+
+zval *TWIG_GET_ARRAY_ELEMENT(zval *class, char *prop_name, int prop_name_length TSRMLS_DC)
+{
+ zval **tmp_zval;
+
+ if (class == NULL/* || Z_TYPE_P(class) != IS_ARRAY*/) {
+ return NULL;
+ }
+
+ if (class != NULL && Z_TYPE_P(class) == IS_OBJECT && TWIG_INSTANCE_OF(class, zend_ce_arrayaccess TSRMLS_CC)) {
+ // array access object
+ zval *tmp_name_zval;
+ zval *tmp_ret_zval;
+
+ ALLOC_INIT_ZVAL(tmp_name_zval);
+ ZVAL_STRING(tmp_name_zval, prop_name, 1);
+ tmp_ret_zval = TWIG_GET_ARRAYOBJECT_ELEMENT(class, tmp_name_zval TSRMLS_CC);
+ zval_dtor(tmp_name_zval);
+ efree(tmp_name_zval);
+ return tmp_ret_zval;
+ }
+
+ if (zend_symtable_find(HASH_OF(class), prop_name, prop_name_length+1, (void**)&tmp_zval) == SUCCESS) {
+ return *tmp_zval;
+ }
+ return NULL;
+}
+
+zval *TWIG_PROPERTY(zval *object, zval *propname TSRMLS_DC)
+{
+ char *prot_name;
+ int prot_name_length;
+ zval *tmp = NULL;
+
+ tmp = TWIG_GET_ARRAY_ELEMENT(object, Z_STRVAL_P(propname), Z_STRLEN_P(propname) TSRMLS_CC);
+ if (tmp) {
+ return tmp;
+ }
+
+ zend_mangle_property_name(&prot_name, &prot_name_length, "*", 1, Z_STRVAL_P(propname), Z_STRLEN_P(propname), 0);
+ tmp = TWIG_GET_ARRAY_ELEMENT(object, prot_name, prot_name_length TSRMLS_CC);
+ efree(prot_name);
+ if (tmp) {
+ return tmp;
+ }
+
+ if (Z_OBJ_HT_P(object)->read_property) {
+#if PHP_VERSION_ID >= 50400
+ tmp = Z_OBJ_HT_P(object)->read_property(object, propname, BP_VAR_IS, NULL TSRMLS_CC);
+#else
+ tmp = Z_OBJ_HT_P(object)->read_property(object, propname, BP_VAR_IS TSRMLS_CC);
+#endif
+ if (tmp != EG(uninitialized_zval_ptr)) {
+ return tmp;
+ } else {
+ return NULL;
+ }
+ }
+ return tmp;
+}
+
+int TWIG_HAS_PROPERTY(zval *object, zval *propname TSRMLS_DC)
+{
+ if (Z_OBJ_HT_P(object)->has_property) {
+#if PHP_VERSION_ID >= 50400
+ return Z_OBJ_HT_P(object)->has_property(object, propname, 0, NULL TSRMLS_CC);
+#else
+ return Z_OBJ_HT_P(object)->has_property(object, propname, 0 TSRMLS_CC);
+#endif
+ }
+ return 0;
+}
+
+zval *TWIG_PROPERTY_CHAR(zval *object, char *propname TSRMLS_DC)
+{
+ zval *tmp_name_zval, *tmp;
+
+ ALLOC_INIT_ZVAL(tmp_name_zval);
+ ZVAL_STRING(tmp_name_zval, propname, 1);
+ tmp = TWIG_PROPERTY(object, tmp_name_zval TSRMLS_CC);
+ zval_dtor(tmp_name_zval);
+ efree(tmp_name_zval);
+ return tmp;
+}
+
+int TWIG_CALL_B_0(zval *object, char *method)
+{
+ return 0;
+}
+
+zval *TWIG_CALL_S(zval *object, char *method, char *arg0 TSRMLS_DC)
+{
+ zend_fcall_info fci;
+ zval **args[1];
+ zval *argument;
+ zval *zfunction;
+ zval *retval_ptr;
+
+ MAKE_STD_ZVAL(argument);
+ ZVAL_STRING(argument, arg0, 1);
+ args[0] = &argument;
+
+ MAKE_STD_ZVAL(zfunction);
+ ZVAL_STRING(zfunction, method, 1);
+ fci.size = sizeof(fci);
+ fci.function_table = EG(function_table);
+ fci.function_name = zfunction;
+ fci.symbol_table = NULL;
+#if PHP_VERSION_ID >= 50300
+ fci.object_ptr = object;
+#else
+ fci.object_pp = &object;
+#endif
+ fci.retval_ptr_ptr = &retval_ptr;
+ fci.param_count = 1;
+ fci.params = args;
+ fci.no_separation = 0;
+
+ if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
+ zval_dtor(argument);
+ return 0;
+ }
+ zval_dtor(zfunction);
+ efree(zfunction);
+ zval_dtor(argument);
+ efree(argument);
+ return retval_ptr;
+}
+
+int TWIG_CALL_SB(zval *object, char *method, char *arg0 TSRMLS_DC)
+{
+ zval *retval_ptr;
+ int success;
+
+ retval_ptr = TWIG_CALL_S(object, method, arg0 TSRMLS_CC);
+ success = (retval_ptr && (Z_TYPE_P(retval_ptr) == IS_BOOL) && Z_LVAL_P(retval_ptr));
+
+ if (retval_ptr) {
+ zval_ptr_dtor(&retval_ptr);
+ }
+
+ return success;
+}
+
+int TWIG_CALL_Z(zval *object, char *method, zval *arg1 TSRMLS_DC)
+{
+ zend_fcall_info fci;
+ zval **args[1];
+ zval *zfunction;
+ zval *retval_ptr;
+ int success;
+
+ args[0] = &arg1;
+
+ MAKE_STD_ZVAL(zfunction);
+ ZVAL_STRING(zfunction, method, 1);
+ fci.size = sizeof(fci);
+ fci.function_table = EG(function_table);
+ fci.function_name = zfunction;
+ fci.symbol_table = NULL;
+#if PHP_VERSION_ID >= 50300
+ fci.object_ptr = object;
+#else
+ fci.object_pp = &object;
+#endif
+ fci.retval_ptr_ptr = &retval_ptr;
+ fci.param_count = 1;
+ fci.params = args;
+ fci.no_separation = 0;
+
+ if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
+ zval_dtor(zfunction);
+ efree(zfunction);
+ if (retval_ptr) {
+ zval_ptr_dtor(&retval_ptr);
+ }
+ return 0;
+ }
+
+ zval_dtor(zfunction);
+ efree(zfunction);
+
+ success = (retval_ptr && (Z_TYPE_P(retval_ptr) == IS_BOOL) && Z_LVAL_P(retval_ptr));
+ if (retval_ptr) {
+ zval_ptr_dtor(&retval_ptr);
+ }
+
+ return success;
+}
+
+int TWIG_CALL_ZZ(zval *object, char *method, zval *arg1, zval *arg2 TSRMLS_DC)
+{
+ zend_fcall_info fci;
+ zval **args[2];
+ zval *zfunction;
+ zval *retval_ptr;
+ int success;
+
+ args[0] = &arg1;
+ args[1] = &arg2;
+
+ MAKE_STD_ZVAL(zfunction);
+ ZVAL_STRING(zfunction, method, 1);
+ fci.size = sizeof(fci);
+ fci.function_table = EG(function_table);
+ fci.function_name = zfunction;
+ fci.symbol_table = NULL;
+#if PHP_VERSION_ID >= 50300
+ fci.object_ptr = object;
+#else
+ fci.object_pp = &object;
+#endif
+ fci.retval_ptr_ptr = &retval_ptr;
+ fci.param_count = 2;
+ fci.params = args;
+ fci.no_separation = 0;
+
+ if (zend_call_function(&fci, NULL TSRMLS_CC) == FAILURE) {
+ zval_dtor(zfunction);
+ return 0;
+ }
+
+ zval_dtor(zfunction);
+
+ success = (retval_ptr && (Z_TYPE_P(retval_ptr) == IS_BOOL) && Z_LVAL_P(retval_ptr));
+ if (retval_ptr) {
+ zval_ptr_dtor(&retval_ptr);
+ }
+
+ return success;
+}
+
+#ifndef Z_SET_REFCOUNT_P
+# define Z_SET_REFCOUNT_P(pz, rc) pz->refcount = rc
+# define Z_UNSET_ISREF_P(pz) pz->is_ref = 0
+#endif
+
+void TWIG_NEW(zval *object, char *class, zval *arg0, zval *arg1 TSRMLS_DC)
+{
+ zend_class_entry **pce;
+
+ if (zend_lookup_class(class, strlen(class), &pce TSRMLS_CC) == FAILURE) {
+ return;
+ }
+
+ Z_TYPE_P(object) = IS_OBJECT;
+ object_init_ex(object, *pce);
+ Z_SET_REFCOUNT_P(object, 1);
+ Z_UNSET_ISREF_P(object);
+
+ TWIG_CALL_ZZ(object, "__construct", arg0, arg1 TSRMLS_CC);
+}
+
+static int twig_add_array_key_to_string(void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ smart_str *buf;
+ char *joiner;
+
+ buf = va_arg(args, smart_str*);
+ joiner = va_arg(args, char*);
+
+ if (buf->len != 0) {
+ smart_str_appends(buf, joiner);
+ }
+
+ if (hash_key->nKeyLength == 0) {
+ smart_str_append_long(buf, (long) hash_key->h);
+ } else {
+ char *key, *tmp_str;
+ int key_len, tmp_len;
+ key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
+ tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);
+
+ smart_str_appendl(buf, tmp_str, tmp_len);
+ efree(key);
+ efree(tmp_str);
+ }
+
+ return 0;
+}
+
+char *TWIG_IMPLODE_ARRAY_KEYS(char *joiner, zval *array TSRMLS_DC)
+{
+ smart_str collector = { 0, 0, 0 };
+
+ smart_str_appendl(&collector, "", 0);
+ zend_hash_apply_with_arguments(HASH_OF(array) TSRMLS_CC, twig_add_array_key_to_string, 2, &collector, joiner);
+ smart_str_0(&collector);
+
+ return collector.c;
+}
+
+static void TWIG_THROW_EXCEPTION(char *exception_name TSRMLS_DC, char *message, ...)
+{
+ char *buffer;
+ va_list args;
+ zend_class_entry **pce;
+
+ if (zend_lookup_class(exception_name, strlen(exception_name), &pce TSRMLS_CC) == FAILURE)
+ {
+ return;
+ }
+
+ va_start(args, message);
+ vspprintf(&buffer, 0, message, args);
+ va_end(args);
+
+ zend_throw_exception_ex(*pce, 0 TSRMLS_CC, buffer);
+}
+
+char *TWIG_GET_CLASS_NAME(zval *object TSRMLS_DC)
+{
+ char *class_name;
+ zend_uint class_name_len;
+
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ return "";
+ }
+ zend_get_object_classname(object, &class_name, &class_name_len TSRMLS_CC);
+ return class_name;
+}
+
+static int twig_add_method_to_class(void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ zval *retval;
+ char *item;
+ size_t item_len;
+ zend_function *mptr = (zend_function *) pDest;
+
+ if (!(mptr->common.fn_flags & ZEND_ACC_PUBLIC)) {
+ return 0;
+ }
+
+ retval = va_arg(args, zval*);
+
+ item_len = strlen(mptr->common.function_name);
+ item = estrndup(mptr->common.function_name, item_len);
+ php_strtolower(item, item_len);
+
+ add_assoc_stringl_ex(retval, item, item_len+1, item, item_len, 0);
+
+ return 0;
+}
+
+static int twig_add_property_to_class(void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ zend_class_entry *ce;
+ zval *retval;
+ char *class_name, *prop_name;
+ zend_property_info *pptr = (zend_property_info *) pDest;
+
+ if (!(pptr->flags & ZEND_ACC_PUBLIC)) {
+ return 0;
+ }
+
+ ce = *va_arg(args, zend_class_entry**);
+ retval = va_arg(args, zval*);
+
+ zend_unmangle_property_name(pptr->name, pptr->name_length, &class_name, &prop_name);
+
+ add_assoc_string(retval, prop_name, prop_name, 1);
+
+ return 0;
+}
+
+/* {{{ _adddynproperty */
+static int twig_add_dyn_property_to_class(void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+{
+ zend_class_entry *ce = *va_arg(args, zend_class_entry**);
+ zval *retval = va_arg(args, zval*), member;
+ char *class_name, *prop_name;
+
+ if (hash_key->nKeyLength < 1 || hash_key->arKey[0] == '\0') {
+ return 0; /* non public cannot be dynamic */
+ }
+
+ ZVAL_STRINGL(&member, hash_key->arKey, hash_key->nKeyLength-1, 0);
+ if (zend_get_property_info(ce, &member, 1 TSRMLS_CC) == &EG(std_property_info)) {
+ zend_unmangle_property_name((&EG(std_property_info))->name, (&EG(std_property_info))->name_length, &class_name, &prop_name);
+ add_assoc_string(retval, prop_name, prop_name, 1);
+ }
+ return 0;
+}
+
+static void twig_add_class_to_cache(zval *cache, zval *object, char *class_name TSRMLS_DC)
+{
+ zval *class_info, *class_methods, *class_properties;
+ zend_class_entry *class_ce;
+
+ class_ce = zend_get_class_entry(object TSRMLS_CC);
+
+ ALLOC_INIT_ZVAL(class_info);
+ ALLOC_INIT_ZVAL(class_methods);
+ ALLOC_INIT_ZVAL(class_properties);
+ array_init(class_info);
+ array_init(class_methods);
+ array_init(class_properties);
+ // add all methods to self::cache[$class]['methods']
+ zend_hash_apply_with_arguments(&class_ce->function_table TSRMLS_CC, twig_add_method_to_class, 1, class_methods);
+ zend_hash_apply_with_arguments(&class_ce->properties_info TSRMLS_CC, twig_add_property_to_class, 2, &class_ce, class_properties);
+
+ if (object && Z_OBJ_HT_P(object)->get_properties) {
+ HashTable *properties = Z_OBJ_HT_P(object)->get_properties(object TSRMLS_CC);
+ zend_hash_apply_with_arguments(properties TSRMLS_CC, twig_add_dyn_property_to_class, 2, &class_ce, class_properties);
+ }
+ add_assoc_zval(class_info, "methods", class_methods);
+ add_assoc_zval(class_info, "properties", class_properties);
+ add_assoc_zval(cache, class_name, class_info);
+}
+
+/* {{{ proto mixed twig_template_get_attributes(TwigTemplate template, mixed object, mixed item, array arguments, string type, boolean isDefinedTest, boolean ignoreStrictCheck)
+ A C implementation of TwigTemplate::getAttribute() */
+PHP_FUNCTION(twig_template_get_attributes)
+{
+ zval *template;
+ zval *object;
+ char *item;
+ int item_len;
+ zval zitem;
+ zval *arguments = NULL;
+ zval *ret = NULL;
+ char *type = NULL;
+ int type_len = 0;
+ zend_bool isDefinedTest = 0;
+ zend_bool ignoreStrictCheck = 0;
+ int free_ret = 0;
+ zval *tmp_self_cache;
+
+
+ if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ozs|asbb", &template, &object, &item, &item_len, &arguments, &type, &type_len, &isDefinedTest, &ignoreStrictCheck) == FAILURE) {
+ return;
+ }
+
+ INIT_PZVAL(&zitem);
+ ZVAL_STRINGL(&zitem, item, item_len, 0);
+
+ if (!type) {
+ type = "any";
+ }
+
+/*
+ // array
+ if (Twig_TemplateInterface::METHOD_CALL !== $type) {
+ if ((is_array($object) && array_key_exists($item, $object))
+ || ($object instanceof ArrayAccess && isset($object[$item]))
+ ) {
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ return $object[$item];
+ }
+*/
+ if (strcmp("method", type) != 0) {
+// printf("XXXmethod: %s\n", type);
+ if ((TWIG_ARRAY_KEY_EXISTS(object, item, item_len))
+ || (TWIG_INSTANCE_OF(object, zend_ce_arrayaccess TSRMLS_CC) && TWIG_ISSET_ARRAYOBJECT_ELEMENT(object, &zitem TSRMLS_CC))
+ ) {
+ zval *ret;
+
+ if (isDefinedTest) {
+ RETURN_TRUE;
+ }
+
+ ret = TWIG_GET_ARRAY_ELEMENT(object, item, item_len TSRMLS_CC);
+ RETVAL_ZVAL(ret, 1, 0);
+ if (free_ret) {
+ zval_ptr_dtor(&ret);
+ }
+ return;
+ }
+/*
+ if (Twig_TemplateInterface::ARRAY_CALL === $type) {
+ if ($isDefinedTest) {
+ return false;
+ }
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+*/
+ if (strcmp("array", type) == 0) {
+ if (isDefinedTest) {
+ RETURN_FALSE;
+ }
+ if (ignoreStrictCheck || !TWIG_CALL_BOOLEAN(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "isStrictVariables" TSRMLS_CC)) {
+ return;
+ }
+/*
+ if (is_object($object)) {
+ throw new Twig_Error_Runtime(sprintf('Key "%s" in object (with ArrayAccess) of type "%s" does not exist', $item, get_class($object)));
+ // array
+ } else {
+ throw new Twig_Error_Runtime(sprintf('Key "%s" for array with keys "%s" does not exist', $item, implode(', ', array_keys($object))));
+ }
+ }
+ }
+*/
+ if (Z_TYPE_P(object) == IS_OBJECT) {
+ TWIG_THROW_EXCEPTION("Twig_Error_Runtime" TSRMLS_CC, "Key \"%s\" in object (with ArrayAccess) of type \"%s\" does not exist", item, TWIG_GET_CLASS_NAME(object TSRMLS_CC));
+ } else {
+ TWIG_THROW_EXCEPTION("Twig_Error_Runtime" TSRMLS_CC, "Key \"%s\" for array with keys \"%s\" does not exist", item, TWIG_IMPLODE_ARRAY_KEYS(", ", object TSRMLS_CC));
+ }
+ return;
+ }
+ }
+
+/*
+ if (!is_object($object)) {
+ if ($isDefinedTest) {
+ return false;
+ }
+*/
+
+ if (Z_TYPE_P(object) != IS_OBJECT) {
+ if (isDefinedTest) {
+ RETURN_FALSE;
+ }
+/*
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+ throw new Twig_Error_Runtime(sprintf('Item "%s" for "%s" does not exist', $item, implode(', ', array_keys($object))));
+ }
+*/
+ if (ignoreStrictCheck || !TWIG_CALL_BOOLEAN(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "isStrictVariables" TSRMLS_CC)) {
+ RETURN_FALSE;
+ }
+ if (Z_TYPE_P(object) == IS_ARRAY) {
+ TWIG_THROW_EXCEPTION("Twig_Error_Runtime" TSRMLS_CC, "Item \"%s\" for \"Array\" does not exist", item);
+ } else {
+ Z_ADDREF_P(object);
+ convert_to_string_ex(&object);
+ TWIG_THROW_EXCEPTION("Twig_Error_Runtime" TSRMLS_CC, "Item \"%s\" for \"%s\" does not exist", item, Z_STRVAL_P(object));
+ zval_ptr_dtor(&object);
+ }
+ return;
+ }
+/*
+ // get some information about the object
+ $class = get_class($object);
+ if (!isset(self::$cache[$class])) {
+ $r = new ReflectionClass($class);
+ self::$cache[$class] = array('methods' => array(), 'properties' => array());
+ foreach ($r->getMethods(ReflectionMethod::IS_PUBLIC) as $method) {
+ self::$cache[$class]['methods'][strtolower($method->getName())] = true;
+ }
+
+ foreach ($r->getProperties(ReflectionProperty::IS_PUBLIC) as $property) {
+ self::$cache[$class]['properties'][$property->getName()] = true;
+ }
+ }
+*/
+ if (Z_TYPE_P(object) == IS_OBJECT) {
+ char *class_name = NULL;
+
+ class_name = TWIG_GET_CLASS_NAME(object TSRMLS_CC);
+ tmp_self_cache = TWIG_GET_STATIC_PROPERTY(template, "cache" TSRMLS_CC);
+
+ if (!TWIG_GET_ARRAY_ELEMENT(tmp_self_cache, class_name, strlen(class_name) TSRMLS_CC)) {
+ twig_add_class_to_cache(tmp_self_cache, object, class_name TSRMLS_CC);
+ }
+ efree(class_name);
+ }
+
+/*
+ // object property
+ if (Twig_TemplateInterface::METHOD_CALL !== $type) {
+ if (isset(self::$cache[$class]['properties'][$item])
+ || isset($object->$item) || array_key_exists($item, $object)
+ ) {
+ if ($isDefinedTest) {
+ return true;
+ }
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item);
+ }
+
+ return $object->$item;
+ }
+ }
+*/
+ if (strcmp("method", type) != 0) {
+ zval *tmp_class, *tmp_properties, *tmp_item;
+ char *class_name = NULL;
+
+ class_name = TWIG_GET_CLASS_NAME(object TSRMLS_CC);
+ tmp_class = TWIG_GET_ARRAY_ELEMENT(tmp_self_cache, class_name, strlen(class_name) TSRMLS_CC);
+ tmp_properties = TWIG_GET_ARRAY_ELEMENT(tmp_class, "properties", strlen("properties") TSRMLS_CC);
+ tmp_item = TWIG_GET_ARRAY_ELEMENT(tmp_properties, item, item_len TSRMLS_CC);
+
+ efree(class_name);
+
+ if (tmp_item || TWIG_HAS_PROPERTY(object, &zitem TSRMLS_CC) || TWIG_ARRAY_KEY_EXISTS(object, item, item_len) // FIXME: Array key? is that array access here?
+ ) {
+ if (isDefinedTest) {
+ RETURN_TRUE;
+ }
+ if (TWIG_CALL_SB(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "hasExtension", "sandbox" TSRMLS_CC)) {
+ TWIG_CALL_ZZ(TWIG_CALL_S(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "getExtension", "sandbox" TSRMLS_CC), "checkPropertyAllowed", object, &zitem TSRMLS_CC);
+ }
+ if (EG(exception)) {
+ return;
+ }
+
+ ret = TWIG_PROPERTY(object, &zitem TSRMLS_CC);
+ RETURN_ZVAL(ret, 1, 0);
+ }
+ }
+/*
+ // object method
+ $lcItem = strtolower($item);
+ if (isset(self::$cache[$class]['methods'][$lcItem])) {
+ $method = $item;
+ } elseif (isset(self::$cache[$class]['methods']['get'.$lcItem])) {
+ $method = 'get'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['is'.$lcItem])) {
+ $method = 'is'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['__call'])) {
+ $method = $item;
+*/
+ {
+ char *lcItem = TWIG_STRTOLOWER(item, item_len);
+ int lcItem_length;
+ char *method = NULL;
+ char *tmp_method_name_get;
+ char *tmp_method_name_is;
+ zval *tmp_class, *tmp_methods;
+ char *class_name = NULL;
+
+ class_name = TWIG_GET_CLASS_NAME(object TSRMLS_CC);
+ lcItem_length = strlen(lcItem);
+ tmp_method_name_get = emalloc(4 + lcItem_length);
+ tmp_method_name_is = emalloc(3 + lcItem_length);
+
+ sprintf(tmp_method_name_get, "get%s", lcItem);
+ sprintf(tmp_method_name_is, "is%s", lcItem);
+
+ tmp_class = TWIG_GET_ARRAY_ELEMENT(tmp_self_cache, class_name, strlen(class_name) TSRMLS_CC);
+ tmp_methods = TWIG_GET_ARRAY_ELEMENT(tmp_class, "methods", strlen("methods") TSRMLS_CC);
+ efree(class_name);
+
+ if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, lcItem, lcItem_length TSRMLS_CC)) {
+ method = item;
+ } else if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, tmp_method_name_get, lcItem_length + 3 TSRMLS_CC)) {
+ method = tmp_method_name_get;
+ } else if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, tmp_method_name_is, lcItem_length + 2 TSRMLS_CC)) {
+ method = tmp_method_name_is;
+ } else if (TWIG_GET_ARRAY_ELEMENT(tmp_methods, "__call", 6 TSRMLS_CC)) {
+ method = item;
+/*
+ } else {
+ if ($isDefinedTest) {
+ return false;
+ }
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+ throw new Twig_Error_Runtime(sprintf('Method "%s" for object "%s" does not exist', $item, get_class($object)));
+ }
+ if ($isDefinedTest) {
+ return true;
+ }
+*/
+ } else {
+ if (isDefinedTest) {
+ RETURN_FALSE;
+ }
+ if (ignoreStrictCheck || !TWIG_CALL_BOOLEAN(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "isStrictVariables" TSRMLS_CC)) {
+ return;
+ }
+ TWIG_THROW_EXCEPTION("Twig_Error_Runtime" TSRMLS_CC, "Method \"%s\" for object \"%s\" does not exist", item, TWIG_GET_CLASS_NAME(object TSRMLS_CC));
+ return;
+ }
+ if (isDefinedTest) {
+ efree(tmp_method_name_get);
+ efree(tmp_method_name_is);
+ efree(lcItem);
+ RETURN_TRUE;
+ }
+/*
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkMethodAllowed($object, $method);
+ }
+*/
+ if (TWIG_CALL_SB(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "hasExtension", "sandbox" TSRMLS_CC)) {
+ TWIG_CALL_ZZ(TWIG_CALL_S(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "getExtension", "sandbox" TSRMLS_CC), "checkMethodAllowed", object, &zitem TSRMLS_CC);
+ }
+ if (EG(exception)) {
+ return;
+ }
+/*
+ $ret = call_user_func_array(array($object, $method), $arguments);
+*/
+ if (Z_TYPE_P(object) == IS_OBJECT) {
+ ret = TWIG_CALL_USER_FUNC_ARRAY(object, method, arguments TSRMLS_CC);
+ free_ret = 1;
+ }
+ efree(tmp_method_name_get);
+ efree(tmp_method_name_is);
+ efree(lcItem);
+ }
+/*
+ if ($object instanceof Twig_TemplateInterface) {
+ return new Twig_Markup($ret, $this->env->getCharset());
+ }
+*/
+ if (TWIG_INSTANCE_OF_USERLAND(object, "Twig_TemplateInterface" TSRMLS_CC)) {
+ zval *charset = TWIG_CALL_USER_FUNC_ARRAY(TWIG_PROPERTY_CHAR(template, "env" TSRMLS_CC), "getCharset", NULL TSRMLS_CC);
+ TWIG_NEW(return_value, "Twig_Markup", ret, charset TSRMLS_CC);
+ zval_ptr_dtor(&charset);
+ if (ret) {
+ zval_ptr_dtor(&ret);
+ }
+ return;
+ }
+/*
+ return $ret;
+*/
+ if (ret) {
+ RETVAL_ZVAL(ret, 1, 0);
+ if (free_ret) {
+ zval_ptr_dtor(&ret);
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Autoloader.php b/lib/twig/lib/Twig/Autoloader.php
new file mode 100755
index 0000000..a93b8ca
--- /dev/null
+++ b/lib/twig/lib/Twig/Autoloader.php
@@ -0,0 +1,46 @@
+
+ */
+class Twig_Autoloader
+{
+ /**
+ * Registers Twig_Autoloader as an SPL autoloader.
+ */
+ static public function register()
+ {
+ ini_set('unserialize_callback_func', 'spl_autoload_call');
+ spl_autoload_register(array(new self, 'autoload'));
+ }
+
+ /**
+ * Handles autoloading of classes.
+ *
+ * @param string $class A class name.
+ *
+ * @return boolean Returns true if the class has been loaded
+ */
+ static public function autoload($class)
+ {
+ if (0 !== strpos($class, 'Twig')) {
+ return;
+ }
+
+ if (is_file($file = dirname(__FILE__).'/../'.str_replace(array('_', "\0"), array('/', ''), $class).'.php')) {
+ require $file;
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Compiler.php b/lib/twig/lib/Twig/Compiler.php
new file mode 100755
index 0000000..ae415a2
--- /dev/null
+++ b/lib/twig/lib/Twig/Compiler.php
@@ -0,0 +1,242 @@
+
+ */
+class Twig_Compiler implements Twig_CompilerInterface
+{
+ protected $lastLine;
+ protected $source;
+ protected $indentation;
+ protected $env;
+ protected $debugInfo;
+ protected $sourceOffset;
+ protected $sourceLine;
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env The twig environment instance
+ */
+ public function __construct(Twig_Environment $env)
+ {
+ $this->env = $env;
+ $this->debugInfo = array();
+ }
+
+ /**
+ * Returns the environment instance related to this compiler.
+ *
+ * @return Twig_Environment The environment instance
+ */
+ public function getEnvironment()
+ {
+ return $this->env;
+ }
+
+ /**
+ * Gets the current PHP code after compilation.
+ *
+ * @return string The PHP code
+ */
+ public function getSource()
+ {
+ return $this->source;
+ }
+
+ /**
+ * Compiles a node.
+ *
+ * @param Twig_NodeInterface $node The node to compile
+ * @param integer $indentation The current indentation
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function compile(Twig_NodeInterface $node, $indentation = 0)
+ {
+ $this->lastLine = null;
+ $this->source = '';
+ $this->sourceOffset = 0;
+ $this->sourceLine = 0;
+ $this->indentation = $indentation;
+
+ $node->compile($this);
+
+ return $this;
+ }
+
+ public function subcompile(Twig_NodeInterface $node, $raw = true)
+ {
+ if (false === $raw) {
+ $this->addIndentation();
+ }
+
+ $node->compile($this);
+
+ return $this;
+ }
+
+ /**
+ * Adds a raw string to the compiled code.
+ *
+ * @param string $string The string
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function raw($string)
+ {
+ $this->source .= $string;
+
+ return $this;
+ }
+
+ /**
+ * Writes a string to the compiled code by adding indentation.
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function write()
+ {
+ $strings = func_get_args();
+ foreach ($strings as $string) {
+ $this->addIndentation();
+ $this->source .= $string;
+ }
+
+ return $this;
+ }
+
+ public function addIndentation()
+ {
+ $this->source .= str_repeat(' ', $this->indentation * 4);
+
+ return $this;
+ }
+
+ /**
+ * Adds a quoted string to the compiled code.
+ *
+ * @param string $value The string
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function string($value)
+ {
+ $this->source .= sprintf('"%s"', addcslashes($value, "\0\t\"\$\\"));
+
+ return $this;
+ }
+
+ /**
+ * Returns a PHP representation of a given value.
+ *
+ * @param mixed $value The value to convert
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function repr($value)
+ {
+ if (is_int($value) || is_float($value)) {
+ if (false !== $locale = setlocale(LC_NUMERIC, 0)) {
+ setlocale(LC_NUMERIC, 'C');
+ }
+
+ $this->raw($value);
+
+ if (false !== $locale) {
+ setlocale(LC_NUMERIC, $locale);
+ }
+ } elseif (null === $value) {
+ $this->raw('null');
+ } elseif (is_bool($value)) {
+ $this->raw($value ? 'true' : 'false');
+ } elseif (is_array($value)) {
+ $this->raw('array(');
+ $i = 0;
+ foreach ($value as $key => $value) {
+ if ($i++) {
+ $this->raw(', ');
+ }
+ $this->repr($key);
+ $this->raw(' => ');
+ $this->repr($value);
+ }
+ $this->raw(')');
+ } else {
+ $this->string($value);
+ }
+
+ return $this;
+ }
+
+ /**
+ * Adds debugging information.
+ *
+ * @param Twig_NodeInterface $node The related twig node
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function addDebugInfo(Twig_NodeInterface $node)
+ {
+ if ($node->getLine() != $this->lastLine) {
+ $this->sourceLine += substr_count($this->source, "\n", $this->sourceOffset);
+ $this->sourceOffset = strlen($this->source);
+ $this->debugInfo[$this->sourceLine] = $node->getLine();
+
+ $this->lastLine = $node->getLine();
+ $this->write("// line {$node->getLine()}\n");
+ }
+
+ return $this;
+ }
+
+ public function getDebugInfo()
+ {
+ return $this->debugInfo;
+ }
+
+ /**
+ * Indents the generated code.
+ *
+ * @param integer $step The number of indentation to add
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function indent($step = 1)
+ {
+ $this->indentation += $step;
+
+ return $this;
+ }
+
+ /**
+ * Outdents the generated code.
+ *
+ * @param integer $step The number of indentation to remove
+ *
+ * @return Twig_Compiler The current compiler instance
+ */
+ public function outdent($step = 1)
+ {
+ $this->indentation -= $step;
+
+ if ($this->indentation < 0) {
+ throw new Twig_Error('Unable to call outdent() as the indentation would become negative');
+ }
+
+ return $this;
+ }
+}
diff --git a/lib/twig/lib/Twig/CompilerInterface.php b/lib/twig/lib/Twig/CompilerInterface.php
new file mode 100755
index 0000000..0a13edf
--- /dev/null
+++ b/lib/twig/lib/Twig/CompilerInterface.php
@@ -0,0 +1,35 @@
+
+ */
+interface Twig_CompilerInterface
+{
+ /**
+ * Compiles a node.
+ *
+ * @param Twig_NodeInterface $node The node to compile
+ *
+ * @return Twig_CompilerInterface The current compiler instance
+ */
+ function compile(Twig_NodeInterface $node);
+
+ /**
+ * Gets the current PHP code after compilation.
+ *
+ * @return string The PHP code
+ */
+ function getSource();
+}
diff --git a/lib/twig/lib/Twig/Environment.php b/lib/twig/lib/Twig/Environment.php
new file mode 100755
index 0000000..596c867
--- /dev/null
+++ b/lib/twig/lib/Twig/Environment.php
@@ -0,0 +1,1060 @@
+
+ */
+class Twig_Environment
+{
+ const VERSION = '1.6.4';
+
+ protected $charset;
+ protected $loader;
+ protected $debug;
+ protected $autoReload;
+ protected $cache;
+ protected $lexer;
+ protected $parser;
+ protected $compiler;
+ protected $baseTemplateClass;
+ protected $extensions;
+ protected $parsers;
+ protected $visitors;
+ protected $filters;
+ protected $tests;
+ protected $functions;
+ protected $globals;
+ protected $runtimeInitialized;
+ protected $loadedTemplates;
+ protected $strictVariables;
+ protected $unaryOperators;
+ protected $binaryOperators;
+ protected $templateClassPrefix = '__TwigTemplate_';
+ protected $functionCallbacks;
+ protected $filterCallbacks;
+ protected $staging;
+
+ /**
+ * Constructor.
+ *
+ * Available options:
+ *
+ * * 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 compilation cache (default)
+ *
+ * * auto_reload: Whether to reload the template is the original source changed.
+ * If you don't provide the auto_reload option, it will be
+ * determined automatically base on the debug value.
+ *
+ * * strict_variables: Whether to ignore invalid variables in templates
+ * (default to false).
+ *
+ * * autoescape: Whether to enable auto-escaping (default to true);
+ *
+ * * optimizations: A flag that indicates which optimizations to apply
+ * (default to -1 which means that all optimizations are enabled;
+ * set it to 0 to disable)
+ *
+ * @param Twig_LoaderInterface $loader A Twig_LoaderInterface instance
+ * @param array $options An array of options
+ */
+ public function __construct(Twig_LoaderInterface $loader = null, $options = array())
+ {
+ if (null !== $loader) {
+ $this->setLoader($loader);
+ }
+
+ $options = array_merge(array(
+ 'debug' => false,
+ 'charset' => 'UTF-8',
+ 'base_template_class' => 'Twig_Template',
+ 'strict_variables' => false,
+ 'autoescape' => true,
+ 'cache' => false,
+ 'auto_reload' => null,
+ 'optimizations' => -1,
+ ), $options);
+
+ $this->debug = (bool) $options['debug'];
+ $this->charset = $options['charset'];
+ $this->baseTemplateClass = $options['base_template_class'];
+ $this->autoReload = null === $options['auto_reload'] ? $this->debug : (bool) $options['auto_reload'];
+ $this->extensions = array(
+ 'core' => new Twig_Extension_Core(),
+ 'escaper' => new Twig_Extension_Escaper((bool) $options['autoescape']),
+ 'optimizer' => new Twig_Extension_Optimizer($options['optimizations']),
+ );
+ $this->strictVariables = (bool) $options['strict_variables'];
+ $this->runtimeInitialized = false;
+ $this->setCache($options['cache']);
+ $this->functionCallbacks = array();
+ $this->filterCallbacks = array();
+ }
+
+ /**
+ * Gets the base template class for compiled templates.
+ *
+ * @return string The base template class name
+ */
+ public function getBaseTemplateClass()
+ {
+ return $this->baseTemplateClass;
+ }
+
+ /**
+ * Sets the base template class for compiled templates.
+ *
+ * @param string $class The base template class name
+ */
+ public function setBaseTemplateClass($class)
+ {
+ $this->baseTemplateClass = $class;
+ }
+
+ /**
+ * Enables debugging mode.
+ */
+ public function enableDebug()
+ {
+ $this->debug = true;
+ }
+
+ /**
+ * Disables debugging mode.
+ */
+ public function disableDebug()
+ {
+ $this->debug = false;
+ }
+
+ /**
+ * Checks if debug mode is enabled.
+ *
+ * @return Boolean true if debug mode is enabled, false otherwise
+ */
+ public function isDebug()
+ {
+ return $this->debug;
+ }
+
+ /**
+ * Enables the auto_reload option.
+ */
+ public function enableAutoReload()
+ {
+ $this->autoReload = true;
+ }
+
+ /**
+ * Disables the auto_reload option.
+ */
+ public function disableAutoReload()
+ {
+ $this->autoReload = false;
+ }
+
+ /**
+ * Checks if the auto_reload option is enabled.
+ *
+ * @return Boolean true if auto_reload is enabled, false otherwise
+ */
+ public function isAutoReload()
+ {
+ return $this->autoReload;
+ }
+
+ /**
+ * Enables the strict_variables option.
+ */
+ public function enableStrictVariables()
+ {
+ $this->strictVariables = true;
+ }
+
+ /**
+ * Disables the strict_variables option.
+ */
+ public function disableStrictVariables()
+ {
+ $this->strictVariables = false;
+ }
+
+ /**
+ * Checks if the strict_variables option is enabled.
+ *
+ * @return Boolean true if strict_variables is enabled, false otherwise
+ */
+ public function isStrictVariables()
+ {
+ return $this->strictVariables;
+ }
+
+ /**
+ * Gets the cache directory or false if cache is disabled.
+ *
+ * @return string|false
+ */
+ public function getCache()
+ {
+ return $this->cache;
+ }
+
+ /**
+ * Sets the cache directory or false if cache is disabled.
+ *
+ * @param string|false $cache The absolute path to the compiled templates,
+ * or false to disable cache
+ */
+ public function setCache($cache)
+ {
+ $this->cache = $cache ? $cache : false;
+ }
+
+ /**
+ * Gets the cache filename for a given template.
+ *
+ * @param string $name The template name
+ *
+ * @return string The cache file name
+ */
+ public function getCacheFilename($name)
+ {
+ if (false === $this->cache) {
+ return false;
+ }
+
+ $class = substr($this->getTemplateClass($name), strlen($this->templateClassPrefix));
+
+ return $this->getCache().'/'.substr($class, 0, 2).'/'.substr($class, 2, 2).'/'.substr($class, 4).'.php';
+ }
+
+ /**
+ * Gets the template class associated with the given string.
+ *
+ * @param string $name The name for which to calculate the template class name
+ *
+ * @return string The template class name
+ */
+ public function getTemplateClass($name)
+ {
+ return $this->templateClassPrefix.md5($this->loader->getCacheKey($name));
+ }
+
+ /**
+ * Gets the template class prefix.
+ *
+ * @return string The template class prefix
+ */
+ public function getTemplateClassPrefix()
+ {
+ return $this->templateClassPrefix;
+ }
+
+ /**
+ * Renders a template.
+ *
+ * @param string $name The template name
+ * @param array $context An array of parameters to pass to the template
+ *
+ * @return string The rendered template
+ */
+ public function render($name, array $context = array())
+ {
+ return $this->loadTemplate($name)->render($context);
+ }
+
+ /**
+ * Displays a template.
+ *
+ * @param string $name The template name
+ * @param array $context An array of parameters to pass to the template
+ */
+ public function display($name, array $context = array())
+ {
+ $this->loadTemplate($name)->display($context);
+ }
+
+ /**
+ * Loads a template by name.
+ *
+ * @param string $name The template name
+ *
+ * @return Twig_TemplateInterface A template instance representing the given template name
+ */
+ public function loadTemplate($name)
+ {
+ $cls = $this->getTemplateClass($name);
+
+ if (isset($this->loadedTemplates[$cls])) {
+ return $this->loadedTemplates[$cls];
+ }
+
+ if (!class_exists($cls, false)) {
+ if (false === $cache = $this->getCacheFilename($name)) {
+ eval('?>'.$this->compileSource($this->loader->getSource($name), $name));
+ } else {
+ if (!is_file($cache) || ($this->isAutoReload() && !$this->isTemplateFresh($name, filemtime($cache)))) {
+ $this->writeCacheFile($cache, $this->compileSource($this->loader->getSource($name), $name));
+ }
+
+ require_once $cache;
+ }
+ }
+
+ if (!$this->runtimeInitialized) {
+ $this->initRuntime();
+ }
+
+ return $this->loadedTemplates[$cls] = new $cls($this);
+ }
+
+ /**
+ * Returns true if the template is still fresh.
+ *
+ * Besides checking the loader for freshness information,
+ * this method also checks if the enabled extensions have
+ * not changed.
+ *
+ * @param string $name The template name
+ * @param timestamp $time The last modification time of the cached template
+ *
+ * @return Boolean true if the template is fresh, false otherwise
+ */
+ public function isTemplateFresh($name, $time)
+ {
+ foreach ($this->extensions as $extension) {
+ $r = new ReflectionObject($extension);
+ if (filemtime($r->getFileName()) > $time) {
+ return false;
+ }
+ }
+
+ return $this->loader->isFresh($name, $time);
+ }
+
+ public function resolveTemplate($names)
+ {
+ if (!is_array($names)) {
+ $names = array($names);
+ }
+
+ foreach ($names as $name) {
+ if ($name instanceof Twig_Template) {
+ return $name;
+ }
+
+ try {
+ return $this->loadTemplate($name);
+ } catch (Twig_Error_Loader $e) {
+ }
+ }
+
+ if (1 === count($names)) {
+ throw $e;
+ }
+
+ throw new Twig_Error_Loader(sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
+ }
+
+ /**
+ * Clears the internal template cache.
+ */
+ public function clearTemplateCache()
+ {
+ $this->loadedTemplates = array();
+ }
+
+ /**
+ * Clears the template cache files on the filesystem.
+ */
+ public function clearCacheFiles()
+ {
+ if (false === $this->cache) {
+ return;
+ }
+
+ foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->cache), RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
+ if ($file->isFile()) {
+ @unlink($file->getPathname());
+ }
+ }
+ }
+
+ /**
+ * Gets the Lexer instance.
+ *
+ * @return Twig_LexerInterface A Twig_LexerInterface instance
+ */
+ public function getLexer()
+ {
+ if (null === $this->lexer) {
+ $this->lexer = new Twig_Lexer($this);
+ }
+
+ return $this->lexer;
+ }
+
+ /**
+ * Sets the Lexer instance.
+ *
+ * @param Twig_LexerInterface A Twig_LexerInterface instance
+ */
+ public function setLexer(Twig_LexerInterface $lexer)
+ {
+ $this->lexer = $lexer;
+ }
+
+ /**
+ * Tokenizes a source code.
+ *
+ * @param string $source The template source code
+ * @param string $name The template name
+ *
+ * @return Twig_TokenStream A Twig_TokenStream instance
+ */
+ public function tokenize($source, $name = null)
+ {
+ return $this->getLexer()->tokenize($source, $name);
+ }
+
+ /**
+ * Gets the Parser instance.
+ *
+ * @return Twig_ParserInterface A Twig_ParserInterface instance
+ */
+ public function getParser()
+ {
+ if (null === $this->parser) {
+ $this->parser = new Twig_Parser($this);
+ }
+
+ return $this->parser;
+ }
+
+ /**
+ * Sets the Parser instance.
+ *
+ * @param Twig_ParserInterface A Twig_ParserInterface instance
+ */
+ public function setParser(Twig_ParserInterface $parser)
+ {
+ $this->parser = $parser;
+ }
+
+ /**
+ * Parses a token stream.
+ *
+ * @param Twig_TokenStream $tokens A Twig_TokenStream instance
+ *
+ * @return Twig_Node_Module A Node tree
+ */
+ public function parse(Twig_TokenStream $tokens)
+ {
+ return $this->getParser()->parse($tokens);
+ }
+
+ /**
+ * Gets the Compiler instance.
+ *
+ * @return Twig_CompilerInterface A Twig_CompilerInterface instance
+ */
+ public function getCompiler()
+ {
+ if (null === $this->compiler) {
+ $this->compiler = new Twig_Compiler($this);
+ }
+
+ return $this->compiler;
+ }
+
+ /**
+ * Sets the Compiler instance.
+ *
+ * @param Twig_CompilerInterface $compiler A Twig_CompilerInterface instance
+ */
+ public function setCompiler(Twig_CompilerInterface $compiler)
+ {
+ $this->compiler = $compiler;
+ }
+
+ /**
+ * Compiles a Node.
+ *
+ * @param Twig_NodeInterface $node A Twig_NodeInterface instance
+ *
+ * @return string The compiled PHP source code
+ */
+ public function compile(Twig_NodeInterface $node)
+ {
+ return $this->getCompiler()->compile($node)->getSource();
+ }
+
+ /**
+ * Compiles a template source code.
+ *
+ * @param string $source The template source code
+ * @param string $name The template name
+ *
+ * @return string The compiled PHP source code
+ */
+ public function compileSource($source, $name = null)
+ {
+ try {
+ return $this->compile($this->parse($this->tokenize($source, $name)));
+ } catch (Twig_Error $e) {
+ $e->setTemplateFile($name);
+ throw $e;
+ } catch (Exception $e) {
+ throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $name, $e);
+ }
+ }
+
+ /**
+ * Sets the Loader instance.
+ *
+ * @param Twig_LoaderInterface $loader A Twig_LoaderInterface instance
+ */
+ public function setLoader(Twig_LoaderInterface $loader)
+ {
+ $this->loader = $loader;
+ }
+
+ /**
+ * Gets the Loader instance.
+ *
+ * @return Twig_LoaderInterface A Twig_LoaderInterface instance
+ */
+ public function getLoader()
+ {
+ return $this->loader;
+ }
+
+ /**
+ * Sets the default template charset.
+ *
+ * @param string $charset The default charset
+ */
+ public function setCharset($charset)
+ {
+ $this->charset = $charset;
+ }
+
+ /**
+ * Gets the default template charset.
+ *
+ * @return string The default charset
+ */
+ public function getCharset()
+ {
+ return $this->charset;
+ }
+
+ /**
+ * Initializes the runtime environment.
+ */
+ public function initRuntime()
+ {
+ $this->runtimeInitialized = true;
+
+ foreach ($this->getExtensions() as $extension) {
+ $extension->initRuntime($this);
+ }
+ }
+
+ /**
+ * Returns true if the given extension is registered.
+ *
+ * @param string $name The extension name
+ *
+ * @return Boolean Whether the extension is registered or not
+ */
+ public function hasExtension($name)
+ {
+ return isset($this->extensions[$name]);
+ }
+
+ /**
+ * Gets an extension by name.
+ *
+ * @param string $name The extension name
+ *
+ * @return Twig_ExtensionInterface A Twig_ExtensionInterface instance
+ */
+ public function getExtension($name)
+ {
+ if (!isset($this->extensions[$name])) {
+ throw new Twig_Error_Runtime(sprintf('The "%s" extension is not enabled.', $name));
+ }
+
+ return $this->extensions[$name];
+ }
+
+ /**
+ * Registers an extension.
+ *
+ * @param Twig_ExtensionInterface $extension A Twig_ExtensionInterface instance
+ */
+ public function addExtension(Twig_ExtensionInterface $extension)
+ {
+ $this->extensions[$extension->getName()] = $extension;
+ $this->parsers = null;
+ $this->visitors = null;
+ $this->filters = null;
+ $this->tests = null;
+ $this->functions = null;
+ $this->globals = null;
+ }
+
+ /**
+ * Removes an extension by name.
+ *
+ * @param string $name The extension name
+ */
+ public function removeExtension($name)
+ {
+ unset($this->extensions[$name]);
+ $this->parsers = null;
+ $this->visitors = null;
+ $this->filters = null;
+ $this->tests = null;
+ $this->functions = null;
+ $this->globals = null;
+ }
+
+ /**
+ * Registers an array of extensions.
+ *
+ * @param array $extensions An array of extensions
+ */
+ public function setExtensions(array $extensions)
+ {
+ foreach ($extensions as $extension) {
+ $this->addExtension($extension);
+ }
+ }
+
+ /**
+ * Returns all registered extensions.
+ *
+ * @return array An array of extensions
+ */
+ public function getExtensions()
+ {
+ return $this->extensions;
+ }
+
+ /**
+ * Registers a Token Parser.
+ *
+ * @param Twig_TokenParserInterface $parser A Twig_TokenParserInterface instance
+ */
+ public function addTokenParser(Twig_TokenParserInterface $parser)
+ {
+ $this->staging['token_parsers'][] = $parser;
+ $this->parsers = null;
+ }
+
+ /**
+ * Gets the registered Token Parsers.
+ *
+ * @return Twig_TokenParserBrokerInterface A broker containing token parsers
+ */
+ public function getTokenParsers()
+ {
+ if (null === $this->parsers) {
+ $this->parsers = new Twig_TokenParserBroker();
+
+ if (isset($this->staging['token_parsers'])) {
+ foreach ($this->staging['token_parsers'] as $parser) {
+ $this->parsers->addTokenParser($parser);
+ }
+ }
+
+ foreach ($this->getExtensions() as $extension) {
+ $parsers = $extension->getTokenParsers();
+ foreach($parsers as $parser) {
+ if ($parser instanceof Twig_TokenParserInterface) {
+ $this->parsers->addTokenParser($parser);
+ } elseif ($parser instanceof Twig_TokenParserBrokerInterface) {
+ $this->parsers->addTokenParserBroker($parser);
+ } else {
+ throw new Twig_Error_Runtime('getTokenParsers() must return an array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances');
+ }
+ }
+ }
+ }
+
+ return $this->parsers;
+ }
+
+ /**
+ * Gets registered tags.
+ *
+ * Be warned that this method cannot return tags defined by Twig_TokenParserBrokerInterface classes.
+ *
+ * @return Twig_TokenParserInterface[] An array of Twig_TokenParserInterface instances
+ */
+ public function getTags()
+ {
+ $tags = array();
+ foreach ($this->getTokenParsers()->getParsers() as $parser) {
+ if ($parser instanceof Twig_TokenParserInterface) {
+ $tags[$parser->getTag()] = $parser;
+ }
+ }
+
+ return $tags;
+ }
+
+ /**
+ * Registers a Node Visitor.
+ *
+ * @param Twig_NodeVisitorInterface $visitor A Twig_NodeVisitorInterface instance
+ */
+ public function addNodeVisitor(Twig_NodeVisitorInterface $visitor)
+ {
+ $this->staging['visitors'][] = $visitor;
+ $this->visitors = null;
+ }
+
+ /**
+ * Gets the registered Node Visitors.
+ *
+ * @return Twig_NodeVisitorInterface[] An array of Twig_NodeVisitorInterface instances
+ */
+ public function getNodeVisitors()
+ {
+ if (null === $this->visitors) {
+ $this->visitors = isset($this->staging['visitors']) ? $this->staging['visitors'] : array();
+ foreach ($this->getExtensions() as $extension) {
+ $this->visitors = array_merge($this->visitors, $extension->getNodeVisitors());
+ }
+ }
+
+ return $this->visitors;
+ }
+
+ /**
+ * Registers a Filter.
+ *
+ * @param string $name The filter name
+ * @param Twig_FilterInterface $filter A Twig_FilterInterface instance
+ */
+ public function addFilter($name, Twig_FilterInterface $filter)
+ {
+ $this->staging['filters'][$name] = $filter;
+ $this->filters = null;
+ }
+
+ /**
+ * Get a filter by name.
+ *
+ * Subclasses may override this method and load filters differently;
+ * so no list of filters is available.
+ *
+ * @param string $name The filter name
+ *
+ * @return Twig_Filter|false A Twig_Filter instance or false if the filter does not exists
+ */
+ public function getFilter($name)
+ {
+ if (null === $this->filters) {
+ $this->getFilters();
+ }
+
+ if (isset($this->filters[$name])) {
+ return $this->filters[$name];
+ }
+
+ foreach ($this->filters as $pattern => $filter) {
+ $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
+
+ if ($count) {
+ if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
+ array_shift($matches);
+ $filter->setArguments($matches);
+
+ return $filter;
+ }
+ }
+ }
+
+ foreach ($this->filterCallbacks as $callback) {
+ if (false !== $filter = call_user_func($callback, $name)) {
+ return $filter;
+ }
+ }
+
+ return false;
+ }
+
+ public function registerUndefinedFilterCallback($callable)
+ {
+ $this->filterCallbacks[] = $callable;
+ }
+
+ /**
+ * Gets the registered Filters.
+ *
+ * Be warned that this method cannot return filters defined with registerUndefinedFunctionCallback.
+ *
+ * @return Twig_FilterInterface[] An array of Twig_FilterInterface instances
+ *
+ * @see registerUndefinedFilterCallback
+ */
+ public function getFilters()
+ {
+ if (null === $this->filters) {
+ $this->filters = isset($this->staging['filters']) ? $this->staging['filters'] : array();
+ foreach ($this->getExtensions() as $extension) {
+ $this->filters = array_merge($this->filters, $extension->getFilters());
+ }
+ }
+
+ return $this->filters;
+ }
+
+ /**
+ * Registers a Test.
+ *
+ * @param string $name The test name
+ * @param Twig_TestInterface $test A Twig_TestInterface instance
+ */
+ public function addTest($name, Twig_TestInterface $test)
+ {
+ $this->staging['tests'][$name] = $test;
+ $this->tests = null;
+ }
+
+ /**
+ * Gets the registered Tests.
+ *
+ * @return Twig_TestInterface[] An array of Twig_TestInterface instances
+ */
+ public function getTests()
+ {
+ if (null === $this->tests) {
+ $this->tests = isset($this->staging['tests']) ? $this->staging['tests'] : array();
+ foreach ($this->getExtensions() as $extension) {
+ $this->tests = array_merge($this->tests, $extension->getTests());
+ }
+ }
+
+ return $this->tests;
+ }
+
+ /**
+ * Registers a Function.
+ *
+ * @param string $name The function name
+ * @param Twig_FunctionInterface $function A Twig_FunctionInterface instance
+ */
+ public function addFunction($name, Twig_FunctionInterface $function)
+ {
+ $this->staging['functions'][$name] = $function;
+ $this->functions = null;
+ }
+
+ /**
+ * Get a function by name.
+ *
+ * Subclasses may override this method and load functions differently;
+ * so no list of functions is available.
+ *
+ * @param string $name function name
+ *
+ * @return Twig_Function|false A Twig_Function instance or false if the function does not exists
+ */
+ public function getFunction($name)
+ {
+ if (null === $this->functions) {
+ $this->getFunctions();
+ }
+
+ if (isset($this->functions[$name])) {
+ return $this->functions[$name];
+ }
+
+ foreach ($this->functions as $pattern => $function) {
+ $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);
+
+ if ($count) {
+ if (preg_match('#^'.$pattern.'$#', $name, $matches)) {
+ array_shift($matches);
+ $function->setArguments($matches);
+
+ return $function;
+ }
+ }
+ }
+
+ foreach ($this->functionCallbacks as $callback) {
+ if (false !== $function = call_user_func($callback, $name)) {
+ return $function;
+ }
+ }
+
+ return false;
+ }
+
+ public function registerUndefinedFunctionCallback($callable)
+ {
+ $this->functionCallbacks[] = $callable;
+ }
+
+ /**
+ * Gets registered functions.
+ *
+ * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
+ *
+ * @return Twig_FunctionInterface[] An array of Twig_FunctionInterface instances
+ *
+ * @see registerUndefinedFunctionCallback
+ */
+ public function getFunctions()
+ {
+ if (null === $this->functions) {
+ $this->functions = isset($this->staging['functions']) ? $this->staging['functions'] : array();
+ foreach ($this->getExtensions() as $extension) {
+ $this->functions = array_merge($this->functions, $extension->getFunctions());
+ }
+ }
+
+ return $this->functions;
+ }
+
+ /**
+ * Registers a Global.
+ *
+ * @param string $name The global name
+ * @param mixed $value The global value
+ */
+ public function addGlobal($name, $value)
+ {
+ $this->staging['globals'][$name] = $value;
+ $this->globals = null;
+ }
+
+ /**
+ * Gets the registered Globals.
+ *
+ * @return array An array of globals
+ */
+ public function getGlobals()
+ {
+ if (null === $this->globals) {
+ $this->globals = isset($this->staging['globals']) ? $this->staging['globals'] : array();
+ foreach ($this->getExtensions() as $extension) {
+ $this->globals = array_merge($this->globals, $extension->getGlobals());
+ }
+ }
+
+ return $this->globals;
+ }
+
+ /**
+ * Gets the registered unary Operators.
+ *
+ * @return array An array of unary operators
+ */
+ public function getUnaryOperators()
+ {
+ if (null === $this->unaryOperators) {
+ $this->initOperators();
+ }
+
+ return $this->unaryOperators;
+ }
+
+ /**
+ * Gets the registered binary Operators.
+ *
+ * @return array An array of binary operators
+ */
+ public function getBinaryOperators()
+ {
+ if (null === $this->binaryOperators) {
+ $this->initOperators();
+ }
+
+ return $this->binaryOperators;
+ }
+
+ public function computeAlternatives($name, $items)
+ {
+ $alternatives = array();
+ foreach ($items as $item) {
+ $lev = levenshtein($name, $item);
+ if ($lev <= strlen($name) / 3 || false !== strpos($item, $name)) {
+ $alternatives[$item] = $lev;
+ }
+ }
+ asort($alternatives);
+
+ return array_keys($alternatives);
+ }
+
+ protected function initOperators()
+ {
+ $this->unaryOperators = array();
+ $this->binaryOperators = array();
+ foreach ($this->getExtensions() as $extension) {
+ $operators = $extension->getOperators();
+
+ if (!$operators) {
+ continue;
+ }
+
+ if (2 !== count($operators)) {
+ throw new InvalidArgumentException(sprintf('"%s::getOperators()" does not return a valid operators array.', get_class($extension)));
+ }
+
+ $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
+ $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
+ }
+ }
+
+ protected function writeCacheFile($file, $content)
+ {
+ $dir = dirname($file);
+ if (!is_dir($dir)) {
+ if (false === @mkdir($dir, 0777, true) && !is_dir($dir)) {
+ throw new RuntimeException(sprintf("Unable to create the cache directory (%s).", $dir));
+ }
+ } elseif (!is_writable($dir)) {
+ throw new RuntimeException(sprintf("Unable to write in the cache directory (%s).", $dir));
+ }
+
+ $tmpFile = tempnam(dirname($file), basename($file));
+ if (false !== @file_put_contents($tmpFile, $content)) {
+ // rename does not work on Win32 before 5.2.6
+ if (@rename($tmpFile, $file) || (@copy($tmpFile, $file) && unlink($tmpFile))) {
+ chmod($file, 0644);
+
+ return;
+ }
+ }
+
+ throw new Twig_Error_Runtime(sprintf('Failed to write cache file "%s".', $file));
+ }
+}
diff --git a/lib/twig/lib/Twig/Error.php b/lib/twig/lib/Twig/Error.php
new file mode 100755
index 0000000..b945706
--- /dev/null
+++ b/lib/twig/lib/Twig/Error.php
@@ -0,0 +1,176 @@
+
+ */
+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;
+ }
+}
diff --git a/lib/twig/lib/Twig/Error/Loader.php b/lib/twig/lib/Twig/Error/Loader.php
new file mode 100755
index 0000000..418a776
--- /dev/null
+++ b/lib/twig/lib/Twig/Error/Loader.php
@@ -0,0 +1,20 @@
+
+ */
+class Twig_Error_Loader extends Twig_Error
+{
+}
diff --git a/lib/twig/lib/Twig/Error/Runtime.php b/lib/twig/lib/Twig/Error/Runtime.php
new file mode 100755
index 0000000..8a387fa
--- /dev/null
+++ b/lib/twig/lib/Twig/Error/Runtime.php
@@ -0,0 +1,21 @@
+
+ */
+class Twig_Error_Runtime extends Twig_Error
+{
+}
diff --git a/lib/twig/lib/Twig/Error/Syntax.php b/lib/twig/lib/Twig/Error/Syntax.php
new file mode 100755
index 0000000..a2650c3
--- /dev/null
+++ b/lib/twig/lib/Twig/Error/Syntax.php
@@ -0,0 +1,21 @@
+
+ */
+class Twig_Error_Syntax extends Twig_Error
+{
+}
diff --git a/lib/twig/lib/Twig/ExpressionParser.php b/lib/twig/lib/Twig/ExpressionParser.php
new file mode 100755
index 0000000..0f35930
--- /dev/null
+++ b/lib/twig/lib/Twig/ExpressionParser.php
@@ -0,0 +1,488 @@
+
+ */
+class Twig_ExpressionParser
+{
+ const OPERATOR_LEFT = 1;
+ const OPERATOR_RIGHT = 2;
+
+ protected $parser;
+ protected $unaryOperators;
+ protected $binaryOperators;
+
+ public function __construct(Twig_Parser $parser, array $unaryOperators, array $binaryOperators)
+ {
+ $this->parser = $parser;
+ $this->unaryOperators = $unaryOperators;
+ $this->binaryOperators = $binaryOperators;
+ }
+
+ public function parseExpression($precedence = 0)
+ {
+ $expr = $this->getPrimary();
+ $token = $this->parser->getCurrentToken();
+ while ($this->isBinary($token) && $this->binaryOperators[$token->getValue()]['precedence'] >= $precedence) {
+ $op = $this->binaryOperators[$token->getValue()];
+ $this->parser->getStream()->next();
+
+ if (isset($op['callable'])) {
+ $expr = call_user_func($op['callable'], $this->parser, $expr);
+ } else {
+ $expr1 = $this->parseExpression(self::OPERATOR_LEFT === $op['associativity'] ? $op['precedence'] + 1 : $op['precedence']);
+ $class = $op['class'];
+ $expr = new $class($expr, $expr1, $token->getLine());
+ }
+
+ $token = $this->parser->getCurrentToken();
+ }
+
+ if (0 === $precedence) {
+ return $this->parseConditionalExpression($expr);
+ }
+
+ return $expr;
+ }
+
+ protected function getPrimary()
+ {
+ $token = $this->parser->getCurrentToken();
+
+ if ($this->isUnary($token)) {
+ $operator = $this->unaryOperators[$token->getValue()];
+ $this->parser->getStream()->next();
+ $expr = $this->parseExpression($operator['precedence']);
+ $class = $operator['class'];
+
+ return $this->parsePostfixExpression(new $class($expr, $token->getLine()));
+ } elseif ($token->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $this->parser->getStream()->next();
+ $expr = $this->parseExpression();
+ $this->parser->getStream()->expect(Twig_Token::PUNCTUATION_TYPE, ')', 'An opened parenthesis is not properly closed');
+
+ return $this->parsePostfixExpression($expr);
+ }
+
+ return $this->parsePrimaryExpression();
+ }
+
+ protected function parseConditionalExpression($expr)
+ {
+ while ($this->parser->getStream()->test(Twig_Token::PUNCTUATION_TYPE, '?')) {
+ $this->parser->getStream()->next();
+ $expr2 = $this->parseExpression();
+ $this->parser->getStream()->expect(Twig_Token::PUNCTUATION_TYPE, ':', 'The ternary operator must have a default value');
+ $expr3 = $this->parseExpression();
+
+ $expr = new Twig_Node_Expression_Conditional($expr, $expr2, $expr3, $this->parser->getCurrentToken()->getLine());
+ }
+
+ return $expr;
+ }
+
+ protected function isUnary(Twig_Token $token)
+ {
+ return $token->test(Twig_Token::OPERATOR_TYPE) && isset($this->unaryOperators[$token->getValue()]);
+ }
+
+ protected function isBinary(Twig_Token $token)
+ {
+ return $token->test(Twig_Token::OPERATOR_TYPE) && isset($this->binaryOperators[$token->getValue()]);
+ }
+
+ public function parsePrimaryExpression()
+ {
+ $token = $this->parser->getCurrentToken();
+ switch ($token->getType()) {
+ case Twig_Token::NAME_TYPE:
+ $this->parser->getStream()->next();
+ switch ($token->getValue()) {
+ case 'true':
+ case 'TRUE':
+ $node = new Twig_Node_Expression_Constant(true, $token->getLine());
+ break;
+
+ case 'false':
+ case 'FALSE':
+ $node = new Twig_Node_Expression_Constant(false, $token->getLine());
+ break;
+
+ case 'none':
+ case 'NONE':
+ case 'null':
+ case 'NULL':
+ $node = new Twig_Node_Expression_Constant(null, $token->getLine());
+ break;
+
+ default:
+ if ('(' === $this->parser->getCurrentToken()->getValue()) {
+ $node = $this->getFunctionNode($token->getValue(), $token->getLine());
+ } else {
+ $node = new Twig_Node_Expression_Name($token->getValue(), $token->getLine());
+ }
+ }
+ break;
+
+ case Twig_Token::NUMBER_TYPE:
+ $this->parser->getStream()->next();
+ $node = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ break;
+
+ case Twig_Token::STRING_TYPE:
+ case Twig_Token::INTERPOLATION_START_TYPE:
+ $node = $this->parseStringExpression();
+ break;
+
+ default:
+ if ($token->test(Twig_Token::PUNCTUATION_TYPE, '[')) {
+ $node = $this->parseArrayExpression();
+ } elseif ($token->test(Twig_Token::PUNCTUATION_TYPE, '{')) {
+ $node = $this->parseHashExpression();
+ } else {
+ throw new Twig_Error_Syntax(sprintf('Unexpected token "%s" of value "%s"', Twig_Token::typeToEnglish($token->getType(), $token->getLine()), $token->getValue()), $token->getLine());
+ }
+ }
+
+ return $this->parsePostfixExpression($node);
+ }
+
+ public function parseStringExpression()
+ {
+ $stream = $this->parser->getStream();
+
+ $nodes = array();
+ // a string cannot be followed by another string in a single expression
+ $nextCanBeString = true;
+ while (true) {
+ if ($stream->test(Twig_Token::STRING_TYPE) && $nextCanBeString) {
+ $token = $stream->next();
+ $nodes[] = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ $nextCanBeString = false;
+ } elseif ($stream->test(Twig_Token::INTERPOLATION_START_TYPE)) {
+ $stream->next();
+ $nodes[] = $this->parseExpression();
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $nextCanBeString = true;
+ } else {
+ break;
+ }
+ }
+
+ $expr = array_shift($nodes);
+ foreach ($nodes as $node) {
+ $expr = new Twig_Node_Expression_Binary_Concat($expr, $node, $node->getLine());
+ }
+
+ return $expr;
+ }
+
+ public function parseArrayExpression()
+ {
+ $stream = $this->parser->getStream();
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '[', 'An array element was expected');
+
+ $node = new Twig_Node_Expression_Array(array(), $stream->getCurrent()->getLine());
+ $first = true;
+ while (!$stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
+ if (!$first) {
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ',', 'An array element must be followed by a comma');
+
+ // trailing ,?
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
+ break;
+ }
+ }
+ $first = false;
+
+ $node->addElement($this->parseExpression());
+ }
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ']', 'An opened array is not properly closed');
+
+ return $node;
+ }
+
+ public function parseHashExpression()
+ {
+ $stream = $this->parser->getStream();
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '{', 'A hash element was expected');
+
+ $node = new Twig_Node_Expression_Array(array(), $stream->getCurrent()->getLine());
+ $first = true;
+ while (!$stream->test(Twig_Token::PUNCTUATION_TYPE, '}')) {
+ if (!$first) {
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ',', 'A hash value must be followed by a comma');
+
+ // trailing ,?
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, '}')) {
+ break;
+ }
+ }
+ $first = false;
+
+ // a hash key can be:
+ //
+ // * a number -- 12
+ // * a string -- 'a'
+ // * a name, which is equivalent to a string -- a
+ // * an expression, which must be enclosed in parentheses -- (1 + 2)
+ if ($stream->test(Twig_Token::STRING_TYPE) || $stream->test(Twig_Token::NAME_TYPE) || $stream->test(Twig_Token::NUMBER_TYPE)) {
+ $token = $stream->next();
+ $key = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ } elseif ($stream->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $key = $this->parseExpression();
+ } else {
+ $current = $stream->getCurrent();
+
+ throw new Twig_Error_Syntax(sprintf('A hash key must be a quoted string, a number, a name, or an expression enclosed in parentheses (unexpected token "%s" of value "%s"', Twig_Token::typeToEnglish($current->getType(), $current->getLine()), $current->getValue()), $current->getLine());
+ }
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ':', 'A hash key must be followed by a colon (:)');
+ $value = $this->parseExpression();
+
+ $node->addElement($value, $key);
+ }
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '}', 'An opened hash is not properly closed');
+
+ return $node;
+ }
+
+ public function parsePostfixExpression($node)
+ {
+ while (true) {
+ $token = $this->parser->getCurrentToken();
+ if ($token->getType() == Twig_Token::PUNCTUATION_TYPE) {
+ if ('.' == $token->getValue() || '[' == $token->getValue()) {
+ $node = $this->parseSubscriptExpression($node);
+ } elseif ('|' == $token->getValue()) {
+ $node = $this->parseFilterExpression($node);
+ } else {
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+
+ return $node;
+ }
+
+ public function getFunctionNode($name, $line)
+ {
+ $args = $this->parseArguments();
+ switch ($name) {
+ case 'parent':
+ if (!count($this->parser->getBlockStack())) {
+ throw new Twig_Error_Syntax('Calling "parent" outside a block is forbidden', $line);
+ }
+
+ if (!$this->parser->getParent() && !$this->parser->hasTraits()) {
+ throw new Twig_Error_Syntax('Calling "parent" on a template that does not extend nor "use" another template is forbidden', $line);
+ }
+
+ return new Twig_Node_Expression_Parent($this->parser->peekBlockStack(), $line);
+ case 'block':
+ return new Twig_Node_Expression_BlockReference($args->getNode(0), false, $line);
+ case 'attribute':
+ if (count($args) < 2) {
+ throw new Twig_Error_Syntax('The "attribute" function takes at least two arguments (the variable and the attributes)', $line);
+ }
+
+ return new Twig_Node_Expression_GetAttr($args->getNode(0), $args->getNode(1), count($args) > 2 ? $args->getNode(2) : new Twig_Node_Expression_Array(array(), $line), Twig_TemplateInterface::ANY_CALL, $line);
+ default:
+ if (null !== $alias = $this->parser->getImportedFunction($name)) {
+ $arguments = new Twig_Node_Expression_Array(array(), $line);
+ foreach ($args as $n) {
+ $arguments->addElement($n);
+ }
+
+ $node = new Twig_Node_Expression_MethodCall($alias['node'], $alias['name'], $arguments, $line);
+ $node->setAttribute('safe', true);
+
+ return $node;
+ }
+
+ $class = $this->getFunctionNodeClass($name);
+
+ return new $class($name, $args, $line);
+ }
+ }
+
+ public function parseSubscriptExpression($node)
+ {
+ $stream = $this->parser->getStream();
+ $token = $stream->next();
+ $lineno = $token->getLine();
+ $arguments = new Twig_Node_Expression_Array(array(), $lineno);
+ $type = Twig_TemplateInterface::ANY_CALL;
+ if ($token->getValue() == '.') {
+ $token = $stream->next();
+ if (
+ $token->getType() == Twig_Token::NAME_TYPE
+ ||
+ $token->getType() == Twig_Token::NUMBER_TYPE
+ ||
+ ($token->getType() == Twig_Token::OPERATOR_TYPE && preg_match(Twig_Lexer::REGEX_NAME, $token->getValue()))
+ ) {
+ $arg = new Twig_Node_Expression_Constant($token->getValue(), $lineno);
+
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $type = Twig_TemplateInterface::METHOD_CALL;
+ foreach ($this->parseArguments() as $n) {
+ $arguments->addElement($n);
+ }
+ }
+ } else {
+ throw new Twig_Error_Syntax('Expected name or number', $lineno);
+ }
+ } else {
+ $type = Twig_TemplateInterface::ARRAY_CALL;
+
+ $arg = $this->parseExpression();
+
+ // slice?
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ':')) {
+ $stream->next();
+
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, ']')) {
+ $length = new Twig_Node_Expression_Constant(null, $token->getLine());
+ } else {
+ $length = $this->parseExpression();
+ }
+
+ $class = $this->getFilterNodeClass('slice');
+ $arguments = new Twig_Node(array($arg, $length));
+ $filter = new $class($node, new Twig_Node_Expression_Constant('slice', $token->getLine()), $arguments, $token->getLine());
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ']');
+
+ return $filter;
+ }
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ']');
+ }
+
+ return new Twig_Node_Expression_GetAttr($node, $arg, $arguments, $type, $lineno);
+ }
+
+ public function parseFilterExpression($node)
+ {
+ $this->parser->getStream()->next();
+
+ return $this->parseFilterExpressionRaw($node);
+ }
+
+ public function parseFilterExpressionRaw($node, $tag = null)
+ {
+ while (true) {
+ $token = $this->parser->getStream()->expect(Twig_Token::NAME_TYPE);
+
+ $name = new Twig_Node_Expression_Constant($token->getValue(), $token->getLine());
+ if (!$this->parser->getStream()->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $arguments = new Twig_Node();
+ } else {
+ $arguments = $this->parseArguments();
+ }
+
+ $class = $this->getFilterNodeClass($name->getAttribute('value'));
+
+ $node = new $class($node, $name, $arguments, $token->getLine(), $tag);
+
+ if (!$this->parser->getStream()->test(Twig_Token::PUNCTUATION_TYPE, '|')) {
+ break;
+ }
+
+ $this->parser->getStream()->next();
+ }
+
+ return $node;
+ }
+
+ public function parseArguments()
+ {
+ $args = array();
+ $stream = $this->parser->getStream();
+
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, '(', 'A list of arguments must be opened by a parenthesis');
+ while (!$stream->test(Twig_Token::PUNCTUATION_TYPE, ')')) {
+ if (!empty($args)) {
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ',', 'Arguments must be separated by a comma');
+ }
+ $args[] = $this->parseExpression();
+ }
+ $stream->expect(Twig_Token::PUNCTUATION_TYPE, ')', 'A list of arguments must be closed by a parenthesis');
+
+ return new Twig_Node($args);
+ }
+
+ public function parseAssignmentExpression()
+ {
+ $targets = array();
+ while (true) {
+ $token = $this->parser->getStream()->expect(Twig_Token::NAME_TYPE, null, 'Only variables can be assigned to');
+ if (in_array($token->getValue(), array('true', 'false', 'none'))) {
+ throw new Twig_Error_Syntax(sprintf('You cannot assign a value to "%s"', $token->getValue()), $token->getLine());
+ }
+ $targets[] = new Twig_Node_Expression_AssignName($token->getValue(), $token->getLine());
+
+ if (!$this->parser->getStream()->test(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+ $this->parser->getStream()->next();
+ }
+
+ return new Twig_Node($targets);
+ }
+
+ public function parseMultitargetExpression()
+ {
+ $targets = array();
+ while (true) {
+ $targets[] = $this->parseExpression();
+ if (!$this->parser->getStream()->test(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+ $this->parser->getStream()->next();
+ }
+
+ return new Twig_Node($targets);
+ }
+
+ protected function getFunctionNodeClass($name)
+ {
+ $functionMap = $this->parser->getEnvironment()->getFunctions();
+ if (isset($functionMap[$name]) && $functionMap[$name] instanceof Twig_Function_Node) {
+ return $functionMap[$name]->getClass();
+ }
+
+ return 'Twig_Node_Expression_Function';
+ }
+
+ protected function getFilterNodeClass($name)
+ {
+ $filterMap = $this->parser->getEnvironment()->getFilters();
+ if (isset($filterMap[$name]) && $filterMap[$name] instanceof Twig_Filter_Node) {
+ return $filterMap[$name]->getClass();
+ }
+
+ return 'Twig_Node_Expression_Filter';
+ }
+}
diff --git a/lib/twig/lib/Twig/Extension.php b/lib/twig/lib/Twig/Extension.php
new file mode 100755
index 0000000..931fc03
--- /dev/null
+++ b/lib/twig/lib/Twig/Extension.php
@@ -0,0 +1,93 @@
+dateFormats[0] = $format;
+ }
+
+ if (null !== $dateIntervalFormat) {
+ $this->dateFormats[1] = $dateIntervalFormat;
+ }
+ }
+
+ /**
+ * Gets the default format to be used by the date filter.
+ *
+ * @return array The default date format string and the default date interval format string
+ */
+ public function getDateFormat()
+ {
+ return $this->dateFormats;
+ }
+
+ /**
+ * Sets the default timezone to be used by the date filter.
+ *
+ * @param DateTimeZone|string $timezone The default timezone string or a DateTimeZone object
+ */
+ public function setTimezone($timezone)
+ {
+ $this->timezone = $timezone instanceof DateTimeZone ? $timezone : new DateTimeZone($timezone);
+ }
+
+ /**
+ * Gets the default timezone to be used by the date filter.
+ *
+ * @return DateTimeZone The default timezone currently in use
+ */
+ public function getTimezone()
+ {
+ return $this->timezone;
+ }
+
+ /**
+ * Sets the default format to be used by the number_format filter.
+ *
+ * @param integer $decimal The number of decimal places to use.
+ * @param string $decimalPoint The character(s) to use for the decimal point.
+ * @param string $thousandSep The character(s) to use for the thousands separator.
+ */
+ public function setNumberFormat($decimal, $decimalPoint, $thousandSep)
+ {
+ $this->numberFormat = array($decimal, $decimalPoint, $thousandSep);
+ }
+
+ /**
+ * Get the default format used by the number_format filter.
+ *
+ * @return array The arguments for number_format()
+ */
+ public function getNumberFormat()
+ {
+ return $this->numberFormat;
+ }
+
+ /**
+ * Returns the token parser instance to add to the existing list.
+ *
+ * @return array An array of Twig_TokenParser instances
+ */
+ public function getTokenParsers()
+ {
+ return array(
+ new Twig_TokenParser_For(),
+ new Twig_TokenParser_If(),
+ new Twig_TokenParser_Extends(),
+ new Twig_TokenParser_Include(),
+ new Twig_TokenParser_Block(),
+ new Twig_TokenParser_Use(),
+ new Twig_TokenParser_Filter(),
+ new Twig_TokenParser_Macro(),
+ new Twig_TokenParser_Import(),
+ new Twig_TokenParser_From(),
+ new Twig_TokenParser_Set(),
+ new Twig_TokenParser_Spaceless(),
+ new Twig_TokenParser_Flush(),
+ new Twig_TokenParser_Do(),
+ );
+ }
+
+ /**
+ * Returns a list of filters to add to the existing list.
+ *
+ * @return array An array of filters
+ */
+ public function getFilters()
+ {
+ $filters = array(
+ // formatting filters
+ 'date' => new Twig_Filter_Function('twig_date_format_filter', array('needs_environment' => true)),
+ 'format' => new Twig_Filter_Function('sprintf'),
+ 'replace' => new Twig_Filter_Function('strtr'),
+ 'number_format' => new Twig_Filter_Function('twig_number_format_filter', array('needs_environment' => true)),
+
+ // encoding
+ 'url_encode' => new Twig_Filter_Function('twig_urlencode_filter'),
+ 'json_encode' => new Twig_Filter_Function('twig_jsonencode_filter'),
+ 'convert_encoding' => new Twig_Filter_Function('twig_convert_encoding'),
+
+ // string filters
+ 'title' => new Twig_Filter_Function('twig_title_string_filter', array('needs_environment' => true)),
+ 'capitalize' => new Twig_Filter_Function('twig_capitalize_string_filter', array('needs_environment' => true)),
+ 'upper' => new Twig_Filter_Function('strtoupper'),
+ 'lower' => new Twig_Filter_Function('strtolower'),
+ 'striptags' => new Twig_Filter_Function('strip_tags'),
+ 'trim' => new Twig_Filter_Function('trim'),
+ 'nl2br' => new Twig_Filter_Function('nl2br', array('pre_escape' => 'html', 'is_safe' => array('html'))),
+
+ // array helpers
+ 'join' => new Twig_Filter_Function('twig_join_filter'),
+ 'sort' => new Twig_Filter_Function('twig_sort_filter'),
+ 'merge' => new Twig_Filter_Function('twig_array_merge'),
+
+ // string/array filters
+ 'reverse' => new Twig_Filter_Function('twig_reverse_filter', array('needs_environment' => true)),
+ 'length' => new Twig_Filter_Function('twig_length_filter', array('needs_environment' => true)),
+ 'slice' => new Twig_Filter_Function('twig_slice', array('needs_environment' => true)),
+
+ // iteration and runtime
+ 'default' => new Twig_Filter_Node('Twig_Node_Expression_Filter_Default'),
+ '_default' => new Twig_Filter_Function('_twig_default_filter'),
+
+ 'keys' => new Twig_Filter_Function('twig_get_array_keys_filter'),
+
+ // escaping
+ 'escape' => new Twig_Filter_Function('twig_escape_filter', array('needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe')),
+ 'e' => new Twig_Filter_Function('twig_escape_filter', array('needs_environment' => true, 'is_safe_callback' => 'twig_escape_filter_is_safe')),
+ );
+
+ if (function_exists('mb_get_info')) {
+ $filters['upper'] = new Twig_Filter_Function('twig_upper_filter', array('needs_environment' => true));
+ $filters['lower'] = new Twig_Filter_Function('twig_lower_filter', array('needs_environment' => true));
+ }
+
+ return $filters;
+ }
+
+ /**
+ * Returns a list of global functions to add to the existing list.
+ *
+ * @return array An array of global functions
+ */
+ public function getFunctions()
+ {
+ return array(
+ 'range' => new Twig_Function_Function('range'),
+ 'constant' => new Twig_Function_Function('constant'),
+ 'cycle' => new Twig_Function_Function('twig_cycle'),
+ 'random' => new Twig_Function_Function('twig_random', array('needs_environment' => true)),
+ 'date' => new Twig_Function_Function('twig_date_converter', array('needs_environment' => true)),
+ );
+ }
+
+ /**
+ * Returns a list of tests to add to the existing list.
+ *
+ * @return array An array of tests
+ */
+ public function getTests()
+ {
+ return array(
+ 'even' => new Twig_Test_Node('Twig_Node_Expression_Test_Even'),
+ 'odd' => new Twig_Test_Node('Twig_Node_Expression_Test_Odd'),
+ 'defined' => new Twig_Test_Node('Twig_Node_Expression_Test_Defined'),
+ 'sameas' => new Twig_Test_Node('Twig_Node_Expression_Test_Sameas'),
+ 'none' => new Twig_Test_Node('Twig_Node_Expression_Test_Null'),
+ 'null' => new Twig_Test_Node('Twig_Node_Expression_Test_Null'),
+ 'divisibleby' => new Twig_Test_Node('Twig_Node_Expression_Test_Divisibleby'),
+ 'constant' => new Twig_Test_Node('Twig_Node_Expression_Test_Constant'),
+ 'empty' => new Twig_Test_Function('twig_test_empty'),
+ );
+ }
+
+ /**
+ * Returns a list of operators to add to the existing list.
+ *
+ * @return array An array of operators
+ */
+ public function getOperators()
+ {
+ return array(
+ array(
+ 'not' => array('precedence' => 50, 'class' => 'Twig_Node_Expression_Unary_Not'),
+ '-' => array('precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Neg'),
+ '+' => array('precedence' => 500, 'class' => 'Twig_Node_Expression_Unary_Pos'),
+ ),
+ array(
+ 'b-and' => array('precedence' => 5, 'class' => 'Twig_Node_Expression_Binary_BitwiseAnd', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'b-xor' => array('precedence' => 5, 'class' => 'Twig_Node_Expression_Binary_BitwiseXor', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'b-or' => array('precedence' => 5, 'class' => 'Twig_Node_Expression_Binary_BitwiseOr', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'or' => array('precedence' => 10, 'class' => 'Twig_Node_Expression_Binary_Or', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'and' => array('precedence' => 15, 'class' => 'Twig_Node_Expression_Binary_And', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '==' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Equal', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '!=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '<' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Less', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '>' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_Greater', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '>=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_GreaterEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '<=' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_LessEqual', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'not in' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_NotIn', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'in' => array('precedence' => 20, 'class' => 'Twig_Node_Expression_Binary_In', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '..' => array('precedence' => 25, 'class' => 'Twig_Node_Expression_Binary_Range', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '+' => array('precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Add', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '-' => array('precedence' => 30, 'class' => 'Twig_Node_Expression_Binary_Sub', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '~' => array('precedence' => 40, 'class' => 'Twig_Node_Expression_Binary_Concat', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '*' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mul', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '/' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Div', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '//' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_FloorDiv', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '%' => array('precedence' => 60, 'class' => 'Twig_Node_Expression_Binary_Mod', 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'is' => array('precedence' => 100, 'callable' => array($this, 'parseTestExpression'), 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ 'is not' => array('precedence' => 100, 'callable' => array($this, 'parseNotTestExpression'), 'associativity' => Twig_ExpressionParser::OPERATOR_LEFT),
+ '**' => array('precedence' => 200, 'class' => 'Twig_Node_Expression_Binary_Power', 'associativity' => Twig_ExpressionParser::OPERATOR_RIGHT),
+ ),
+ );
+ }
+
+ public function parseNotTestExpression(Twig_Parser $parser, $node)
+ {
+ return new Twig_Node_Expression_Unary_Not($this->parseTestExpression($parser, $node), $parser->getCurrentToken()->getLine());
+ }
+
+ public function parseTestExpression(Twig_Parser $parser, $node)
+ {
+ $stream = $parser->getStream();
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ $arguments = null;
+ if ($stream->test(Twig_Token::PUNCTUATION_TYPE, '(')) {
+ $arguments = $parser->getExpressionParser()->parseArguments();
+ }
+
+ $class = $this->getTestNodeClass($parser->getEnvironment(), $name);
+
+ return new $class($node, $name, $arguments, $parser->getCurrentToken()->getLine());
+ }
+
+ protected function getTestNodeClass(Twig_Environment $env, $name)
+ {
+ $testMap = $env->getTests();
+ if (isset($testMap[$name]) && $testMap[$name] instanceof Twig_Test_Node) {
+ return $testMap[$name]->getClass();
+ }
+
+ return 'Twig_Node_Expression_Test';
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'core';
+ }
+}
+
+/**
+ * Cycles over a value.
+ *
+ * @param ArrayAccess|array $values An array or an ArrayAccess instance
+ * @param integer $i The cycle value
+ *
+ * @return string The next value in the cycle
+ */
+function twig_cycle($values, $i)
+{
+ if (!is_array($values) && !$values instanceof ArrayAccess) {
+ return $values;
+ }
+
+ return $values[$i % count($values)];
+}
+
+/**
+ * Returns a random value depending on the supplied parameter type:
+ * - a random item from a Traversable or array
+ * - a random character from a string
+ * - a random integer between 0 and the integer parameter
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param Traversable|array|int|string $values The values to pick a random item from
+ *
+ * @return mixed A random value from the given sequence
+ */
+function twig_random(Twig_Environment $env, $values = null)
+{
+ if (null === $values) {
+ return mt_rand();
+ }
+
+ if (is_int($values) || is_float($values)) {
+ return $values < 0 ? mt_rand($values, 0) : mt_rand(0, $values);
+ }
+
+ if ($values instanceof Traversable) {
+ $values = iterator_to_array($values);
+ } elseif (is_string($values)) {
+ if (null !== $charset = $env->getCharset()) {
+ if ('UTF-8' != $charset) {
+ $values = twig_convert_encoding($values, 'UTF-8', $charset);
+ }
+
+ // unicode version of str_split()
+ // split at all positions, but not after the start and not before the end
+ $values = preg_split('/(? $value) {
+ $values[$i] = twig_convert_encoding($value, $charset, 'UTF-8');
+ }
+ }
+ } else {
+ return $values[mt_rand(0, strlen($values) - 1)];
+ }
+ }
+
+ if (!is_array($values)) {
+ return $values;
+ }
+
+ if (0 === count($values)) {
+ throw new Twig_Error_Runtime('The random function cannot pick from an empty array.');
+ }
+
+ return $values[array_rand($values, 1)];
+}
+
+/**
+ * Converts a date to the given format.
+ *
+ *
+ * {{ post.published_at|date("m/d/Y") }}
+ *
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param DateTime|DateInterval|string $date A date
+ * @param string $format A format
+ * @param DateTimeZone|string $timezone A timezone
+ *
+ * @return string The formatter date
+ */
+function twig_date_format_filter(Twig_Environment $env, $date, $format = null, $timezone = null)
+{
+ if (null === $format) {
+ $formats = $env->getExtension('core')->getDateFormat();
+ $format = $date instanceof DateInterval ? $formats[1] : $formats[0];
+ }
+
+ if ($date instanceof DateInterval || $date instanceof DateTime) {
+ if (null !== $timezone) {
+ $date->setTimezone($timezone instanceof DateTimeZone ? $timezone : new DateTimeZone($timezone));
+ }
+
+ return $date->format($format);
+ }
+
+ return twig_date_converter($env, $date, $timezone)->format($format);
+}
+
+/**
+ * Converts an input to a DateTime instance.
+ *
+ *
+ * {% if date(user.created_at) < date('+2days') %}
+ * {# do something #}
+ * {% endif %}
+ *
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param DateTime|string $date A date
+ * @param DateTimeZone|string $timezone A timezone
+ *
+ * @return DateTime A DateTime instance
+ */
+function twig_date_converter(Twig_Environment $env, $date = null, $timezone = null)
+{
+ if ($date instanceof DateTime) {
+ return $date;
+ }
+
+ $asString = (string) $date;
+
+ if (ctype_digit($asString) || (!empty($asString) && '-' === $asString[0] && ctype_digit(substr($asString, 1)))) {
+ $date = new DateTime('@'.$date);
+ $date->setTimezone(new DateTimeZone(date_default_timezone_get()));
+ } else {
+ $date = new DateTime($date);
+ }
+
+ // set Timezone
+ if (null !== $timezone) {
+ if (!$timezone instanceof DateTimeZone) {
+ $timezone = new DateTimeZone($timezone);
+ }
+
+ $date->setTimezone($timezone);
+ } elseif (($timezone = $env->getExtension('core')->getTimezone()) instanceof DateTimeZone) {
+ $date->setTimezone($timezone);
+ }
+
+ return $date;
+}
+
+/**
+ * Number format filter.
+ *
+ * All of the formatting options can be left null, in that case the defaults will
+ * be used. Supplying any of the parameters will override the defaults set in the
+ * environment object.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $number A float/int/string of the number to format
+ * @param int $decimal The number of decimal points to display.
+ * @param string $decimalPoint The character(s) to use for the decimal point.
+ * @param string $thousandSep The character(s) to use for the thousands separator.
+ *
+ * @return string The formatted number
+ */
+function twig_number_format_filter(Twig_Environment $env, $number, $decimal = null, $decimalPoint = null, $thousandSep = null)
+{
+ $defaults = $env->getExtension('core')->getNumberFormat();
+ if (null === $decimal) {
+ $decimal = $defaults[0];
+ }
+
+ if (null === $decimalPoint) {
+ $decimalPoint = $defaults[1];
+ }
+
+ if (null === $thousandSep) {
+ $thousandSep = $defaults[2];
+ }
+
+ return number_format((float) $number, $decimal, $decimalPoint, $thousandSep);
+}
+
+/**
+ * URL encodes a string.
+ *
+ * @param string $url A URL
+ * @param bool $raw true to use rawurlencode() instead of urlencode
+ *
+ * @return string The URL encoded value
+ */
+function twig_urlencode_filter($url, $raw = false)
+{
+ if ($raw) {
+ return rawurlencode($url);
+ }
+
+ return urlencode($url);
+}
+
+if (version_compare(PHP_VERSION, '5.3.0', '<')) {
+ /**
+ * JSON encodes a variable.
+ *
+ * @param mixed $value The value to encode.
+ * @param integer $options Not used on PHP 5.2.x
+ *
+ * @return mixed The JSON encoded value
+ */
+ function twig_jsonencode_filter($value, $options = 0)
+ {
+ if ($value instanceof Twig_Markup) {
+ $value = (string) $value;
+ } elseif (is_array($value)) {
+ array_walk_recursive($value, '_twig_markup2string');
+ }
+
+ return json_encode($value);
+ }
+} else {
+ /**
+ * JSON encodes a variable.
+ *
+ * @param mixed $value The value to encode.
+ * @param integer $options Bitmask consisting of JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT
+ *
+ * @return mixed The JSON encoded value
+ */
+ function twig_jsonencode_filter($value, $options = 0)
+ {
+ if ($value instanceof Twig_Markup) {
+ $value = (string) $value;
+ } elseif (is_array($value)) {
+ array_walk_recursive($value, '_twig_markup2string');
+ }
+
+ return json_encode($value, $options);
+ }
+}
+
+function _twig_markup2string(&$value)
+{
+ if ($value instanceof Twig_Markup) {
+ $value = (string) $value;
+ }
+}
+
+/**
+ * Merges an array with another one.
+ *
+ *
+ * {% set items = { 'apple': 'fruit', 'orange': 'fruit' } %}
+ *
+ * {% set items = items|merge({ 'peugeot': 'car' }) %}
+ *
+ * {# items now contains { 'apple': 'fruit', 'orange': 'fruit', 'peugeot': 'car' } #}
+ *
+ *
+ * @param array $arr1 An array
+ * @param array $arr2 An array
+ *
+ * @return array The merged array
+ */
+function twig_array_merge($arr1, $arr2)
+{
+ if (!is_array($arr1) || !is_array($arr2)) {
+ throw new Twig_Error_Runtime('The merge filter only works with arrays or hashes.');
+ }
+
+ return array_merge($arr1, $arr2);
+}
+
+/**
+ * Slices a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $item A variable
+ * @param integer $start Start of the slice
+ * @param integer $length Size of the slice
+ * @param Boolean $preserveKeys Whether to preserve key or not (when the input is an array)
+ *
+ * @return mixed The sliced variable
+ */
+function twig_slice(Twig_Environment $env, $item, $start, $length = null, $preserveKeys = false)
+{
+ if ($item instanceof Traversable) {
+ $item = iterator_to_array($item, false);
+ }
+
+ if (is_array($item)) {
+ return array_slice($item, $start, $length, $preserveKeys);
+ }
+
+ $item = (string) $item;
+
+ if (function_exists('mb_get_info') && null !== $charset = $env->getCharset()) {
+ return mb_substr($item, $start, null === $length ? mb_strlen($item, $charset) - $start : $length, $charset);
+ }
+
+ return null === $length ? substr($item, $start) : substr($item, $start, $length);
+}
+
+/**
+ * Joins the values to a string.
+ *
+ * The separator between elements is an empty string per default, you can define it with the optional parameter.
+ *
+ *
+ * {{ [1, 2, 3]|join('|') }}
+ * {# returns 1|2|3 #}
+ *
+ * {{ [1, 2, 3]|join }}
+ * {# returns 123 #}
+ *
+ *
+ * @param array $value An array
+ * @param string $glue The separator
+ *
+ * @return string The concatenated string
+ */
+function twig_join_filter($value, $glue = '')
+{
+ if ($value instanceof Traversable) {
+ $value = iterator_to_array($value, false);
+ }
+
+ return implode($glue, (array) $value);
+}
+
+// The '_default' filter is used internally to avoid using the ternary operator
+// which costs a lot for big contexts (before PHP 5.4). So, on average,
+// a function call is cheaper.
+function _twig_default_filter($value, $default = '')
+{
+ if (twig_test_empty($value)) {
+ return $default;
+ }
+
+ return $value;
+}
+
+/**
+ * Returns the keys for the given array.
+ *
+ * It is useful when you want to iterate over the keys of an array:
+ *
+ *
+ * {% for key in array|keys %}
+ * {# ... #}
+ * {% endfor %}
+ *
+ *
+ * @param array $array An array
+ *
+ * @return array The keys
+ */
+function twig_get_array_keys_filter($array)
+{
+ if (is_object($array) && $array instanceof Traversable) {
+ return array_keys(iterator_to_array($array));
+ }
+
+ if (!is_array($array)) {
+ return array();
+ }
+
+ return array_keys($array);
+}
+
+/**
+ * Reverses a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param array|Traversable|string $item An array, a Traversable instance, or a string
+ * @param Boolean $preserveKeys Whether to preserve key or not
+ *
+ * @return mixed The reversed input
+ */
+function twig_reverse_filter(Twig_Environment $env, $item, $preserveKeys = false)
+{
+ if (is_object($item) && $item instanceof Traversable) {
+ return array_reverse(iterator_to_array($item), $preserveKeys);
+ }
+
+ if (is_array($item)) {
+ return array_reverse($item, $preserveKeys);
+ }
+
+ if (null !== $charset = $env->getCharset()) {
+ $string = (string) $item;
+
+ if ('UTF-8' != $charset) {
+ $item = twig_convert_encoding($string, 'UTF-8', $charset);
+ }
+
+ preg_match_all('/./us', $item, $matches);
+
+ $string = implode('', array_reverse($matches[0]));
+
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, $charset, 'UTF-8');
+ }
+
+ return $string;
+ }
+
+ return strrev((string) $item);
+}
+
+/**
+ * Sorts an array.
+ *
+ * @param array $array An array
+ */
+function twig_sort_filter($array)
+{
+ asort($array);
+
+ return $array;
+}
+
+/* used internally */
+function twig_in_filter($value, $compare)
+{
+ if (is_array($compare)) {
+ return in_array($value, $compare);
+ } elseif (is_string($compare)) {
+ if (!strlen((string) $value)) {
+ return empty($compare);
+ }
+
+ return false !== strpos($compare, (string) $value);
+ } elseif (is_object($compare) && $compare instanceof Traversable) {
+ return in_array($value, iterator_to_array($compare, false));
+ }
+
+ return false;
+}
+
+/**
+ * Escapes a string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string The value to be escaped
+ * @param string $type The escaping strategy
+ * @param string $charset The charset
+ * @param Boolean $autoescape Whether the function is called by the auto-escaping feature (true) or by the developer (false)
+ */
+function twig_escape_filter(Twig_Environment $env, $string, $type = 'html', $charset = null, $autoescape = false)
+{
+ if ($autoescape && is_object($string) && $string instanceof Twig_Markup) {
+ return $string;
+ }
+
+ if (!is_string($string) && !(is_object($string) && method_exists($string, '__toString'))) {
+ return $string;
+ }
+
+ if (null === $charset) {
+ $charset = $env->getCharset();
+ }
+
+ $string = (string) $string;
+
+ switch ($type) {
+ case 'js':
+ // escape all non-alphanumeric characters
+ // into their \xHH or \uHHHH representations
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, 'UTF-8', $charset);
+ }
+
+ if (null === $string = preg_replace_callback('#[^\p{L}\p{N} ]#u', '_twig_escape_js_callback', $string)) {
+ throw new Twig_Error_Runtime('The string to escape is not a valid UTF-8 string.');
+ }
+
+ if ('UTF-8' != $charset) {
+ $string = twig_convert_encoding($string, $charset, 'UTF-8');
+ }
+
+ return $string;
+
+ case 'html':
+ // see http://php.net/htmlspecialchars
+
+ // Using a static variable to avoid initializing the array
+ // each time the function is called. Moving the declaration on the
+ // top of the function slow downs other escaping types.
+ static $htmlspecialcharsCharsets = array(
+ 'iso-8859-1' => true, 'iso8859-1' => true,
+ 'iso-8859-15' => true, 'iso8859-15' => true,
+ 'utf-8' => true,
+ 'cp866' => true, 'ibm866' => true, '866' => true,
+ 'cp1251' => true, 'windows-1251' => true, 'win-1251' => true,
+ '1251' => true,
+ 'cp1252' => true, 'windows-1252' => true, '1252' => true,
+ 'koi8-r' => true, 'koi8-ru' => true, 'koi8r' => true,
+ 'big5' => true, '950' => true,
+ 'gb2312' => true, '936' => true,
+ 'big5-hkscs' => true,
+ 'shift_jis' => true, 'sjis' => true, '932' => true,
+ 'euc-jp' => true, 'eucjp' => true,
+ 'iso8859-5' => true, 'iso-8859-5' => true, 'macroman' => true,
+ );
+
+ if (isset($htmlspecialcharsCharsets[strtolower($charset)])) {
+ return htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
+ }
+
+ $string = twig_convert_encoding($string, 'UTF-8', $charset);
+ $string = htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
+
+ return twig_convert_encoding($string, $charset, 'UTF-8');
+
+ default:
+ throw new Twig_Error_Runtime(sprintf('Invalid escape type "%s".', $type));
+ }
+}
+
+/* used internally */
+function twig_escape_filter_is_safe(Twig_Node $filterArgs)
+{
+ foreach ($filterArgs as $arg) {
+ if ($arg instanceof Twig_Node_Expression_Constant) {
+ return array($arg->getAttribute('value'));
+ }
+
+ return array();
+ }
+
+ return array('html');
+}
+
+if (function_exists('iconv')) {
+ function twig_convert_encoding($string, $to, $from)
+ {
+ return iconv($from, $to, $string);
+ }
+} elseif (function_exists('mb_convert_encoding')) {
+ function twig_convert_encoding($string, $to, $from)
+ {
+ return mb_convert_encoding($string, $to, $from);
+ }
+} else {
+ function twig_convert_encoding($string, $to, $from)
+ {
+ throw new Twig_Error_Runtime('No suitable convert encoding function (use UTF-8 as your encoding or install the iconv or mbstring extension).');
+ }
+}
+
+function _twig_escape_js_callback($matches)
+{
+ $char = $matches[0];
+
+ // \xHH
+ if (!isset($char[1])) {
+ return '\\x'.substr('00'.bin2hex($char), -2);
+ }
+
+ // \uHHHH
+ $char = twig_convert_encoding($char, 'UTF-16BE', 'UTF-8');
+
+ return '\\u'.substr('0000'.bin2hex($char), -4);
+}
+
+// add multibyte extensions if possible
+if (function_exists('mb_get_info')) {
+ /**
+ * Returns the length of a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $thing A variable
+ *
+ * @return integer The length of the value
+ */
+ function twig_length_filter(Twig_Environment $env, $thing)
+ {
+ return is_scalar($thing) ? mb_strlen($thing, $env->getCharset()) : count($thing);
+ }
+
+ /**
+ * Converts a string to uppercase.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The uppercased string
+ */
+ function twig_upper_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_strtoupper($string, $charset);
+ }
+
+ return strtoupper($string);
+ }
+
+ /**
+ * Converts a string to lowercase.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The lowercased string
+ */
+ function twig_lower_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_strtolower($string, $charset);
+ }
+
+ return strtolower($string);
+ }
+
+ /**
+ * Returns a titlecased string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The titlecased string
+ */
+ function twig_title_string_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_convert_case($string, MB_CASE_TITLE, $charset);
+ }
+
+ return ucwords(strtolower($string));
+ }
+
+ /**
+ * Returns a capitalized string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The capitalized string
+ */
+ function twig_capitalize_string_filter(Twig_Environment $env, $string)
+ {
+ if (null !== ($charset = $env->getCharset())) {
+ return mb_strtoupper(mb_substr($string, 0, 1, $charset), $charset).
+ mb_strtolower(mb_substr($string, 1, mb_strlen($string, $charset), $charset), $charset);
+ }
+
+ return ucfirst(strtolower($string));
+ }
+}
+// and byte fallback
+else
+{
+ /**
+ * Returns the length of a variable.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param mixed $thing A variable
+ *
+ * @return integer The length of the value
+ */
+ function twig_length_filter(Twig_Environment $env, $thing)
+ {
+ return is_scalar($thing) ? strlen($thing) : count($thing);
+ }
+
+ /**
+ * Returns a titlecased string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The titlecased string
+ */
+ function twig_title_string_filter(Twig_Environment $env, $string)
+ {
+ return ucwords(strtolower($string));
+ }
+
+ /**
+ * Returns a capitalized string.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param string $string A string
+ *
+ * @return string The capitalized string
+ */
+ function twig_capitalize_string_filter(Twig_Environment $env, $string)
+ {
+ return ucfirst(strtolower($string));
+ }
+}
+
+/* used internally */
+function twig_ensure_traversable($seq)
+{
+ if (is_array($seq) || (is_object($seq) && $seq instanceof Traversable)) {
+ return $seq;
+ } else {
+ return array();
+ }
+}
+
+/**
+ * Checks if a variable is empty.
+ *
+ *
+ * {# evaluates to true if the foo variable is null, false, or the empty string #}
+ * {% if foo is empty %}
+ * {# ... #}
+ * {% endif %}
+ *
+ *
+ * @param mixed $value A variable
+ *
+ * @return Boolean true if the value is empty, false otherwise
+ */
+function twig_test_empty($value)
+{
+ if ($value instanceof Countable) {
+ return 0 == count($value);
+ }
+
+ return false === $value || (empty($value) && '0' != $value);
+}
diff --git a/lib/twig/lib/Twig/Extension/Debug.php b/lib/twig/lib/Twig/Extension/Debug.php
new file mode 100755
index 0000000..aab7093
--- /dev/null
+++ b/lib/twig/lib/Twig/Extension/Debug.php
@@ -0,0 +1,64 @@
+ new Twig_Function_Function('twig_var_dump', array('is_safe' => $isDumpOutputHtmlSafe ? array('html') : array(), 'needs_context' => true, 'needs_environment' => true)),
+ );
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'debug';
+ }
+}
+
+function twig_var_dump(Twig_Environment $env, $context)
+{
+ if (!$env->isDebug()) {
+ return;
+ }
+
+ ob_start();
+
+ $count = func_num_args();
+ if (2 === $count) {
+ $vars = array();
+ foreach ($context as $key => $value) {
+ if (!$value instanceof Twig_Template) {
+ $vars[$key] = $value;
+ }
+ }
+
+ var_dump($vars);
+ } else {
+ for ($i = 2; $i < $count; $i++) {
+ var_dump(func_get_arg($i));
+ }
+ }
+
+ return ob_get_clean();
+}
diff --git a/lib/twig/lib/Twig/Extension/Escaper.php b/lib/twig/lib/Twig/Extension/Escaper.php
new file mode 100755
index 0000000..43ae111
--- /dev/null
+++ b/lib/twig/lib/Twig/Extension/Escaper.php
@@ -0,0 +1,77 @@
+autoescape = $autoescape;
+ }
+
+ /**
+ * Returns the token parser instances to add to the existing list.
+ *
+ * @return array An array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances
+ */
+ public function getTokenParsers()
+ {
+ return array(new Twig_TokenParser_AutoEscape());
+ }
+
+ /**
+ * Returns the node visitor instances to add to the existing list.
+ *
+ * @return array An array of Twig_NodeVisitorInterface instances
+ */
+ public function getNodeVisitors()
+ {
+ return array(new Twig_NodeVisitor_Escaper());
+ }
+
+ /**
+ * Returns a list of filters to add to the existing list.
+ *
+ * @return array An array of filters
+ */
+ public function getFilters()
+ {
+ return array(
+ 'raw' => new Twig_Filter_Function('twig_raw_filter', array('is_safe' => array('all'))),
+ );
+ }
+
+ public function isGlobal()
+ {
+ return $this->autoescape;
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'escaper';
+ }
+}
+
+/**
+ * Marks a variable as being safe.
+ *
+ * @param string $string A PHP variable
+ */
+function twig_raw_filter($string)
+{
+ return $string;
+}
+
diff --git a/lib/twig/lib/Twig/Extension/Optimizer.php b/lib/twig/lib/Twig/Extension/Optimizer.php
new file mode 100755
index 0000000..013fcb6
--- /dev/null
+++ b/lib/twig/lib/Twig/Extension/Optimizer.php
@@ -0,0 +1,35 @@
+optimizers = $optimizers;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getNodeVisitors()
+ {
+ return array(new Twig_NodeVisitor_Optimizer($this->optimizers));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getName()
+ {
+ return 'optimizer';
+ }
+}
diff --git a/lib/twig/lib/Twig/Extension/Sandbox.php b/lib/twig/lib/Twig/Extension/Sandbox.php
new file mode 100755
index 0000000..bf76c11
--- /dev/null
+++ b/lib/twig/lib/Twig/Extension/Sandbox.php
@@ -0,0 +1,112 @@
+policy = $policy;
+ $this->sandboxedGlobally = $sandboxed;
+ }
+
+ /**
+ * Returns the token parser instances to add to the existing list.
+ *
+ * @return array An array of Twig_TokenParserInterface or Twig_TokenParserBrokerInterface instances
+ */
+ public function getTokenParsers()
+ {
+ return array(new Twig_TokenParser_Sandbox());
+ }
+
+ /**
+ * Returns the node visitor instances to add to the existing list.
+ *
+ * @return array An array of Twig_NodeVisitorInterface instances
+ */
+ public function getNodeVisitors()
+ {
+ return array(new Twig_NodeVisitor_Sandbox());
+ }
+
+ public function enableSandbox()
+ {
+ $this->sandboxed = true;
+ }
+
+ public function disableSandbox()
+ {
+ $this->sandboxed = false;
+ }
+
+ public function isSandboxed()
+ {
+ return $this->sandboxedGlobally || $this->sandboxed;
+ }
+
+ public function isSandboxedGlobally()
+ {
+ return $this->sandboxedGlobally;
+ }
+
+ public function setSecurityPolicy(Twig_Sandbox_SecurityPolicyInterface $policy)
+ {
+ $this->policy = $policy;
+ }
+
+ public function getSecurityPolicy()
+ {
+ return $this->policy;
+ }
+
+ public function checkSecurity($tags, $filters, $functions)
+ {
+ if ($this->isSandboxed()) {
+ $this->policy->checkSecurity($tags, $filters, $functions);
+ }
+ }
+
+ public function checkMethodAllowed($obj, $method)
+ {
+ if ($this->isSandboxed()) {
+ $this->policy->checkMethodAllowed($obj, $method);
+ }
+ }
+
+ public function checkPropertyAllowed($obj, $method)
+ {
+ if ($this->isSandboxed()) {
+ $this->policy->checkPropertyAllowed($obj, $method);
+ }
+ }
+
+ public function ensureToStringAllowed($obj)
+ {
+ if (is_object($obj)) {
+ $this->policy->checkMethodAllowed($obj, '__toString');
+ }
+
+ return $obj;
+ }
+
+ /**
+ * Returns the name of the extension.
+ *
+ * @return string The extension name
+ */
+ public function getName()
+ {
+ return 'sandbox';
+ }
+}
diff --git a/lib/twig/lib/Twig/ExtensionInterface.php b/lib/twig/lib/Twig/ExtensionInterface.php
new file mode 100755
index 0000000..0bfed88
--- /dev/null
+++ b/lib/twig/lib/Twig/ExtensionInterface.php
@@ -0,0 +1,84 @@
+
+ */
+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();
+}
diff --git a/lib/twig/lib/Twig/Filter.php b/lib/twig/lib/Twig/Filter.php
new file mode 100755
index 0000000..f27f08e
--- /dev/null
+++ b/lib/twig/lib/Twig/Filter.php
@@ -0,0 +1,69 @@
+
+ */
+abstract class Twig_Filter implements Twig_FilterInterface
+{
+ protected $options;
+ protected $arguments = array();
+
+ public function __construct(array $options = array())
+ {
+ $this->options = array_merge(array(
+ 'needs_environment' => false,
+ 'needs_context' => false,
+ 'pre_escape' => null,
+ ), $options);
+ }
+
+ public function setArguments($arguments)
+ {
+ $this->arguments = $arguments;
+ }
+
+ public function getArguments()
+ {
+ return $this->arguments;
+ }
+
+ public function needsEnvironment()
+ {
+ return $this->options['needs_environment'];
+ }
+
+ public function needsContext()
+ {
+ return $this->options['needs_context'];
+ }
+
+ public function getSafe(Twig_Node $filterArgs)
+ {
+ if (isset($this->options['is_safe'])) {
+ return $this->options['is_safe'];
+ }
+
+ if (isset($this->options['is_safe_callback'])) {
+ return call_user_func($this->options['is_safe_callback'], $filterArgs);
+ }
+
+ return array();
+ }
+
+ public function getPreEscape()
+ {
+ return $this->options['pre_escape'];
+ }
+}
diff --git a/lib/twig/lib/Twig/Filter/Function.php b/lib/twig/lib/Twig/Filter/Function.php
new file mode 100755
index 0000000..1de078b
--- /dev/null
+++ b/lib/twig/lib/Twig/Filter/Function.php
@@ -0,0 +1,33 @@
+
+ */
+class Twig_Filter_Function extends Twig_Filter
+{
+ protected $function;
+
+ public function __construct($function, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->function = $function;
+ }
+
+ public function compile()
+ {
+ return $this->function;
+ }
+}
diff --git a/lib/twig/lib/Twig/Filter/Method.php b/lib/twig/lib/Twig/Filter/Method.php
new file mode 100755
index 0000000..d831e0f
--- /dev/null
+++ b/lib/twig/lib/Twig/Filter/Method.php
@@ -0,0 +1,34 @@
+
+ */
+class Twig_Filter_Method extends Twig_Filter
+{
+ protected $extension, $method;
+
+ public function __construct(Twig_ExtensionInterface $extension, $method, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->extension = $extension;
+ $this->method = $method;
+ }
+
+ public function compile()
+ {
+ return sprintf('$this->env->getExtension(\'%s\')->%s', $this->extension->getName(), $this->method);
+ }
+}
diff --git a/lib/twig/lib/Twig/Filter/Node.php b/lib/twig/lib/Twig/Filter/Node.php
new file mode 100755
index 0000000..7481c05
--- /dev/null
+++ b/lib/twig/lib/Twig/Filter/Node.php
@@ -0,0 +1,37 @@
+
+ */
+class Twig_Filter_Node extends Twig_Filter
+{
+ protected $class;
+
+ public function __construct($class, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->class = $class;
+ }
+
+ public function getClass()
+ {
+ return $this->class;
+ }
+
+ public function compile()
+ {
+ }
+}
diff --git a/lib/twig/lib/Twig/FilterInterface.php b/lib/twig/lib/Twig/FilterInterface.php
new file mode 100755
index 0000000..866e932
--- /dev/null
+++ b/lib/twig/lib/Twig/FilterInterface.php
@@ -0,0 +1,38 @@
+
+ */
+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();
+}
diff --git a/lib/twig/lib/Twig/Function.php b/lib/twig/lib/Twig/Function.php
new file mode 100755
index 0000000..cd7643f
--- /dev/null
+++ b/lib/twig/lib/Twig/Function.php
@@ -0,0 +1,63 @@
+
+ */
+abstract class Twig_Function implements Twig_FunctionInterface
+{
+ protected $options;
+ protected $arguments = array();
+
+ public function __construct(array $options = array())
+ {
+ $this->options = array_merge(array(
+ 'needs_environment' => false,
+ 'needs_context' => false,
+ ), $options);
+ }
+
+ public function setArguments($arguments)
+ {
+ $this->arguments = $arguments;
+ }
+
+ public function getArguments()
+ {
+ return $this->arguments;
+ }
+
+ public function needsEnvironment()
+ {
+ return $this->options['needs_environment'];
+ }
+
+ public function needsContext()
+ {
+ return $this->options['needs_context'];
+ }
+
+ public function getSafe(Twig_Node $functionArgs)
+ {
+ if (isset($this->options['is_safe'])) {
+ return $this->options['is_safe'];
+ }
+
+ if (isset($this->options['is_safe_callback'])) {
+ return call_user_func($this->options['is_safe_callback'], $functionArgs);
+ }
+
+ return array();
+ }
+}
diff --git a/lib/twig/lib/Twig/Function/Function.php b/lib/twig/lib/Twig/Function/Function.php
new file mode 100755
index 0000000..3237d8c
--- /dev/null
+++ b/lib/twig/lib/Twig/Function/Function.php
@@ -0,0 +1,34 @@
+
+ */
+class Twig_Function_Function extends Twig_Function
+{
+ protected $function;
+
+ public function __construct($function, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->function = $function;
+ }
+
+ public function compile()
+ {
+ return $this->function;
+ }
+}
diff --git a/lib/twig/lib/Twig/Function/Method.php b/lib/twig/lib/Twig/Function/Method.php
new file mode 100755
index 0000000..7328566
--- /dev/null
+++ b/lib/twig/lib/Twig/Function/Method.php
@@ -0,0 +1,35 @@
+
+ */
+class Twig_Function_Method extends Twig_Function
+{
+ protected $extension, $method;
+
+ public function __construct(Twig_ExtensionInterface $extension, $method, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->extension = $extension;
+ $this->method = $method;
+ }
+
+ public function compile()
+ {
+ return sprintf('$this->env->getExtension(\'%s\')->%s', $this->extension->getName(), $this->method);
+ }
+}
diff --git a/lib/twig/lib/Twig/Function/Node.php b/lib/twig/lib/Twig/Function/Node.php
new file mode 100755
index 0000000..a687a84
--- /dev/null
+++ b/lib/twig/lib/Twig/Function/Node.php
@@ -0,0 +1,37 @@
+
+ */
+class Twig_Function_Node extends Twig_Filter
+{
+ protected $class;
+
+ public function __construct($class, array $options = array())
+ {
+ parent::__construct($options);
+
+ $this->class = $class;
+ }
+
+ public function getClass()
+ {
+ return $this->class;
+ }
+
+ public function compile()
+ {
+ }
+}
diff --git a/lib/twig/lib/Twig/FunctionInterface.php b/lib/twig/lib/Twig/FunctionInterface.php
new file mode 100755
index 0000000..d402d17
--- /dev/null
+++ b/lib/twig/lib/Twig/FunctionInterface.php
@@ -0,0 +1,37 @@
+
+ */
+interface Twig_FunctionInterface
+{
+ /**
+ * Compiles a function.
+ *
+ * @return string The PHP code for the function
+ */
+ function compile();
+
+ function needsEnvironment();
+
+ function needsContext();
+
+ function getSafe(Twig_Node $filterArgs);
+
+ function setArguments($arguments);
+
+ function getArguments();
+}
diff --git a/lib/twig/lib/Twig/Lexer.php b/lib/twig/lib/Twig/Lexer.php
new file mode 100755
index 0000000..4958cb6
--- /dev/null
+++ b/lib/twig/lib/Twig/Lexer.php
@@ -0,0 +1,406 @@
+
+ */
+class Twig_Lexer implements Twig_LexerInterface
+{
+ protected $tokens;
+ protected $code;
+ protected $cursor;
+ protected $lineno;
+ protected $end;
+ protected $state;
+ protected $states;
+ protected $brackets;
+ protected $env;
+ protected $filename;
+ protected $options;
+ protected $regexes;
+
+ const STATE_DATA = 0;
+ const STATE_BLOCK = 1;
+ const STATE_VAR = 2;
+ const STATE_STRING = 3;
+ const STATE_INTERPOLATION = 4;
+
+ const REGEX_NAME = '/[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*/A';
+ const REGEX_NUMBER = '/[0-9]+(?:\.[0-9]+)?/A';
+ const REGEX_STRING = '/"([^#"\\\\]*(?:\\\\.[^#"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\'/As';
+ const REGEX_DQ_STRING_DELIM = '/"/A';
+ const REGEX_DQ_STRING_PART = '/[^#"\\\\]*(?:(?:\\\\.|#(?!\{))[^#"\\\\]*)*/As';
+ const PUNCTUATION = '()[]{}?:.,|';
+
+ public function __construct(Twig_Environment $env, array $options = array())
+ {
+ $this->env = $env;
+
+ $this->options = array_merge(array(
+ 'tag_comment' => array('{#', '#}'),
+ 'tag_block' => array('{%', '%}'),
+ 'tag_variable' => array('{{', '}}'),
+ 'whitespace_trim' => '-',
+ 'interpolation' => array('#{', '}'),
+ ), $options);
+
+ $this->regexes = array(
+ 'lex_var' => '/\s*'.preg_quote($this->options['whitespace_trim'].$this->options['tag_variable'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_variable'][1], '/').'/A',
+ 'lex_block' => '/\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')\n?/A',
+ 'lex_raw_data' => '/('.preg_quote($this->options['tag_block'][0].$this->options['whitespace_trim'], '/').'|'.preg_quote($this->options['tag_block'][0], '/').')\s*endraw\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')/s',
+ 'operator' => $this->getOperatorRegex(),
+ 'lex_comment' => '/(?:'.preg_quote($this->options['whitespace_trim'], '/').preg_quote($this->options['tag_comment'][1], '/').'\s*|'.preg_quote($this->options['tag_comment'][1], '/').')\n?/s',
+ 'lex_block_raw' => '/\s*raw\s*(?:'.preg_quote($this->options['whitespace_trim'].$this->options['tag_block'][1], '/').'\s*|\s*'.preg_quote($this->options['tag_block'][1], '/').')/As',
+ 'lex_block_line' => '/\s*line\s+(\d+)\s*'.preg_quote($this->options['tag_block'][1], '/').'/As',
+ 'lex_tokens_start' => '/('.preg_quote($this->options['tag_variable'][0], '/').'|'.preg_quote($this->options['tag_block'][0], '/').'|'.preg_quote($this->options['tag_comment'][0], '/').')('.preg_quote($this->options['whitespace_trim'], '/').')?/s',
+ 'interpolation_start' => '/'.preg_quote($this->options['interpolation'][0], '/').'\s*/A',
+ 'interpolation_end' => '/\s*'.preg_quote($this->options['interpolation'][1], '/').'/A',
+ );
+ }
+
+ /**
+ * 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
+ */
+ public function tokenize($code, $filename = null)
+ {
+ if (function_exists('mb_internal_encoding') && ((int) ini_get('mbstring.func_overload')) & 2) {
+ $mbEncoding = mb_internal_encoding();
+ mb_internal_encoding('ASCII');
+ }
+
+ $this->code = str_replace(array("\r\n", "\r"), "\n", $code);
+ $this->filename = $filename;
+ $this->cursor = 0;
+ $this->lineno = 1;
+ $this->end = strlen($this->code);
+ $this->tokens = array();
+ $this->state = self::STATE_DATA;
+ $this->states = array();
+ $this->brackets = array();
+ $this->position = -1;
+
+ // find all token starts in one go
+ preg_match_all($this->regexes['lex_tokens_start'], $this->code, $matches, PREG_OFFSET_CAPTURE);
+ $this->positions = $matches;
+
+ while ($this->cursor < $this->end) {
+ // dispatch to the lexing functions depending
+ // on the current state
+ switch ($this->state) {
+ case self::STATE_DATA:
+ $this->lexData();
+ break;
+
+ case self::STATE_BLOCK:
+ $this->lexBlock();
+ break;
+
+ case self::STATE_VAR:
+ $this->lexVar();
+ break;
+
+ case self::STATE_STRING:
+ $this->lexString();
+ break;
+
+ case self::STATE_INTERPOLATION:
+ $this->lexInterpolation();
+ break;
+ }
+ }
+
+ $this->pushToken(Twig_Token::EOF_TYPE);
+
+ if (!empty($this->brackets)) {
+ list($expect, $lineno) = array_pop($this->brackets);
+ throw new Twig_Error_Syntax(sprintf('Unclosed "%s"', $expect), $lineno, $this->filename);
+ }
+
+ if (isset($mbEncoding)) {
+ mb_internal_encoding($mbEncoding);
+ }
+
+ return new Twig_TokenStream($this->tokens, $this->filename);
+ }
+
+ protected function lexData()
+ {
+ // if no matches are left we return the rest of the template as simple text token
+ if ($this->position == count($this->positions[0]) - 1) {
+ $this->pushToken(Twig_Token::TEXT_TYPE, substr($this->code, $this->cursor));
+ $this->cursor = $this->end;
+
+ return;
+ }
+
+ // Find the first token after the current cursor
+ $position = $this->positions[0][++$this->position];
+ while ($position[1] < $this->cursor) {
+ if ($this->position == count($this->positions[0]) - 1) {
+ return;
+ }
+ $position = $this->positions[0][++$this->position];
+ }
+
+ // push the template text first
+ $text = $textContent = substr($this->code, $this->cursor, $position[1] - $this->cursor);
+ if (isset($this->positions[2][$this->position][0])) {
+ $text = rtrim($text);
+ }
+ $this->pushToken(Twig_Token::TEXT_TYPE, $text);
+ $this->moveCursor($textContent.$position[0]);
+
+ switch ($this->positions[1][$this->position][0]) {
+ case $this->options['tag_comment'][0]:
+ $this->lexComment();
+ break;
+
+ case $this->options['tag_block'][0]:
+ // raw data?
+ if (preg_match($this->regexes['lex_block_raw'], $this->code, $match, null, $this->cursor)) {
+ $this->moveCursor($match[0]);
+ $this->lexRawData();
+ // {% line \d+ %}
+ } elseif (preg_match($this->regexes['lex_block_line'], $this->code, $match, null, $this->cursor)) {
+ $this->moveCursor($match[0]);
+ $this->lineno = (int) $match[1];
+ } else {
+ $this->pushToken(Twig_Token::BLOCK_START_TYPE);
+ $this->pushState(self::STATE_BLOCK);
+ }
+ break;
+
+ case $this->options['tag_variable'][0]:
+ $this->pushToken(Twig_Token::VAR_START_TYPE);
+ $this->pushState(self::STATE_VAR);
+ break;
+ }
+ }
+
+ protected function lexBlock()
+ {
+ if (empty($this->brackets) && preg_match($this->regexes['lex_block'], $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::BLOCK_END_TYPE);
+ $this->moveCursor($match[0]);
+ $this->popState();
+ } else {
+ $this->lexExpression();
+ }
+ }
+
+ protected function lexVar()
+ {
+ if (empty($this->brackets) && preg_match($this->regexes['lex_var'], $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::VAR_END_TYPE);
+ $this->moveCursor($match[0]);
+ $this->popState();
+ } else {
+ $this->lexExpression();
+ }
+ }
+
+ protected function lexExpression()
+ {
+ // whitespace
+ if (preg_match('/\s+/A', $this->code, $match, null, $this->cursor)) {
+ $this->moveCursor($match[0]);
+
+ if ($this->cursor >= $this->end) {
+ throw new Twig_Error_Syntax(sprintf('Unexpected end of file: Unclosed "%s"', $this->state === self::STATE_BLOCK ? 'block' : 'variable'));
+ }
+ }
+
+ // operators
+ if (preg_match($this->regexes['operator'], $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::OPERATOR_TYPE, $match[0]);
+ $this->moveCursor($match[0]);
+ }
+ // names
+ elseif (preg_match(self::REGEX_NAME, $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::NAME_TYPE, $match[0]);
+ $this->moveCursor($match[0]);
+ }
+ // numbers
+ elseif (preg_match(self::REGEX_NUMBER, $this->code, $match, null, $this->cursor)) {
+ $number = (float) $match[0]; // floats
+ if (ctype_digit($match[0]) && $number <= PHP_INT_MAX) {
+ $number = (int) $match[0]; // integers lower than the maximum
+ }
+ $this->pushToken(Twig_Token::NUMBER_TYPE, $number);
+ $this->moveCursor($match[0]);
+ }
+ // punctuation
+ elseif (false !== strpos(self::PUNCTUATION, $this->code[$this->cursor])) {
+ // opening bracket
+ if (false !== strpos('([{', $this->code[$this->cursor])) {
+ $this->brackets[] = array($this->code[$this->cursor], $this->lineno);
+ }
+ // closing bracket
+ elseif (false !== strpos(')]}', $this->code[$this->cursor])) {
+ if (empty($this->brackets)) {
+ throw new Twig_Error_Syntax(sprintf('Unexpected "%s"', $this->code[$this->cursor]), $this->lineno, $this->filename);
+ }
+
+ list($expect, $lineno) = array_pop($this->brackets);
+ if ($this->code[$this->cursor] != strtr($expect, '([{', ')]}')) {
+ throw new Twig_Error_Syntax(sprintf('Unclosed "%s"', $expect), $lineno, $this->filename);
+ }
+ }
+
+ $this->pushToken(Twig_Token::PUNCTUATION_TYPE, $this->code[$this->cursor]);
+ ++$this->cursor;
+ }
+ // strings
+ elseif (preg_match(self::REGEX_STRING, $this->code, $match, null, $this->cursor)) {
+ $this->pushToken(Twig_Token::STRING_TYPE, stripcslashes(substr($match[0], 1, -1)));
+ $this->moveCursor($match[0]);
+ }
+ // opening double quoted string
+ elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, null, $this->cursor)) {
+ $this->brackets[] = array('"', $this->lineno);
+ $this->pushState(self::STATE_STRING);
+ $this->moveCursor($match[0]);
+ }
+ // unlexable
+ else {
+ throw new Twig_Error_Syntax(sprintf('Unexpected character "%s"', $this->code[$this->cursor]), $this->lineno, $this->filename);
+ }
+ }
+
+ protected function lexRawData()
+ {
+ if (!preg_match($this->regexes['lex_raw_data'], $this->code, $match, PREG_OFFSET_CAPTURE, $this->cursor)) {
+ throw new Twig_Error_Syntax(sprintf('Unexpected end of file: Unclosed "block"'));
+ }
+
+ $text = substr($this->code, $this->cursor, $match[0][1] - $this->cursor);
+ $this->moveCursor($text.$match[0][0]);
+
+ if (false !== strpos($match[1][0], $this->options['whitespace_trim'])) {
+ $text = rtrim($text);
+ }
+
+ $this->pushToken(Twig_Token::TEXT_TYPE, $text);
+ }
+
+ protected function lexComment()
+ {
+ if (!preg_match($this->regexes['lex_comment'], $this->code, $match, PREG_OFFSET_CAPTURE, $this->cursor)) {
+ throw new Twig_Error_Syntax('Unclosed comment', $this->lineno, $this->filename);
+ }
+
+ $this->moveCursor(substr($this->code, $this->cursor, $match[0][1] - $this->cursor).$match[0][0]);
+ }
+
+ protected function lexString()
+ {
+ if (preg_match($this->regexes['interpolation_start'], $this->code, $match, null, $this->cursor)) {
+ $this->brackets[] = array($this->options['interpolation'][0], $this->lineno);
+ $this->pushToken(Twig_Token::INTERPOLATION_START_TYPE);
+ $this->moveCursor($match[0]);
+ $this->pushState(self::STATE_INTERPOLATION);
+
+ } elseif (preg_match(self::REGEX_DQ_STRING_PART, $this->code, $match, null, $this->cursor) && strlen($match[0]) > 0) {
+ $this->pushToken(Twig_Token::STRING_TYPE, stripcslashes($match[0]));
+ $this->moveCursor($match[0]);
+
+ } elseif (preg_match(self::REGEX_DQ_STRING_DELIM, $this->code, $match, null, $this->cursor)) {
+
+ list($expect, $lineno) = array_pop($this->brackets);
+ if ($this->code[$this->cursor] != '"') {
+ throw new Twig_Error_Syntax(sprintf('Unclosed "%s"', $expect), $lineno, $this->filename);
+ }
+
+ $this->popState();
+ ++$this->cursor;
+
+ return;
+ }
+ }
+
+ protected function lexInterpolation()
+ {
+ $bracket = end($this->brackets);
+ if ($this->options['interpolation'][0] === $bracket[0] && preg_match($this->regexes['interpolation_end'], $this->code, $match, null, $this->cursor)) {
+ array_pop($this->brackets);
+ $this->pushToken(Twig_Token::INTERPOLATION_END_TYPE);
+ $this->moveCursor($match[0]);
+ $this->popState();
+ } else {
+ $this->lexExpression();
+ }
+ }
+
+ protected function pushToken($type, $value = '')
+ {
+ // do not push empty text tokens
+ if (Twig_Token::TEXT_TYPE === $type && '' === $value) {
+ return;
+ }
+
+ $this->tokens[] = new Twig_Token($type, $value, $this->lineno);
+ }
+
+ protected function moveCursor($text)
+ {
+ $this->cursor += strlen($text);
+ $this->lineno += substr_count($text, "\n");
+ }
+
+ protected function getOperatorRegex()
+ {
+ $operators = array_merge(
+ array('='),
+ array_keys($this->env->getUnaryOperators()),
+ array_keys($this->env->getBinaryOperators())
+ );
+
+ $operators = array_combine($operators, array_map('strlen', $operators));
+ arsort($operators);
+
+ $regex = array();
+ foreach ($operators as $operator => $length) {
+ // an operator that ends with a character must be followed by
+ // a whitespace or a parenthesis
+ if (ctype_alpha($operator[$length - 1])) {
+ $regex[] = preg_quote($operator, '/').'(?=[\s()])';
+ } else {
+ $regex[] = preg_quote($operator, '/');
+ }
+ }
+
+ return '/'.implode('|', $regex).'/A';
+ }
+
+ protected function pushState($state)
+ {
+ $this->states[] = $this->state;
+ $this->state = $state;
+ }
+
+ protected function popState()
+ {
+ if (0 === count($this->states)) {
+ throw new Exception('Cannot pop state without a previous state');
+ }
+
+ $this->state = array_pop($this->states);
+ }
+}
diff --git a/lib/twig/lib/Twig/LexerInterface.php b/lib/twig/lib/Twig/LexerInterface.php
new file mode 100755
index 0000000..0223384
--- /dev/null
+++ b/lib/twig/lib/Twig/LexerInterface.php
@@ -0,0 +1,29 @@
+
+ */
+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 = null);
+}
diff --git a/lib/twig/lib/Twig/Loader/Array.php b/lib/twig/lib/Twig/Loader/Array.php
new file mode 100755
index 0000000..32bb7e4
--- /dev/null
+++ b/lib/twig/lib/Twig/Loader/Array.php
@@ -0,0 +1,102 @@
+
+ */
+class Twig_Loader_Array implements Twig_LoaderInterface
+{
+ protected $templates;
+
+ /**
+ * Constructor.
+ *
+ * @param array $templates An array of templates (keys are the names, and values are the source code)
+ *
+ * @see Twig_Loader
+ */
+ public function __construct(array $templates)
+ {
+ $this->templates = array();
+ foreach ($templates as $name => $template) {
+ $this->templates[$name] = $template;
+ }
+ }
+
+ /**
+ * Adds or overrides a template.
+ *
+ * @param string $name The template name
+ * @param string $template The template source
+ */
+ public function setTemplate($name, $template)
+ {
+ $this->templates[(string) $name] = $template;
+ }
+
+ /**
+ * 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)
+ {
+ $name = (string) $name;
+ if (!isset($this->templates[$name])) {
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
+ }
+
+ return $this->templates[$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)
+ {
+ $name = (string) $name;
+ if (!isset($this->templates[$name])) {
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
+ }
+
+ return $this->templates[$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)
+ {
+ $name = (string) $name;
+ if (!isset($this->templates[$name])) {
+ throw new Twig_Error_Loader(sprintf('Template "%s" is not defined.', $name));
+ }
+
+ return true;
+ }
+}
diff --git a/lib/twig/lib/Twig/Loader/Chain.php b/lib/twig/lib/Twig/Loader/Chain.php
new file mode 100755
index 0000000..48dd8b8
--- /dev/null
+++ b/lib/twig/lib/Twig/Loader/Chain.php
@@ -0,0 +1,100 @@
+
+ */
+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));
+ }
+}
diff --git a/lib/twig/lib/Twig/Loader/Filesystem.php b/lib/twig/lib/Twig/Loader/Filesystem.php
new file mode 100755
index 0000000..be348aa
--- /dev/null
+++ b/lib/twig/lib/Twig/Loader/Filesystem.php
@@ -0,0 +1,152 @@
+
+ */
+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));
+ }
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Loader/String.php b/lib/twig/lib/Twig/Loader/String.php
new file mode 100755
index 0000000..26eb009
--- /dev/null
+++ b/lib/twig/lib/Twig/Loader/String.php
@@ -0,0 +1,59 @@
+
+ */
+class Twig_Loader_String implements Twig_LoaderInterface
+{
+ /**
+ * 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 $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 $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 true;
+ }
+}
diff --git a/lib/twig/lib/Twig/LoaderInterface.php b/lib/twig/lib/Twig/LoaderInterface.php
new file mode 100755
index 0000000..d8ae444
--- /dev/null
+++ b/lib/twig/lib/Twig/LoaderInterface.php
@@ -0,0 +1,53 @@
+
+ */
+interface Twig_LoaderInterface
+{
+ /**
+ * 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
+ *
+ * @throws Twig_Error_Loader When $name is not found
+ */
+ function getSource($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
+ *
+ * @throws Twig_Error_Loader When $name is not found
+ */
+ 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
+ *
+ * @return Boolean true if the template is fresh, false otherwise
+ *
+ * @throws Twig_Error_Loader When $name is not found
+ */
+ function isFresh($name, $time);
+}
diff --git a/lib/twig/lib/Twig/Markup.php b/lib/twig/lib/Twig/Markup.php
new file mode 100755
index 0000000..7099b29
--- /dev/null
+++ b/lib/twig/lib/Twig/Markup.php
@@ -0,0 +1,38 @@
+
+ */
+class Twig_Markup implements Countable
+{
+ protected $content;
+ protected $charset;
+
+ public function __construct($content, $charset)
+ {
+ $this->content = (string) $content;
+ $this->charset = $charset;
+ }
+
+ public function __toString()
+ {
+ return $this->content;
+ }
+
+ public function count()
+ {
+ return function_exists('mb_get_info') ? mb_strlen($this->content, $this->charset) : strlen($this->content);
+ }
+}
diff --git a/lib/twig/lib/Twig/Node.php b/lib/twig/lib/Twig/Node.php
new file mode 100755
index 0000000..651ffc4
--- /dev/null
+++ b/lib/twig/lib/Twig/Node.php
@@ -0,0 +1,227 @@
+
+ */
+class Twig_Node implements Twig_NodeInterface
+{
+ protected $nodes;
+ protected $attributes;
+ protected $lineno;
+ protected $tag;
+
+ /**
+ * Constructor.
+ *
+ * The nodes are automatically made available as properties ($this->node).
+ * The attributes are automatically made available as array items ($this['name']).
+ *
+ * @param array $nodes An array of named nodes
+ * @param array $attributes An array of attributes (should not be nodes)
+ * @param integer $lineno The line number
+ * @param string $tag The tag name associated with the Node
+ */
+ public function __construct(array $nodes = array(), array $attributes = array(), $lineno = 0, $tag = null)
+ {
+ $this->nodes = $nodes;
+ $this->attributes = $attributes;
+ $this->lineno = $lineno;
+ $this->tag = $tag;
+ }
+
+ public function __toString()
+ {
+ $attributes = array();
+ foreach ($this->attributes as $name => $value) {
+ $attributes[] = sprintf('%s: %s', $name, str_replace("\n", '', var_export($value, true)));
+ }
+
+ $repr = array(get_class($this).'('.implode(', ', $attributes));
+
+ if (count($this->nodes)) {
+ foreach ($this->nodes as $name => $node) {
+ $len = strlen($name) + 4;
+ $noderepr = array();
+ foreach (explode("\n", (string) $node) as $line) {
+ $noderepr[] = str_repeat(' ', $len).$line;
+ }
+
+ $repr[] = sprintf(' %s: %s', $name, ltrim(implode("\n", $noderepr)));
+ }
+
+ $repr[] = ')';
+ } else {
+ $repr[0] .= ')';
+ }
+
+ return implode("\n", $repr);
+ }
+
+ public function toXml($asDom = false)
+ {
+ $dom = new DOMDocument('1.0', 'UTF-8');
+ $dom->formatOutput = true;
+ $dom->appendChild($xml = $dom->createElement('twig'));
+
+ $xml->appendChild($node = $dom->createElement('node'));
+ $node->setAttribute('class', get_class($this));
+
+ foreach ($this->attributes as $name => $value) {
+ $node->appendChild($attribute = $dom->createElement('attribute'));
+ $attribute->setAttribute('name', $name);
+ $attribute->appendChild($dom->createTextNode($value));
+ }
+
+ foreach ($this->nodes as $name => $n) {
+ if (null === $n) {
+ continue;
+ }
+
+ $child = $n->toXml(true)->getElementsByTagName('node')->item(0);
+ $child = $dom->importNode($child, true);
+ $child->setAttribute('name', $name);
+
+ $node->appendChild($child);
+ }
+
+ return $asDom ? $dom : $dom->saveXml();
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ foreach ($this->nodes as $node) {
+ $node->compile($compiler);
+ }
+ }
+
+ public function getLine()
+ {
+ return $this->lineno;
+ }
+
+ public function getNodeTag()
+ {
+ return $this->tag;
+ }
+
+ /**
+ * Returns true if the attribute is defined.
+ *
+ * @param string The attribute name
+ *
+ * @return Boolean true if the attribute is defined, false otherwise
+ */
+ public function hasAttribute($name)
+ {
+ return array_key_exists($name, $this->attributes);
+ }
+
+ /**
+ * Gets an attribute.
+ *
+ * @param string The attribute name
+ *
+ * @return mixed The attribute value
+ */
+ public function getAttribute($name)
+ {
+ if (!array_key_exists($name, $this->attributes)) {
+ throw new Twig_Error_Runtime(sprintf('Attribute "%s" does not exist for Node "%s".', $name, get_class($this)));
+ }
+
+ return $this->attributes[$name];
+ }
+
+ /**
+ * Sets an attribute.
+ *
+ * @param string The attribute name
+ * @param mixed The attribute value
+ */
+ public function setAttribute($name, $value)
+ {
+ $this->attributes[$name] = $value;
+ }
+
+ /**
+ * Removes an attribute.
+ *
+ * @param string The attribute name
+ */
+ public function removeAttribute($name)
+ {
+ unset($this->attributes[$name]);
+ }
+
+ /**
+ * Returns true if the node with the given identifier exists.
+ *
+ * @param string The node name
+ *
+ * @return Boolean true if the node with the given name exists, false otherwise
+ */
+ public function hasNode($name)
+ {
+ return array_key_exists($name, $this->nodes);
+ }
+
+ /**
+ * Gets a node by name.
+ *
+ * @param string The node name
+ *
+ * @return Twig_Node A Twig_Node instance
+ */
+ public function getNode($name)
+ {
+ if (!array_key_exists($name, $this->nodes)) {
+ throw new Twig_Error_Runtime(sprintf('Node "%s" does not exist for Node "%s".', $name, get_class($this)));
+ }
+
+ return $this->nodes[$name];
+ }
+
+ /**
+ * Sets a node.
+ *
+ * @param string The node name
+ * @param Twig_Node A Twig_Node instance
+ */
+ public function setNode($name, $node = null)
+ {
+ $this->nodes[$name] = $node;
+ }
+
+ /**
+ * Removes a node by name.
+ *
+ * @param string The node name
+ */
+ public function removeNode($name)
+ {
+ unset($this->nodes[$name]);
+ }
+
+ public function count()
+ {
+ return count($this->nodes);
+ }
+
+ public function getIterator()
+ {
+ return new ArrayIterator($this->nodes);
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/AutoEscape.php b/lib/twig/lib/Twig/Node/AutoEscape.php
new file mode 100755
index 0000000..a0c2ee6
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/AutoEscape.php
@@ -0,0 +1,40 @@
+
+ */
+class Twig_Node_AutoEscape extends Twig_Node
+{
+ public function __construct($value, Twig_NodeInterface $body, $lineno, $tag = 'autoescape')
+ {
+ parent::__construct(array('body' => $body), array('value' => $value), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('body'));
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Block.php b/lib/twig/lib/Twig/Node/Block.php
new file mode 100755
index 0000000..5548ad0
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Block.php
@@ -0,0 +1,45 @@
+
+ */
+class Twig_Node_Block extends Twig_Node
+{
+ public function __construct($name, Twig_NodeInterface $body, $lineno, $tag = null)
+ {
+ parent::__construct(array('body' => $body), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write(sprintf("public function block_%s(\$context, array \$blocks = array())\n", $this->getAttribute('name')), "{\n")
+ ->indent()
+ ;
+
+ $compiler
+ ->subcompile($this->getNode('body'))
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/BlockReference.php b/lib/twig/lib/Twig/Node/BlockReference.php
new file mode 100755
index 0000000..53f6287
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/BlockReference.php
@@ -0,0 +1,38 @@
+
+ */
+class Twig_Node_BlockReference extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct($name, $lineno, $tag = null)
+ {
+ parent::__construct(array(), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write(sprintf("\$this->displayBlock('%s', \$context, \$blocks);\n", $this->getAttribute('name')))
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Body.php b/lib/twig/lib/Twig/Node/Body.php
new file mode 100755
index 0000000..f72bf50
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Body.php
@@ -0,0 +1,20 @@
+
+ */
+class Twig_Node_Body extends Twig_Node
+{
+}
diff --git a/lib/twig/lib/Twig/Node/Do.php b/lib/twig/lib/Twig/Node/Do.php
new file mode 100755
index 0000000..aa419d9
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Do.php
@@ -0,0 +1,39 @@
+
+ */
+class Twig_Node_Do extends Twig_Node
+{
+ public function __construct(Twig_Node_Expression $expr, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('')
+ ->subcompile($this->getNode('expr'))
+ ->raw(";\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression.php b/lib/twig/lib/Twig/Node/Expression.php
new file mode 100755
index 0000000..13b170e
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression.php
@@ -0,0 +1,21 @@
+
+ */
+abstract class Twig_Node_Expression extends Twig_Node
+{
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Array.php b/lib/twig/lib/Twig/Node/Expression/Array.php
new file mode 100755
index 0000000..1da785f
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Array.php
@@ -0,0 +1,86 @@
+index = -1;
+ foreach ($this->getKeyValuePairs() as $pair) {
+ if ($pair['key'] instanceof Twig_Node_Expression_Constant && ctype_digit((string) $pair['key']->getAttribute('value')) && $pair['key']->getAttribute('value') > $this->index) {
+ $this->index = $pair['key']->getAttribute('value');
+ }
+ }
+ }
+
+ public function getKeyValuePairs()
+ {
+ $pairs = array();
+
+ foreach (array_chunk($this->nodes, 2) as $pair) {
+ $pairs[] = array(
+ 'key' => $pair[0],
+ 'value' => $pair[1],
+ );
+ }
+
+ return $pairs;
+ }
+
+ public function hasElement(Twig_Node_Expression $key)
+ {
+ foreach ($this->getKeyValuePairs() as $pair) {
+ // we compare the string representation of the keys
+ // to avoid comparing the line numbers which are not relevant here.
+ if ((string) $key == (string) $pair['key']) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public function addElement(Twig_Node_Expression $value, Twig_Node_Expression $key = null)
+ {
+ if (null === $key) {
+ $key = new Twig_Node_Expression_Constant(++$this->index, $value->getLine());
+ }
+
+ array_push($this->nodes, $key, $value);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->raw('array(');
+ $first = true;
+ foreach ($this->getKeyValuePairs() as $pair) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $first = false;
+
+ $compiler
+ ->subcompile($pair['key'])
+ ->raw(' => ')
+ ->subcompile($pair['value'])
+ ;
+ }
+ $compiler->raw(')');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/AssignName.php b/lib/twig/lib/Twig/Node/Expression/AssignName.php
new file mode 100755
index 0000000..2ddea78
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/AssignName.php
@@ -0,0 +1,28 @@
+raw('$context[')
+ ->string($this->getAttribute('name'))
+ ->raw(']')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary.php b/lib/twig/lib/Twig/Node/Expression/Binary.php
new file mode 100755
index 0000000..9dd5de2
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary.php
@@ -0,0 +1,40 @@
+ $left, 'right' => $right), array(), $lineno);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('left'))
+ ->raw(' ')
+ ;
+ $this->operator($compiler);
+ $compiler
+ ->raw(' ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ abstract public function operator(Twig_Compiler $compiler);
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Add.php b/lib/twig/lib/Twig/Node/Expression/Binary/Add.php
new file mode 100755
index 0000000..0ef8e11
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Add.php
@@ -0,0 +1,18 @@
+raw('+');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/And.php b/lib/twig/lib/Twig/Node/Expression/Binary/And.php
new file mode 100755
index 0000000..d5752eb
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/And.php
@@ -0,0 +1,18 @@
+raw('&&');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseAnd.php b/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseAnd.php
new file mode 100755
index 0000000..9a46d84
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseAnd.php
@@ -0,0 +1,18 @@
+raw('&');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseOr.php b/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseOr.php
new file mode 100755
index 0000000..058a20b
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseOr.php
@@ -0,0 +1,18 @@
+raw('|');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseXor.php b/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseXor.php
new file mode 100755
index 0000000..f4da73d
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/BitwiseXor.php
@@ -0,0 +1,18 @@
+raw('^');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Concat.php b/lib/twig/lib/Twig/Node/Expression/Binary/Concat.php
new file mode 100755
index 0000000..f9a6462
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Concat.php
@@ -0,0 +1,18 @@
+raw('.');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Div.php b/lib/twig/lib/Twig/Node/Expression/Binary/Div.php
new file mode 100755
index 0000000..e0797a6
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Div.php
@@ -0,0 +1,18 @@
+raw('/');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Equal.php b/lib/twig/lib/Twig/Node/Expression/Binary/Equal.php
new file mode 100755
index 0000000..7b1236d
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Equal.php
@@ -0,0 +1,17 @@
+raw('==');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/FloorDiv.php b/lib/twig/lib/Twig/Node/Expression/Binary/FloorDiv.php
new file mode 100755
index 0000000..7fbd055
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/FloorDiv.php
@@ -0,0 +1,29 @@
+raw('intval(floor(');
+ parent::compile($compiler);
+ $compiler->raw('))');
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('/');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Greater.php b/lib/twig/lib/Twig/Node/Expression/Binary/Greater.php
new file mode 100755
index 0000000..a110bd9
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Greater.php
@@ -0,0 +1,17 @@
+raw('>');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/GreaterEqual.php b/lib/twig/lib/Twig/Node/Expression/Binary/GreaterEqual.php
new file mode 100755
index 0000000..3754fed
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/GreaterEqual.php
@@ -0,0 +1,17 @@
+raw('>=');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/In.php b/lib/twig/lib/Twig/Node/Expression/Binary/In.php
new file mode 100755
index 0000000..788f937
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/In.php
@@ -0,0 +1,33 @@
+raw('twig_in_filter(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('in');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Less.php b/lib/twig/lib/Twig/Node/Expression/Binary/Less.php
new file mode 100755
index 0000000..45fd300
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Less.php
@@ -0,0 +1,17 @@
+raw('<');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/LessEqual.php b/lib/twig/lib/Twig/Node/Expression/Binary/LessEqual.php
new file mode 100755
index 0000000..e38e257
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/LessEqual.php
@@ -0,0 +1,17 @@
+raw('<=');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Mod.php b/lib/twig/lib/Twig/Node/Expression/Binary/Mod.php
new file mode 100755
index 0000000..9924114
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Mod.php
@@ -0,0 +1,18 @@
+raw('%');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Mul.php b/lib/twig/lib/Twig/Node/Expression/Binary/Mul.php
new file mode 100755
index 0000000..c91529c
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Mul.php
@@ -0,0 +1,18 @@
+raw('*');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/NotEqual.php b/lib/twig/lib/Twig/Node/Expression/Binary/NotEqual.php
new file mode 100755
index 0000000..26867ba
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/NotEqual.php
@@ -0,0 +1,17 @@
+raw('!=');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/NotIn.php b/lib/twig/lib/Twig/Node/Expression/Binary/NotIn.php
new file mode 100755
index 0000000..f347b7b
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/NotIn.php
@@ -0,0 +1,33 @@
+raw('!twig_in_filter(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('not in');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Or.php b/lib/twig/lib/Twig/Node/Expression/Binary/Or.php
new file mode 100755
index 0000000..adba49c
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Or.php
@@ -0,0 +1,18 @@
+raw('||');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Power.php b/lib/twig/lib/Twig/Node/Expression/Binary/Power.php
new file mode 100755
index 0000000..b2c5904
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Power.php
@@ -0,0 +1,33 @@
+raw('pow(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('**');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Range.php b/lib/twig/lib/Twig/Node/Expression/Binary/Range.php
new file mode 100755
index 0000000..bea4f2a
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Range.php
@@ -0,0 +1,33 @@
+raw('range(')
+ ->subcompile($this->getNode('left'))
+ ->raw(', ')
+ ->subcompile($this->getNode('right'))
+ ->raw(')')
+ ;
+ }
+
+ public function operator(Twig_Compiler $compiler)
+ {
+ return $compiler->raw('..');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Binary/Sub.php b/lib/twig/lib/Twig/Node/Expression/Binary/Sub.php
new file mode 100755
index 0000000..d446399
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Binary/Sub.php
@@ -0,0 +1,18 @@
+raw('-');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/BlockReference.php b/lib/twig/lib/Twig/Node/Expression/BlockReference.php
new file mode 100755
index 0000000..174d909
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/BlockReference.php
@@ -0,0 +1,52 @@
+
+ */
+class Twig_Node_Expression_BlockReference extends Twig_Node_Expression
+{
+ public function __construct(Twig_NodeInterface $name, $asString = false, $lineno, $tag = null)
+ {
+ parent::__construct(array('name' => $name), array('as_string' => $asString, 'output' => false), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ if ($this->getAttribute('as_string')) {
+ $compiler->raw('(string) ');
+ }
+
+ if ($this->getAttribute('output')) {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("\$this->displayBlock(")
+ ->subcompile($this->getNode('name'))
+ ->raw(", \$context, \$blocks);\n")
+ ;
+ } else {
+ $compiler
+ ->raw("\$this->renderBlock(")
+ ->subcompile($this->getNode('name'))
+ ->raw(", \$context, \$blocks)")
+ ;
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Conditional.php b/lib/twig/lib/Twig/Node/Expression/Conditional.php
new file mode 100755
index 0000000..edcb1e2
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Conditional.php
@@ -0,0 +1,31 @@
+ $expr1, 'expr2' => $expr2, 'expr3' => $expr3), array(), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('((')
+ ->subcompile($this->getNode('expr1'))
+ ->raw(') ? (')
+ ->subcompile($this->getNode('expr2'))
+ ->raw(') : (')
+ ->subcompile($this->getNode('expr3'))
+ ->raw('))')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Constant.php b/lib/twig/lib/Twig/Node/Expression/Constant.php
new file mode 100755
index 0000000..a91dc69
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Constant.php
@@ -0,0 +1,23 @@
+ $value), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->repr($this->getAttribute('value'));
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/ExtensionReference.php b/lib/twig/lib/Twig/Node/Expression/ExtensionReference.php
new file mode 100755
index 0000000..cb4efad
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/ExtensionReference.php
@@ -0,0 +1,34 @@
+
+ */
+class Twig_Node_Expression_ExtensionReference extends Twig_Node_Expression
+{
+ public function __construct($name, $lineno, $tag = null)
+ {
+ parent::__construct(array(), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->raw(sprintf("\$this->env->getExtension('%s')", $this->getAttribute('name')));
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Filter.php b/lib/twig/lib/Twig/Node/Expression/Filter.php
new file mode 100755
index 0000000..8a0903a
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Filter.php
@@ -0,0 +1,61 @@
+ $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(')');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Filter/Default.php b/lib/twig/lib/Twig/Node/Expression/Filter/Default.php
new file mode 100755
index 0000000..1cb3342
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Filter/Default.php
@@ -0,0 +1,44 @@
+
+ * {{ var.foo|default('foo item on var is not defined') }}
+ *
+ *
+ * @package twig
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Filter_Default extends Twig_Node_Expression_Filter
+{
+ public function __construct(Twig_NodeInterface $node, Twig_Node_Expression_Constant $filterName, Twig_NodeInterface $arguments, $lineno, $tag = null)
+ {
+ $default = new Twig_Node_Expression_Filter($node, new Twig_Node_Expression_Constant('_default', $node->getLine()), $arguments, $node->getLine());
+
+ if ('default' === $filterName->getAttribute('value') && ($node instanceof Twig_Node_Expression_Name || $node instanceof Twig_Node_Expression_GetAttr)) {
+ $test = new Twig_Node_Expression_Test_Defined(clone $node, 'defined', new Twig_Node(), $node->getLine());
+ $false = count($arguments) ? $arguments->getNode(0) : new Twig_Node_Expression_Constant('', $node->getLine());
+
+ $node = new Twig_Node_Expression_Conditional($test, $default, $false, $node->getLine());
+ } else {
+ $node = $default;
+ }
+
+ parent::__construct($node, $filterName, $arguments, $lineno, $tag);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('node'));
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Function.php b/lib/twig/lib/Twig/Node/Expression/Function.php
new file mode 100755
index 0000000..9342bb1
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Function.php
@@ -0,0 +1,66 @@
+ $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(')');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/GetAttr.php b/lib/twig/lib/Twig/Node/Expression/GetAttr.php
new file mode 100755
index 0000000..6498444
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/GetAttr.php
@@ -0,0 +1,53 @@
+ $node, 'attribute' => $attribute, 'arguments' => $arguments), array('type' => $type, 'is_defined_test' => false, 'ignore_strict_check' => false), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ if (function_exists('twig_template_get_attributes')) {
+ $compiler->raw('twig_template_get_attributes($this, ');
+ } else {
+ $compiler->raw('$this->getAttribute(');
+ }
+
+ if ($this->getAttribute('ignore_strict_check')) {
+ $this->getNode('node')->setAttribute('ignore_strict_check', true);
+ }
+
+ $compiler->subcompile($this->getNode('node'));
+
+ $compiler->raw(', ')->subcompile($this->getNode('attribute'));
+
+ if (count($this->getNode('arguments')) || Twig_TemplateInterface::ANY_CALL !== $this->getAttribute('type') || $this->getAttribute('is_defined_test') || $this->getAttribute('ignore_strict_check')) {
+ $compiler->raw(', ')->subcompile($this->getNode('arguments'));
+
+ if (Twig_TemplateInterface::ANY_CALL !== $this->getAttribute('type') || $this->getAttribute('is_defined_test') || $this->getAttribute('ignore_strict_check')) {
+ $compiler->raw(', ')->repr($this->getAttribute('type'));
+ }
+
+ if ($this->getAttribute('is_defined_test') || $this->getAttribute('ignore_strict_check')) {
+ $compiler->raw(', '.($this->getAttribute('is_defined_test') ? 'true' : 'false'));
+ }
+
+ if ($this->getAttribute('ignore_strict_check')) {
+ $compiler->raw(', '.($this->getAttribute('ignore_strict_check') ? 'true' : 'false'));
+ }
+ }
+
+ $compiler->raw(')');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/MethodCall.php b/lib/twig/lib/Twig/Node/Expression/MethodCall.php
new file mode 100755
index 0000000..5093808
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/MethodCall.php
@@ -0,0 +1,37 @@
+ $node, 'arguments' => $arguments), array('method' => $method, 'safe' => false), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->subcompile($this->getNode('node'))
+ ->raw('->')
+ ->raw($this->getAttribute('method'))
+ ->raw('(')
+ ;
+ $first = true;
+ foreach ($this->getNode('arguments')->getKeyValuePairs() as $pair) {
+ if (!$first) {
+ $compiler->raw(', ');
+ }
+ $first = false;
+
+ $compiler->subcompile($pair['value']);
+ }
+ $compiler->raw(')');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Name.php b/lib/twig/lib/Twig/Node/Expression/Name.php
new file mode 100755
index 0000000..8f5a1ea
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Name.php
@@ -0,0 +1,76 @@
+ '$this',
+ '_context' => '$context',
+ '_charset' => '$this->env->getCharset()',
+ );
+
+ public function __construct($name, $lineno)
+ {
+ parent::__construct(array(), array('name' => $name, 'is_defined_test' => false, 'ignore_strict_check' => false), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $name = $this->getAttribute('name');
+
+ if ($this->getAttribute('is_defined_test')) {
+ if ($this->isSpecial()) {
+ $compiler->repr(true);
+ } else {
+ $compiler->raw('array_key_exists(')->repr($name)->raw(', $context)');
+ }
+ } elseif ($this->isSpecial()) {
+ $compiler->raw($this->specialVars[$name]);
+ } else {
+ // remove the non-PHP 5.4 version when PHP 5.3 support is dropped
+ // as the non-optimized version is just a workaround for slow ternary operator
+ // when the context has a lot of variables
+ if (version_compare(phpversion(), '5.4.0RC1', '>=') && ($this->getAttribute('ignore_strict_check') || !$compiler->getEnvironment()->isStrictVariables())) {
+ // PHP 5.4 ternary operator performance was optimized
+ $compiler
+ ->raw('(isset($context[')
+ ->string($name)
+ ->raw(']) ? $context[')
+ ->string($name)
+ ->raw('] : null)')
+ ;
+ } else {
+ $compiler
+ ->raw('$this->getContext($context, ')
+ ->string($name)
+ ;
+
+ if ($this->getAttribute('ignore_strict_check')) {
+ $compiler->raw(', true');
+ }
+
+ $compiler
+ ->raw(')')
+ ;
+ }
+ }
+ }
+
+ public function isSpecial()
+ {
+ return isset($this->specialVars[$this->getAttribute('name')]);
+ }
+
+ public function isSimple()
+ {
+ return !$this->isSpecial() && !$this->getAttribute('is_defined_test');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Parent.php b/lib/twig/lib/Twig/Node/Expression/Parent.php
new file mode 100755
index 0000000..ea97349
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Parent.php
@@ -0,0 +1,48 @@
+
+ */
+class Twig_Node_Expression_Parent extends Twig_Node_Expression
+{
+ public function __construct($name, $lineno, $tag = null)
+ {
+ parent::__construct(array(), array('output' => false, 'name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ if ($this->getAttribute('output')) {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("\$this->displayParentBlock(")
+ ->string($this->getAttribute('name'))
+ ->raw(", \$context, \$blocks);\n")
+ ;
+ } else {
+ $compiler
+ ->raw("\$this->renderParentBlock(")
+ ->string($this->getAttribute('name'))
+ ->raw(", \$context, \$blocks)")
+ ;
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/TempName.php b/lib/twig/lib/Twig/Node/Expression/TempName.php
new file mode 100755
index 0000000..eea9d47
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/TempName.php
@@ -0,0 +1,22 @@
+ $name), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->raw('$_')->raw($this->getAttribute('name'))->raw('_');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test.php b/lib/twig/lib/Twig/Node/Expression/Test.php
new file mode 100755
index 0000000..4e0b25e
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test.php
@@ -0,0 +1,54 @@
+ $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(')');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test/Constant.php b/lib/twig/lib/Twig/Node/Expression/Test/Constant.php
new file mode 100755
index 0000000..6e6b6fd
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test/Constant.php
@@ -0,0 +1,36 @@
+
+ * {% if post.status is constant('Post::PUBLISHED') %}
+ * the status attribute is exactly the same as Post::PUBLISHED
+ * {% endif %}
+ *
+ *
+ * @package twig
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Constant extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' === constant(')
+ ->subcompile($this->getNode('arguments')->getNode(0))
+ ->raw('))')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test/Defined.php b/lib/twig/lib/Twig/Node/Expression/Test/Defined.php
new file mode 100755
index 0000000..e7c6828
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test/Defined.php
@@ -0,0 +1,55 @@
+
+ * {# defined works with variable names and variable attributes #}
+ * {% if foo is defined %}
+ * {# ... #}
+ * {% endif %}
+ *
+ *
+ * @package twig
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Defined extends Twig_Node_Expression_Test
+{
+ public function __construct(Twig_NodeInterface $node, $name, Twig_NodeInterface $arguments = null, $lineno)
+ {
+ parent::__construct($node, $name, $arguments, $lineno);
+
+ if ($node instanceof Twig_Node_Expression_Name) {
+ $node->setAttribute('is_defined_test', true);
+ } elseif ($node instanceof Twig_Node_Expression_GetAttr) {
+ $node->setAttribute('is_defined_test', true);
+
+ $this->changeIgnoreStrictCheck($node);
+ } else {
+ throw new Twig_Error_Syntax('The "defined" test only works with simple variables', $this->getLine());
+ }
+ }
+
+ protected function changeIgnoreStrictCheck(Twig_Node_Expression_GetAttr $node)
+ {
+ $node->setAttribute('ignore_strict_check', true);
+
+ if ($node->getNode('node') instanceof Twig_Node_Expression_GetAttr) {
+ $this->changeIgnoreStrictCheck($node->getNode('node'));
+ }
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('node'));
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test/Divisibleby.php b/lib/twig/lib/Twig/Node/Expression/Test/Divisibleby.php
new file mode 100755
index 0000000..05563d5
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test/Divisibleby.php
@@ -0,0 +1,34 @@
+
+ * {% if loop.index is divisibleby(3) %}
+ *
+ *
+ * @package twig
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Divisibleby extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(0 == ')
+ ->subcompile($this->getNode('node'))
+ ->raw(' % ')
+ ->subcompile($this->getNode('arguments')->getNode(0))
+ ->raw(')')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test/Even.php b/lib/twig/lib/Twig/Node/Expression/Test/Even.php
new file mode 100755
index 0000000..08e6d82
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test/Even.php
@@ -0,0 +1,33 @@
+
+ * {{ var is even }}
+ *
+ *
+ * @package twig
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Even extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' % 2 == 0')
+ ->raw(')')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test/Null.php b/lib/twig/lib/Twig/Node/Expression/Test/Null.php
new file mode 100755
index 0000000..55061db
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test/Null.php
@@ -0,0 +1,32 @@
+
+ * {{ var is none }}
+ *
+ *
+ * @package twig
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Null extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(null === ')
+ ->subcompile($this->getNode('node'))
+ ->raw(')')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test/Odd.php b/lib/twig/lib/Twig/Node/Expression/Test/Odd.php
new file mode 100755
index 0000000..5fecebc
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test/Odd.php
@@ -0,0 +1,33 @@
+
+ * {{ var is odd }}
+ *
+ *
+ * @package twig
+ * @author Fabien Potencier
+ */
+class Twig_Node_Expression_Test_Odd extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' % 2 == 1')
+ ->raw(')')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Test/Sameas.php b/lib/twig/lib/Twig/Node/Expression/Test/Sameas.php
new file mode 100755
index 0000000..8639b96
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Test/Sameas.php
@@ -0,0 +1,30 @@
+
+ */
+class Twig_Node_Expression_Test_Sameas extends Twig_Node_Expression_Test
+{
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->raw('(')
+ ->subcompile($this->getNode('node'))
+ ->raw(' === ')
+ ->subcompile($this->getNode('arguments')->getNode(0))
+ ->raw(')')
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Unary.php b/lib/twig/lib/Twig/Node/Expression/Unary.php
new file mode 100755
index 0000000..c514388
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Unary.php
@@ -0,0 +1,30 @@
+ $node), array(), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->raw('(');
+ $this->operator($compiler);
+ $compiler
+ ->subcompile($this->getNode('node'))
+ ->raw(')')
+ ;
+ }
+
+ abstract public function operator(Twig_Compiler $compiler);
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Unary/Neg.php b/lib/twig/lib/Twig/Node/Expression/Unary/Neg.php
new file mode 100755
index 0000000..2a3937e
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Unary/Neg.php
@@ -0,0 +1,18 @@
+raw('-');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Unary/Not.php b/lib/twig/lib/Twig/Node/Expression/Unary/Not.php
new file mode 100755
index 0000000..f94073c
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Unary/Not.php
@@ -0,0 +1,18 @@
+raw('!');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Expression/Unary/Pos.php b/lib/twig/lib/Twig/Node/Expression/Unary/Pos.php
new file mode 100755
index 0000000..04edb52
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Expression/Unary/Pos.php
@@ -0,0 +1,18 @@
+raw('+');
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Flush.php b/lib/twig/lib/Twig/Node/Flush.php
new file mode 100755
index 0000000..8f2ab9d
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Flush.php
@@ -0,0 +1,37 @@
+
+ */
+class Twig_Node_Flush extends Twig_Node
+{
+ public function __construct($lineno, $tag)
+ {
+ parent::__construct(array(), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("flush();\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/For.php b/lib/twig/lib/Twig/Node/For.php
new file mode 100755
index 0000000..d9d25b3
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/For.php
@@ -0,0 +1,113 @@
+
+ */
+class Twig_Node_For extends Twig_Node
+{
+ protected $loop;
+
+ public function __construct(Twig_Node_Expression_AssignName $keyTarget, Twig_Node_Expression_AssignName $valueTarget, Twig_Node_Expression $seq, Twig_Node_Expression $ifexpr = null, Twig_NodeInterface $body, Twig_NodeInterface $else = null, $lineno, $tag = null)
+ {
+ $body = new Twig_Node(array($body, $this->loop = new Twig_Node_ForLoop($lineno, $tag)));
+
+ if (null !== $ifexpr) {
+ $body = new Twig_Node_If(new Twig_Node(array($ifexpr, $body)), null, $lineno, $tag);
+ }
+
+ parent::__construct(array('key_target' => $keyTarget, 'value_target' => $valueTarget, 'seq' => $seq, 'body' => $body, 'else' => $else), array('with_loop' => true, 'ifexpr' => null !== $ifexpr), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ // the (array) cast bypasses a PHP 5.2.6 bug
+ ->write("\$context['_parent'] = (array) \$context;\n")
+ ->write("\$context['_seq'] = twig_ensure_traversable(")
+ ->subcompile($this->getNode('seq'))
+ ->raw(");\n")
+ ;
+
+ if (null !== $this->getNode('else')) {
+ $compiler->write("\$context['_iterated'] = false;\n");
+ }
+
+ if ($this->getAttribute('with_loop')) {
+ $compiler
+ ->write("\$context['loop'] = array(\n")
+ ->write(" 'parent' => \$context['_parent'],\n")
+ ->write(" 'index0' => 0,\n")
+ ->write(" 'index' => 1,\n")
+ ->write(" 'first' => true,\n")
+ ->write(");\n")
+ ;
+
+ if (!$this->getAttribute('ifexpr')) {
+ $compiler
+ ->write("if (is_array(\$context['_seq']) || (is_object(\$context['_seq']) && \$context['_seq'] instanceof Countable)) {\n")
+ ->indent()
+ ->write("\$length = count(\$context['_seq']);\n")
+ ->write("\$context['loop']['revindex0'] = \$length - 1;\n")
+ ->write("\$context['loop']['revindex'] = \$length;\n")
+ ->write("\$context['loop']['length'] = \$length;\n")
+ ->write("\$context['loop']['last'] = 1 === \$length;\n")
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+ }
+
+ $this->loop->setAttribute('else', null !== $this->getNode('else'));
+ $this->loop->setAttribute('with_loop', $this->getAttribute('with_loop'));
+ $this->loop->setAttribute('ifexpr', $this->getAttribute('ifexpr'));
+
+ $compiler
+ ->write("foreach (\$context['_seq'] as ")
+ ->subcompile($this->getNode('key_target'))
+ ->raw(" => ")
+ ->subcompile($this->getNode('value_target'))
+ ->raw(") {\n")
+ ->indent()
+ ->subcompile($this->getNode('body'))
+ ->outdent()
+ ->write("}\n")
+ ;
+
+ if (null !== $this->getNode('else')) {
+ $compiler
+ ->write("if (!\$context['_iterated']) {\n")
+ ->indent()
+ ->subcompile($this->getNode('else'))
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+
+ $compiler->write("\$_parent = \$context['_parent'];\n");
+
+ // remove some "private" loop variables (needed for nested loops)
+ $compiler->write('unset($context[\'_seq\'], $context[\'_iterated\'], $context[\''.$this->getNode('key_target')->getAttribute('name').'\'], $context[\''.$this->getNode('value_target')->getAttribute('name').'\'], $context[\'_parent\'], $context[\'loop\']);'."\n");
+
+ // keep the values set in the inner context for variables defined in the outer context
+ $compiler->write("\$context = array_merge(\$_parent, array_intersect_key(\$context, \$_parent));\n");
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/ForLoop.php b/lib/twig/lib/Twig/Node/ForLoop.php
new file mode 100755
index 0000000..38f2e85
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/ForLoop.php
@@ -0,0 +1,56 @@
+
+ */
+class Twig_Node_ForLoop extends Twig_Node
+{
+ public function __construct($lineno, $tag = null)
+ {
+ parent::__construct(array(), array('with_loop' => false, 'ifexpr' => false, 'else' => false), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ if ($this->getAttribute('else')) {
+ $compiler->write("\$context['_iterated'] = true;\n");
+ }
+
+ if ($this->getAttribute('with_loop')) {
+ $compiler
+ ->write("++\$context['loop']['index0'];\n")
+ ->write("++\$context['loop']['index'];\n")
+ ->write("\$context['loop']['first'] = false;\n")
+ ;
+
+ if (!$this->getAttribute('ifexpr')) {
+ $compiler
+ ->write("if (isset(\$context['loop']['length'])) {\n")
+ ->indent()
+ ->write("--\$context['loop']['revindex0'];\n")
+ ->write("--\$context['loop']['revindex'];\n")
+ ->write("\$context['loop']['last'] = 0 === \$context['loop']['revindex0'];\n")
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/If.php b/lib/twig/lib/Twig/Node/If.php
new file mode 100755
index 0000000..aa12efb
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/If.php
@@ -0,0 +1,67 @@
+
+ */
+class Twig_Node_If extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $tests, Twig_NodeInterface $else = null, $lineno, $tag = null)
+ {
+ parent::__construct(array('tests' => $tests, 'else' => $else), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->addDebugInfo($this);
+ for ($i = 0; $i < count($this->getNode('tests')); $i += 2) {
+ if ($i > 0) {
+ $compiler
+ ->outdent()
+ ->write("} elseif (")
+ ;
+ } else {
+ $compiler
+ ->write('if (')
+ ;
+ }
+
+ $compiler
+ ->subcompile($this->getNode('tests')->getNode($i))
+ ->raw(") {\n")
+ ->indent()
+ ->subcompile($this->getNode('tests')->getNode($i + 1))
+ ;
+ }
+
+ if ($this->hasNode('else') && null !== $this->getNode('else')) {
+ $compiler
+ ->outdent()
+ ->write("} else {\n")
+ ->indent()
+ ->subcompile($this->getNode('else'))
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write("}\n");
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Import.php b/lib/twig/lib/Twig/Node/Import.php
new file mode 100755
index 0000000..a327411
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Import.php
@@ -0,0 +1,51 @@
+
+ */
+class Twig_Node_Import extends Twig_Node
+{
+ public function __construct(Twig_Node_Expression $expr, Twig_Node_Expression $var, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr, 'var' => $var), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('')
+ ->subcompile($this->getNode('var'))
+ ->raw(' = ')
+ ;
+
+ if ($this->getNode('expr') instanceof Twig_Node_Expression_Name && '_self' === $this->getNode('expr')->getAttribute('name')) {
+ $compiler->raw("\$this");
+ } else {
+ $compiler
+ ->raw('$this->env->loadTemplate(')
+ ->subcompile($this->getNode('expr'))
+ ->raw(")")
+ ;
+ }
+
+ $compiler->raw(";\n");
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Include.php b/lib/twig/lib/Twig/Node/Include.php
new file mode 100755
index 0000000..467749b
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Include.php
@@ -0,0 +1,88 @@
+
+ */
+class Twig_Node_Include extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct(Twig_Node_Expression $expr, Twig_Node_Expression $variables = null, $only = false, $ignoreMissing = false, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr, 'variables' => $variables), array('only' => (Boolean) $only, 'ignore_missing' => (Boolean) $ignoreMissing), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->addDebugInfo($this);
+
+ if ($this->getAttribute('ignore_missing')) {
+ $compiler
+ ->write("try {\n")
+ ->indent()
+ ;
+ }
+
+ if ($this->getNode('expr') instanceof Twig_Node_Expression_Constant) {
+ $compiler
+ ->write("\$this->env->loadTemplate(")
+ ->subcompile($this->getNode('expr'))
+ ->raw(")->display(")
+ ;
+ } else {
+ $compiler
+ ->write("\$template = \$this->env->resolveTemplate(")
+ ->subcompile($this->getNode('expr'))
+ ->raw(");\n")
+ ->write('$template->display(')
+ ;
+ }
+
+ if (false === $this->getAttribute('only')) {
+ if (null === $this->getNode('variables')) {
+ $compiler->raw('$context');
+ } else {
+ $compiler
+ ->raw('array_merge($context, ')
+ ->subcompile($this->getNode('variables'))
+ ->raw(')')
+ ;
+ }
+ } else {
+ if (null === $this->getNode('variables')) {
+ $compiler->raw('array()');
+ } else {
+ $compiler->subcompile($this->getNode('variables'));
+ }
+ }
+
+ $compiler->raw(");\n");
+
+ if ($this->getAttribute('ignore_missing')) {
+ $compiler
+ ->outdent()
+ ->write("} catch (Twig_Error_Loader \$e) {\n")
+ ->indent()
+ ->write("// ignore missing template\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Macro.php b/lib/twig/lib/Twig/Node/Macro.php
new file mode 100755
index 0000000..5db1bf1
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Macro.php
@@ -0,0 +1,84 @@
+
+ */
+class Twig_Node_Macro extends Twig_Node
+{
+ public function __construct($name, Twig_NodeInterface $body, Twig_NodeInterface $arguments, $lineno, $tag = null)
+ {
+ parent::__construct(array('body' => $body, 'arguments' => $arguments), array('name' => $name), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $arguments = array();
+ foreach ($this->getNode('arguments') as $argument) {
+ $arguments[] = '$'.$argument->getAttribute('name').' = null';
+ }
+
+ $compiler
+ ->addDebugInfo($this)
+ ->write(sprintf("public function get%s(%s)\n", $this->getAttribute('name'), implode(', ', $arguments)), "{\n")
+ ->indent()
+ ;
+
+ if (!count($this->getNode('arguments'))) {
+ $compiler->write("\$context = \$this->env->getGlobals();\n\n");
+ } else {
+ $compiler
+ ->write("\$context = array_merge(\$this->env->getGlobals(), array(\n")
+ ->indent()
+ ;
+
+ foreach ($this->getNode('arguments') as $argument) {
+ $compiler
+ ->write('')
+ ->string($argument->getAttribute('name'))
+ ->raw(' => $'.$argument->getAttribute('name'))
+ ->raw(",\n")
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write("));\n\n")
+ ;
+ }
+
+ $compiler
+ ->write("\$blocks = array();\n\n")
+ ->write("ob_start();\n")
+ ->write("try {\n")
+ ->indent()
+ ->subcompile($this->getNode('body'))
+ ->outdent()
+ ->write("} catch(Exception \$e) {\n")
+ ->indent()
+ ->write("ob_end_clean();\n\n")
+ ->write("throw \$e;\n")
+ ->outdent()
+ ->write("}\n\n")
+ ->write("return ob_get_clean();\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Module.php b/lib/twig/lib/Twig/Node/Module.php
new file mode 100755
index 0000000..c67bc9a
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Module.php
@@ -0,0 +1,358 @@
+
+ */
+class Twig_Node_Module extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $body, Twig_Node_Expression $parent = null, Twig_NodeInterface $blocks, Twig_NodeInterface $macros, Twig_NodeInterface $traits, $filename)
+ {
+ parent::__construct(array('parent' => $parent, 'body' => $body, 'blocks' => $blocks, 'macros' => $macros, 'traits' => $traits), array('filename' => $filename), 1);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $this->compileTemplate($compiler);
+ }
+
+ protected function compileTemplate(Twig_Compiler $compiler)
+ {
+ $this->compileClassHeader($compiler);
+
+ if (count($this->getNode('blocks')) || count($this->getNode('traits'))) {
+ $this->compileConstructor($compiler);
+ }
+
+ $this->compileGetParent($compiler);
+
+ $this->compileDisplayHeader($compiler);
+
+ $this->compileDisplayBody($compiler);
+
+ $this->compileDisplayFooter($compiler);
+
+ $compiler->subcompile($this->getNode('blocks'));
+
+ $this->compileMacros($compiler);
+
+ $this->compileGetTemplateName($compiler);
+
+ $this->compileIsTraitable($compiler);
+
+ $this->compileDebugInfo($compiler);
+
+ $this->compileClassFooter($compiler);
+ }
+
+ protected function compileGetParent(Twig_Compiler $compiler)
+ {
+ if (null === $this->getNode('parent')) {
+ return;
+ }
+
+ $compiler
+ ->write("protected function doGetParent(array \$context)\n", "{\n")
+ ->indent()
+ ->write("return ")
+ ;
+
+ if ($this->getNode('parent') instanceof Twig_Node_Expression_Constant) {
+ $compiler->subcompile($this->getNode('parent'));
+ } else {
+ $compiler
+ ->raw("\$this->env->resolveTemplate(")
+ ->subcompile($this->getNode('parent'))
+ ->raw(")")
+ ;
+ }
+
+ $compiler
+ ->raw(";\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileDisplayBody(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('body'));
+
+ if (null !== $this->getNode('parent')) {
+ if ($this->getNode('parent') instanceof Twig_Node_Expression_Constant) {
+ $compiler->write("\$this->parent");
+ } else {
+ $compiler->write("\$this->getParent(\$context)");
+ }
+ $compiler->raw("->display(\$context, array_merge(\$this->blocks, \$blocks));\n");
+ }
+ }
+
+ protected function compileClassHeader(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("write("/* ".str_replace('*/', '* /', $this->getAttribute('filename'))." */\n")
+ ->write('class '.$compiler->getEnvironment()->getTemplateClass($this->getAttribute('filename')))
+ ->raw(sprintf(" extends %s\n", $compiler->getEnvironment()->getBaseTemplateClass()))
+ ->write("{\n")
+ ->indent()
+ ;
+ }
+
+ protected function compileConstructor(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("public function __construct(Twig_Environment \$env)\n", "{\n")
+ ->indent()
+ ->write("parent::__construct(\$env);\n\n")
+ ;
+
+ // parent
+ if (null === $this->getNode('parent')) {
+ $compiler->write("\$this->parent = false;\n\n");
+ } elseif ($this->getNode('parent') instanceof Twig_Node_Expression_Constant) {
+ $compiler
+ ->write("\$this->parent = \$this->env->loadTemplate(")
+ ->subcompile($this->getNode('parent'))
+ ->raw(");\n\n")
+ ;
+ }
+
+ $countTraits = count($this->getNode('traits'));
+ if ($countTraits) {
+ // traits
+ foreach ($this->getNode('traits') as $i => $trait) {
+ $this->compileLoadTemplate($compiler, $trait->getNode('template'), sprintf('$_trait_%s', $i));
+
+ $compiler
+ ->addDebugInfo($trait->getNode('template'))
+ ->write(sprintf("if (!\$_trait_%s->isTraitable()) {\n", $i))
+ ->indent()
+ ->write("throw new Twig_Error_Runtime('Template \"'.")
+ ->subcompile($trait->getNode('template'))
+ ->raw(".'\" cannot be used as a trait.');\n")
+ ->outdent()
+ ->write("}\n")
+ ->write(sprintf("\$_trait_%s_blocks = \$_trait_%s->getBlocks();\n\n", $i, $i))
+ ;
+
+ foreach ($trait->getNode('targets') as $key => $value) {
+ $compiler
+ ->write(sprintf("\$_trait_%s_blocks[", $i))
+ ->subcompile($value)
+ ->raw(sprintf("] = \$_trait_%s_blocks[", $i))
+ ->string($key)
+ ->raw(sprintf("]; unset(\$_trait_%s_blocks[", $i))
+ ->string($key)
+ ->raw("]);\n\n")
+ ;
+ }
+ }
+
+ if ($countTraits > 1) {
+ $compiler
+ ->write("\$this->traits = array_merge(\n")
+ ->indent()
+ ;
+
+ for ($i = 0; $i < $countTraits; $i++) {
+ $compiler
+ ->write(sprintf("\$_trait_%s_blocks".($i == $countTraits - 1 ? '' : ',')."\n", $i))
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write(");\n\n")
+ ;
+ } else {
+ $compiler
+ ->write("\$this->traits = \$_trait_0_blocks;\n\n")
+ ;
+ }
+
+ $compiler
+ ->write("\$this->blocks = array_merge(\n")
+ ->indent()
+ ->write("\$this->traits,\n")
+ ->write("array(\n")
+ ;
+ } else {
+ $compiler
+ ->write("\$this->blocks = array(\n")
+ ;
+ }
+
+ // blocks
+ $compiler
+ ->indent()
+ ;
+
+ foreach ($this->getNode('blocks') as $name => $node) {
+ $compiler
+ ->write(sprintf("'%s' => array(\$this, 'block_%s'),\n", $name, $name))
+ ;
+ }
+
+ if ($countTraits) {
+ $compiler
+ ->outdent()
+ ->write(")\n")
+ ;
+ }
+
+ $compiler
+ ->outdent()
+ ->write(");\n")
+ ->outdent()
+ ->write("}\n\n");
+ ;
+ }
+
+ protected function compileDisplayHeader(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("protected function doDisplay(array \$context, array \$blocks = array())\n", "{\n")
+ ->indent()
+ ;
+ }
+
+ protected function compileDisplayFooter(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileClassFooter(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+
+ protected function compileMacros(Twig_Compiler $compiler)
+ {
+ $compiler->subcompile($this->getNode('macros'));
+ }
+
+ protected function compileGetTemplateName(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("public function getTemplateName()\n", "{\n")
+ ->indent()
+ ->write('return ')
+ ->repr($this->getAttribute('filename'))
+ ->raw(";\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileIsTraitable(Twig_Compiler $compiler)
+ {
+ // A template can be used as a trait if:
+ // * it has no parent
+ // * it has no macros
+ // * it has no body
+ //
+ // Put another way, a template can be used as a trait if it
+ // only contains blocks and use statements.
+ $traitable = null === $this->getNode('parent') && 0 === count($this->getNode('macros'));
+ if ($traitable) {
+ if ($this->getNode('body') instanceof Twig_Node_Body) {
+ $nodes = $this->getNode('body')->getNode(0);
+ } else {
+ $nodes = $this->getNode('body');
+ }
+
+ if (!count($nodes)) {
+ $nodes = new Twig_Node(array($nodes));
+ }
+
+ foreach ($nodes as $node) {
+ if (!count($node)) {
+ continue;
+ }
+
+ if ($node instanceof Twig_Node_Text && ctype_space($node->getAttribute('data'))) {
+ continue;
+ }
+
+ if ($node instanceof Twig_Node_BlockReference) {
+ continue;
+ }
+
+ $traitable = false;
+ break;
+ }
+ }
+
+ if ($traitable) {
+ return;
+ }
+
+ $compiler
+ ->write("public function isTraitable()\n", "{\n")
+ ->indent()
+ ->write(sprintf("return %s;\n", $traitable ? 'true' : 'false'))
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+
+ protected function compileDebugInfo(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->write("public function getDebugInfo()\n", "{\n")
+ ->indent()
+ ->write(sprintf("return %s;\n", str_replace("\n", '', var_export(array_reverse($compiler->getDebugInfo(), true), true))))
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+
+ protected function compileLoadTemplate(Twig_Compiler $compiler, $node, $var)
+ {
+ if ($node instanceof Twig_Node_Expression_Constant) {
+ $compiler
+ ->write(sprintf("%s = \$this->env->loadTemplate(", $var))
+ ->subcompile($node)
+ ->raw(");\n")
+ ;
+ } else {
+ $compiler
+ ->write(sprintf("%s = ", $var))
+ ->subcompile($node)
+ ->raw(";\n")
+ ->write(sprintf("if (!%s", $var))
+ ->raw(" instanceof Twig_Template) {\n")
+ ->indent()
+ ->write(sprintf("%s = \$this->env->loadTemplate(%s);\n", $var, $var))
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Print.php b/lib/twig/lib/Twig/Node/Print.php
new file mode 100755
index 0000000..766725f
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Print.php
@@ -0,0 +1,40 @@
+
+ */
+class Twig_Node_Print extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct(Twig_Node_Expression $expr, $lineno, $tag = null)
+ {
+ parent::__construct(array('expr' => $expr), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('echo ')
+ ->subcompile($this->getNode('expr'))
+ ->raw(";\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Sandbox.php b/lib/twig/lib/Twig/Node/Sandbox.php
new file mode 100755
index 0000000..cbfcb41
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Sandbox.php
@@ -0,0 +1,48 @@
+
+ */
+class Twig_Node_Sandbox extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $body, $lineno, $tag = null)
+ {
+ parent::__construct(array('body' => $body), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("\$sandbox = \$this->env->getExtension('sandbox');\n")
+ ->write("if (!\$alreadySandboxed = \$sandbox->isSandboxed()) {\n")
+ ->indent()
+ ->write("\$sandbox->enableSandbox();\n")
+ ->outdent()
+ ->write("}\n")
+ ->subcompile($this->getNode('body'))
+ ->write("if (!\$alreadySandboxed) {\n")
+ ->indent()
+ ->write("\$sandbox->disableSandbox();\n")
+ ->outdent()
+ ->write("}\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/SandboxedModule.php b/lib/twig/lib/Twig/Node/SandboxedModule.php
new file mode 100755
index 0000000..655efa3
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/SandboxedModule.php
@@ -0,0 +1,59 @@
+
+ */
+class Twig_Node_SandboxedModule extends Twig_Node_Module
+{
+ protected $usedFilters;
+ protected $usedTags;
+ protected $usedFunctions;
+
+ public function __construct(Twig_Node_Module $node, array $usedFilters, array $usedTags, array $usedFunctions)
+ {
+ parent::__construct($node->getNode('body'), $node->getNode('parent'), $node->getNode('blocks'), $node->getNode('macros'), $node->getNode('traits'), $node->getAttribute('filename'), $node->getLine(), $node->getNodeTag());
+
+ $this->usedFilters = $usedFilters;
+ $this->usedTags = $usedTags;
+ $this->usedFunctions = $usedFunctions;
+ }
+
+ protected function compileDisplayBody(Twig_Compiler $compiler)
+ {
+ $compiler->write("\$this->checkSecurity();\n");
+
+ parent::compileDisplayBody($compiler);
+ }
+
+ protected function compileDisplayFooter(Twig_Compiler $compiler)
+ {
+ parent::compileDisplayFooter($compiler);
+
+ $compiler
+ ->write("protected function checkSecurity() {\n")
+ ->indent()
+ ->write("\$this->env->getExtension('sandbox')->checkSecurity(\n")
+ ->indent()
+ ->write(!$this->usedTags ? "array(),\n" : "array('".implode('\', \'', $this->usedTags)."'),\n")
+ ->write(!$this->usedFilters ? "array(),\n" : "array('".implode('\', \'', $this->usedFilters)."'),\n")
+ ->write(!$this->usedFunctions ? "array()\n" : "array('".implode('\', \'', $this->usedFunctions)."')\n")
+ ->outdent()
+ ->write(");\n")
+ ->outdent()
+ ->write("}\n\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/SandboxedPrint.php b/lib/twig/lib/Twig/Node/SandboxedPrint.php
new file mode 100755
index 0000000..77730d8
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/SandboxedPrint.php
@@ -0,0 +1,60 @@
+
+ */
+class Twig_Node_SandboxedPrint extends Twig_Node_Print
+{
+ public function __construct(Twig_Node_Expression $expr, $lineno, $tag = null)
+ {
+ parent::__construct($expr, $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('echo $this->env->getExtension(\'sandbox\')->ensureToStringAllowed(')
+ ->subcompile($this->getNode('expr'))
+ ->raw(");\n")
+ ;
+ }
+
+ /**
+ * Removes node filters.
+ *
+ * This is mostly needed when another visitor adds filters (like the escaper one).
+ *
+ * @param Twig_Node $node A Node
+ */
+ protected function removeNodeFilter($node)
+ {
+ if ($node instanceof Twig_Node_Expression_Filter) {
+ return $this->removeNodeFilter($node->getNode('node'));
+ }
+
+ return $node;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Set.php b/lib/twig/lib/Twig/Node/Set.php
new file mode 100755
index 0000000..70bb519
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Set.php
@@ -0,0 +1,102 @@
+
+ */
+class Twig_Node_Set extends Twig_Node
+{
+ public function __construct($capture, Twig_NodeInterface $names, Twig_NodeInterface $values, $lineno, $tag = null)
+ {
+ parent::__construct(array('names' => $names, 'values' => $values), array('capture' => $capture, 'safe' => false), $lineno, $tag);
+
+ /*
+ * Optimizes the node when capture is used for a large block of text.
+ *
+ * {% set foo %}foo{% endset %} is compiled to $context['foo'] = new Twig_Markup("foo");
+ */
+ if ($this->getAttribute('capture')) {
+ $this->setAttribute('safe', true);
+
+ $values = $this->getNode('values');
+ if ($values instanceof Twig_Node_Text) {
+ $this->setNode('values', new Twig_Node_Expression_Constant($values->getAttribute('data'), $values->getLine()));
+ $this->setAttribute('capture', false);
+ }
+ }
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler->addDebugInfo($this);
+
+ if (count($this->getNode('names')) > 1) {
+ $compiler->write('list(');
+ foreach ($this->getNode('names') as $idx => $node) {
+ if ($idx) {
+ $compiler->raw(', ');
+ }
+
+ $compiler->subcompile($node);
+ }
+ $compiler->raw(')');
+ } else {
+ if ($this->getAttribute('capture')) {
+ $compiler
+ ->write("ob_start();\n")
+ ->subcompile($this->getNode('values'))
+ ;
+ }
+
+ $compiler->subcompile($this->getNode('names'), false);
+
+ if ($this->getAttribute('capture')) {
+ $compiler->raw(" = ('' === \$tmp = ob_get_clean()) ? '' : new Twig_Markup(\$tmp, \$this->env->getCharset())");
+ }
+ }
+
+ if (!$this->getAttribute('capture')) {
+ $compiler->raw(' = ');
+
+ if (count($this->getNode('names')) > 1) {
+ $compiler->write('array(');
+ foreach ($this->getNode('values') as $idx => $value) {
+ if ($idx) {
+ $compiler->raw(', ');
+ }
+
+ $compiler->subcompile($value);
+ }
+ $compiler->raw(')');
+ } else {
+ if ($this->getAttribute('safe')) {
+ $compiler
+ ->raw("('' === \$tmp = ")
+ ->subcompile($this->getNode('values'))
+ ->raw(") ? '' : new Twig_Markup(\$tmp, \$this->env->getCharset())")
+ ;
+ } else {
+ $compiler->subcompile($this->getNode('values'));
+ }
+ }
+ }
+
+ $compiler->raw(";\n");
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/SetTemp.php b/lib/twig/lib/Twig/Node/SetTemp.php
new file mode 100755
index 0000000..3bdd1cb
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/SetTemp.php
@@ -0,0 +1,35 @@
+ $name), $lineno);
+ }
+
+ public function compile(Twig_Compiler $compiler)
+ {
+ $name = $this->getAttribute('name');
+ $compiler
+ ->addDebugInfo($this)
+ ->write('if (isset($context[')
+ ->string($name)
+ ->raw('])) { $_')
+ ->raw($name)
+ ->raw('_ = $context[')
+ ->repr($name)
+ ->raw(']; } else { $_')
+ ->raw($name)
+ ->raw("_ = null; }\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Spaceless.php b/lib/twig/lib/Twig/Node/Spaceless.php
new file mode 100755
index 0000000..4601346
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Spaceless.php
@@ -0,0 +1,41 @@
+
+ */
+class Twig_Node_Spaceless extends Twig_Node
+{
+ public function __construct(Twig_NodeInterface $body, $lineno, $tag = 'spaceless')
+ {
+ parent::__construct(array('body' => $body), array(), $lineno, $tag);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write("ob_start();\n")
+ ->subcompile($this->getNode('body'))
+ ->write("echo trim(preg_replace('/>\s+', '><', ob_get_clean()));\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/Node/Text.php b/lib/twig/lib/Twig/Node/Text.php
new file mode 100755
index 0000000..0c1c092
--- /dev/null
+++ b/lib/twig/lib/Twig/Node/Text.php
@@ -0,0 +1,40 @@
+
+ */
+class Twig_Node_Text extends Twig_Node implements Twig_NodeOutputInterface
+{
+ public function __construct($data, $lineno)
+ {
+ parent::__construct(array(), array('data' => $data), $lineno);
+ }
+
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ public function compile(Twig_Compiler $compiler)
+ {
+ $compiler
+ ->addDebugInfo($this)
+ ->write('echo ')
+ ->string($this->getAttribute('data'))
+ ->raw(";\n")
+ ;
+ }
+}
diff --git a/lib/twig/lib/Twig/NodeInterface.php b/lib/twig/lib/Twig/NodeInterface.php
new file mode 100755
index 0000000..29a84b0
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeInterface.php
@@ -0,0 +1,30 @@
+
+ */
+interface Twig_NodeInterface extends Countable, IteratorAggregate
+{
+ /**
+ * Compiles the node to PHP.
+ *
+ * @param Twig_Compiler A Twig_Compiler instance
+ */
+ function compile(Twig_Compiler $compiler);
+
+ function getLine();
+
+ function getNodeTag();
+}
diff --git a/lib/twig/lib/Twig/NodeOutputInterface.php b/lib/twig/lib/Twig/NodeOutputInterface.php
new file mode 100755
index 0000000..7183956
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeOutputInterface.php
@@ -0,0 +1,20 @@
+
+ */
+interface Twig_NodeOutputInterface
+{
+}
diff --git a/lib/twig/lib/Twig/NodeTraverser.php b/lib/twig/lib/Twig/NodeTraverser.php
new file mode 100755
index 0000000..1e82b03
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeTraverser.php
@@ -0,0 +1,89 @@
+
+ */
+class Twig_NodeTraverser
+{
+ protected $env;
+ protected $visitors;
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ * @param array $visitors An array of Twig_NodeVisitorInterface instances
+ */
+ public function __construct(Twig_Environment $env, array $visitors = array())
+ {
+ $this->env = $env;
+ $this->visitors = array();
+ foreach ($visitors as $visitor) {
+ $this->addVisitor($visitor);
+ }
+ }
+
+ /**
+ * Adds a visitor.
+ *
+ * @param Twig_NodeVisitorInterface $visitor A Twig_NodeVisitorInterface instance
+ */
+ public function addVisitor(Twig_NodeVisitorInterface $visitor)
+ {
+ if (!isset($this->visitors[$visitor->getPriority()])) {
+ $this->visitors[$visitor->getPriority()] = array();
+ }
+
+ $this->visitors[$visitor->getPriority()][] = $visitor;
+ }
+
+ /**
+ * Traverses a node and calls the registered visitors.
+ *
+ * @param Twig_NodeInterface $node A Twig_NodeInterface instance
+ */
+ public function traverse(Twig_NodeInterface $node)
+ {
+ ksort($this->visitors);
+ foreach ($this->visitors as $visitors) {
+ foreach ($visitors as $visitor) {
+ $node = $this->traverseForVisitor($visitor, $node);
+ }
+ }
+
+ return $node;
+ }
+
+ protected function traverseForVisitor(Twig_NodeVisitorInterface $visitor, Twig_NodeInterface $node = null)
+ {
+ if (null === $node) {
+ return null;
+ }
+
+ $node = $visitor->enterNode($node, $this->env);
+
+ foreach ($node as $k => $n) {
+ if (false !== $n = $this->traverseForVisitor($visitor, $n)) {
+ $node->setNode($k, $n);
+ } else {
+ $node->removeNode($k);
+ }
+ }
+
+ return $visitor->leaveNode($node, $this->env);
+ }
+}
diff --git a/lib/twig/lib/Twig/NodeVisitor/Escaper.php b/lib/twig/lib/Twig/NodeVisitor/Escaper.php
new file mode 100755
index 0000000..f682beb
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeVisitor/Escaper.php
@@ -0,0 +1,162 @@
+
+ */
+class Twig_NodeVisitor_Escaper implements Twig_NodeVisitorInterface
+{
+ protected $statusStack = array();
+ protected $blocks = array();
+
+ protected $safeAnalysis;
+ protected $traverser;
+
+ function __construct()
+ {
+ $this->safeAnalysis = new Twig_NodeVisitor_SafeAnalysis();
+ }
+
+ /**
+ * Called before child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_AutoEscape) {
+ $this->statusStack[] = $node->getAttribute('value');
+ } elseif ($node instanceof Twig_Node_Block) {
+ $this->statusStack[] = isset($this->blocks[$node->getAttribute('name')]) ? $this->blocks[$node->getAttribute('name')] : $this->needEscaping($env);
+ }
+
+ return $node;
+ }
+
+ /**
+ * Called after child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Expression_Filter) {
+ return $this->preEscapeFilterNode($node, $env);
+ } elseif ($node instanceof Twig_Node_Print) {
+ return $this->escapePrintNode($node, $env, $this->needEscaping($env));
+ }
+
+ if ($node instanceof Twig_Node_AutoEscape || $node instanceof Twig_Node_Block) {
+ array_pop($this->statusStack);
+ } elseif ($node instanceof Twig_Node_BlockReference) {
+ $this->blocks[$node->getAttribute('name')] = $this->needEscaping($env);
+ }
+
+ return $node;
+ }
+
+ protected function escapePrintNode(Twig_Node_Print $node, Twig_Environment $env, $type)
+ {
+ if (false === $type) {
+ return $node;
+ }
+
+ $expression = $node->getNode('expr');
+
+ if ($this->isSafeFor($type, $expression, $env)) {
+ return $node;
+ }
+
+ $class = get_class($node);
+
+ return new $class(
+ $this->getEscaperFilter($type, $expression),
+ $node->getLine()
+ );
+ }
+
+ protected function preEscapeFilterNode(Twig_Node_Expression_Filter $filter, Twig_Environment $env)
+ {
+ $name = $filter->getNode('filter')->getAttribute('value');
+
+ if (false !== $f = $env->getFilter($name)) {
+ $type = $f->getPreEscape();
+ if (null === $type) {
+ return $filter;
+ }
+
+ $node = $filter->getNode('node');
+ if ($this->isSafeFor($type, $node, $env)) {
+ return $filter;
+ }
+
+ $filter->setNode('node', $this->getEscaperFilter($type, $node));
+
+ return $filter;
+ }
+
+ return $filter;
+ }
+
+ protected function isSafeFor($type, Twig_NodeInterface $expression, $env)
+ {
+ $safe = $this->safeAnalysis->getSafe($expression);
+
+ if (null === $safe) {
+ if (null === $this->traverser) {
+ $this->traverser = new Twig_NodeTraverser($env, array($this->safeAnalysis));
+ }
+ $this->traverser->traverse($expression);
+ $safe = $this->safeAnalysis->getSafe($expression);
+ }
+
+ return in_array($type, $safe) || in_array('all', $safe);
+ }
+
+ protected function needEscaping(Twig_Environment $env)
+ {
+ if (count($this->statusStack)) {
+ return $this->statusStack[count($this->statusStack) - 1];
+ }
+
+ if ($env->hasExtension('escaper') && $env->getExtension('escaper')->isGlobal()) {
+ return 'html';
+ }
+
+ return false;
+ }
+
+ protected function getEscaperFilter($type, Twig_NodeInterface $node)
+ {
+ $line = $node->getLine();
+ $name = new Twig_Node_Expression_Constant('escape', $line);
+ $args = new Twig_Node(array(new Twig_Node_Expression_Constant((string) $type, $line), new Twig_Node_Expression_Constant(null, $line), new Twig_Node_Expression_Constant(true, $line)));
+
+ return new Twig_Node_Expression_Filter($node, $name, $args, $line);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/lib/twig/lib/Twig/NodeVisitor/Optimizer.php b/lib/twig/lib/Twig/NodeVisitor/Optimizer.php
new file mode 100755
index 0000000..cbc61fc
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeVisitor/Optimizer.php
@@ -0,0 +1,247 @@
+
+ */
+class Twig_NodeVisitor_Optimizer implements Twig_NodeVisitorInterface
+{
+ const OPTIMIZE_ALL = -1;
+ const OPTIMIZE_NONE = 0;
+ const OPTIMIZE_FOR = 2;
+ const OPTIMIZE_RAW_FILTER = 4;
+ const OPTIMIZE_VAR_ACCESS = 8;
+
+ protected $loops = array();
+ protected $optimizers;
+ protected $prependedNodes = array();
+ protected $inABody = false;
+
+ /**
+ * Constructor.
+ *
+ * @param integer $optimizers The optimizer mode
+ */
+ public function __construct($optimizers = -1)
+ {
+ if (!is_int($optimizers) || $optimizers > 2) {
+ throw new InvalidArgumentException(sprintf('Optimizer mode "%s" is not valid.', $optimizers));
+ }
+
+ $this->optimizers = $optimizers;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if (self::OPTIMIZE_FOR === (self::OPTIMIZE_FOR & $this->optimizers)) {
+ $this->enterOptimizeFor($node, $env);
+ }
+
+ if (!version_compare(phpversion(), '5.4.0RC1', '>=') && self::OPTIMIZE_VAR_ACCESS === (self::OPTIMIZE_VAR_ACCESS & $this->optimizers) && !$env->isStrictVariables() && !$env->hasExtension('sandbox')) {
+ if ($this->inABody) {
+ if (!$node instanceof Twig_Node_Expression) {
+ if (get_class($node) !== 'Twig_Node') {
+ array_unshift($this->prependedNodes, array());
+ }
+ } else {
+ $node = $this->optimizeVariables($node, $env);
+ }
+ } elseif ($node instanceof Twig_Node_Body) {
+ $this->inABody = true;
+ }
+ }
+
+ return $node;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ $expression = $node instanceof Twig_Node_Expression;
+
+ if (self::OPTIMIZE_FOR === (self::OPTIMIZE_FOR & $this->optimizers)) {
+ $this->leaveOptimizeFor($node, $env);
+ }
+
+ if (self::OPTIMIZE_RAW_FILTER === (self::OPTIMIZE_RAW_FILTER & $this->optimizers)) {
+ $node = $this->optimizeRawFilter($node, $env);
+ }
+
+ $node = $this->optimizePrintNode($node, $env);
+
+ if (self::OPTIMIZE_VAR_ACCESS === (self::OPTIMIZE_VAR_ACCESS & $this->optimizers) && !$env->isStrictVariables() && !$env->hasExtension('sandbox')) {
+ if ($node instanceof Twig_Node_Body) {
+ $this->inABody = false;
+ } elseif ($this->inABody) {
+ if (!$expression && get_class($node) !== 'Twig_Node' && $prependedNodes = array_shift($this->prependedNodes)) {
+ $nodes = array();
+ foreach (array_unique($prependedNodes) as $name) {
+ $nodes[] = new Twig_Node_SetTemp($name, $node->getLine());
+ }
+
+ $nodes[] = $node;
+ $node = new Twig_Node($nodes);
+ }
+ }
+ }
+
+ return $node;
+ }
+
+ protected function optimizeVariables($node, $env)
+ {
+ if ('Twig_Node_Expression_Name' === get_class($node) && $node->isSimple()) {
+ $this->prependedNodes[0][] = $node->getAttribute('name');
+
+ return new Twig_Node_Expression_TempName($node->getAttribute('name'), $node->getLine());
+ }
+
+ return $node;
+ }
+
+ /**
+ * Optimizes print nodes.
+ *
+ * It replaces:
+ *
+ * * "echo $this->render(Parent)Block()" with "$this->display(Parent)Block()"
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ */
+ protected function optimizePrintNode($node, $env)
+ {
+ if (!$node instanceof Twig_Node_Print) {
+ return $node;
+ }
+
+ if (
+ $node->getNode('expr') instanceof Twig_Node_Expression_BlockReference ||
+ $node->getNode('expr') instanceof Twig_Node_Expression_Parent
+ ) {
+ $node->getNode('expr')->setAttribute('output', true);
+
+ return $node->getNode('expr');
+ }
+
+ return $node;
+ }
+
+ /**
+ * Removes "raw" filters.
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ */
+ protected function optimizeRawFilter($node, $env)
+ {
+ if ($node instanceof Twig_Node_Expression_Filter && 'raw' == $node->getNode('filter')->getAttribute('value')) {
+ return $node->getNode('node');
+ }
+
+ return $node;
+ }
+
+ /**
+ * Optimizes "for" tag by removing the "loop" variable creation whenever possible.
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ */
+ protected function enterOptimizeFor($node, $env)
+ {
+ if ($node instanceof Twig_Node_For) {
+ // disable the loop variable by default
+ $node->setAttribute('with_loop', false);
+ array_unshift($this->loops, $node);
+ } elseif (!$this->loops) {
+ // we are outside a loop
+ return;
+ }
+
+ // when do we need to add the loop variable back?
+
+ // the loop variable is referenced for the current loop
+ elseif ($node instanceof Twig_Node_Expression_Name && 'loop' === $node->getAttribute('name')) {
+ $this->addLoopToCurrent();
+ }
+
+ // block reference
+ elseif ($node instanceof Twig_Node_BlockReference || $node instanceof Twig_Node_Expression_BlockReference) {
+ $this->addLoopToCurrent();
+ }
+
+ // include without the only attribute
+ elseif ($node instanceof Twig_Node_Include && !$node->getAttribute('only')) {
+ $this->addLoopToAll();
+ }
+
+ // the loop variable is referenced via an attribute
+ elseif ($node instanceof Twig_Node_Expression_GetAttr
+ && (!$node->getNode('attribute') instanceof Twig_Node_Expression_Constant
+ || 'parent' === $node->getNode('attribute')->getAttribute('value')
+ )
+ && (true === $this->loops[0]->getAttribute('with_loop')
+ || ($node->getNode('node') instanceof Twig_Node_Expression_Name
+ && 'loop' === $node->getNode('node')->getAttribute('name')
+ )
+ )
+ ) {
+ $this->addLoopToAll();
+ }
+ }
+
+ /**
+ * Optimizes "for" tag by removing the "loop" variable creation whenever possible.
+ *
+ * @param Twig_NodeInterface $node A Node
+ * @param Twig_Environment $env The current Twig environment
+ */
+ protected function leaveOptimizeFor($node, $env)
+ {
+ if ($node instanceof Twig_Node_For) {
+ array_shift($this->loops);
+ }
+ }
+
+ protected function addLoopToCurrent()
+ {
+ $this->loops[0]->setAttribute('with_loop', true);
+ }
+
+ protected function addLoopToAll()
+ {
+ foreach ($this->loops as $loop) {
+ $loop->setAttribute('with_loop', true);
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 255;
+ }
+}
diff --git a/lib/twig/lib/Twig/NodeVisitor/SafeAnalysis.php b/lib/twig/lib/Twig/NodeVisitor/SafeAnalysis.php
new file mode 100755
index 0000000..89d8794
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeVisitor/SafeAnalysis.php
@@ -0,0 +1,115 @@
+data[$hash])) {
+ foreach($this->data[$hash] as $bucket) {
+ if ($bucket['key'] === $node) {
+ return $bucket['value'];
+ }
+ }
+ }
+
+ return null;
+ }
+
+ protected function setSafe(Twig_NodeInterface $node, array $safe)
+ {
+ $hash = spl_object_hash($node);
+ if (isset($this->data[$hash])) {
+ foreach($this->data[$hash] as &$bucket) {
+ if ($bucket['key'] === $node) {
+ $bucket['value'] = $safe;
+
+ return;
+ }
+ }
+ }
+ $this->data[$hash][] = array(
+ 'key' => $node,
+ 'value' => $safe,
+ );
+ }
+
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ return $node;
+ }
+
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Expression_Constant) {
+ // constants are marked safe for all
+ $this->setSafe($node, array('all'));
+ } elseif ($node instanceof Twig_Node_Expression_BlockReference) {
+ // blocks are safe by definition
+ $this->setSafe($node, array('all'));
+ } elseif ($node instanceof Twig_Node_Expression_Parent) {
+ // parent block is safe by definition
+ $this->setSafe($node, array('all'));
+ } elseif ($node instanceof Twig_Node_Expression_Conditional) {
+ // intersect safeness of both operands
+ $safe = $this->intersectSafe($this->getSafe($node->getNode('expr2')), $this->getSafe($node->getNode('expr3')));
+ $this->setSafe($node, $safe);
+ } elseif ($node instanceof Twig_Node_Expression_Filter) {
+ // filter expression is safe when the filter is safe
+ $name = $node->getNode('filter')->getAttribute('value');
+ $args = $node->getNode('arguments');
+ if (false !== $filter = $env->getFilter($name)) {
+ $this->setSafe($node, $filter->getSafe($args));
+ } else {
+ $this->setSafe($node, array());
+ }
+ } elseif ($node instanceof Twig_Node_Expression_Function) {
+ // function expression is safe when the function is safe
+ $name = $node->getAttribute('name');
+ $args = $node->getNode('arguments');
+ $function = $env->getFunction($name);
+ if (false !== $function) {
+ $this->setSafe($node, $function->getSafe($args));
+ } else {
+ $this->setSafe($node, array());
+ }
+ } elseif ($node instanceof Twig_Node_Expression_MethodCall) {
+ if ($node->getAttribute('safe')) {
+ $this->setSafe($node, array('all'));
+ } else {
+ $this->setSafe($node, array());
+ }
+ } else {
+ $this->setSafe($node, array());
+ }
+
+ return $node;
+ }
+
+ protected function intersectSafe(array $a = null, array $b = null)
+ {
+ if (null === $a || null === $b) {
+ return array();
+ }
+
+ if (in_array('all', $a)) {
+ return $b;
+ }
+
+ if (in_array('all', $b)) {
+ return $a;
+ }
+
+ return array_intersect($a, $b);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/lib/twig/lib/Twig/NodeVisitor/Sandbox.php b/lib/twig/lib/Twig/NodeVisitor/Sandbox.php
new file mode 100755
index 0000000..1957f8a
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeVisitor/Sandbox.php
@@ -0,0 +1,93 @@
+
+ */
+class Twig_NodeVisitor_Sandbox implements Twig_NodeVisitorInterface
+{
+ protected $inAModule = false;
+ protected $tags;
+ protected $filters;
+ protected $functions;
+
+ /**
+ * Called before child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function enterNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Module) {
+ $this->inAModule = true;
+ $this->tags = array();
+ $this->filters = array();
+ $this->functions = array();
+
+ return $node;
+ } elseif ($this->inAModule) {
+ // look for tags
+ if ($node->getNodeTag()) {
+ $this->tags[] = $node->getNodeTag();
+ }
+
+ // look for filters
+ if ($node instanceof Twig_Node_Expression_Filter) {
+ $this->filters[] = $node->getNode('filter')->getAttribute('value');
+ }
+
+ // look for functions
+ if ($node instanceof Twig_Node_Expression_Function) {
+ $this->functions[] = $node->getAttribute('name');
+ }
+
+ // wrap print to check __toString() calls
+ if ($node instanceof Twig_Node_Print) {
+ return new Twig_Node_SandboxedPrint($node->getNode('expr'), $node->getLine(), $node->getNodeTag());
+ }
+ }
+
+ return $node;
+ }
+
+ /**
+ * Called after child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ public function leaveNode(Twig_NodeInterface $node, Twig_Environment $env)
+ {
+ if ($node instanceof Twig_Node_Module) {
+ $this->inAModule = false;
+
+ return new Twig_Node_SandboxedModule($node, array_unique($this->filters), array_unique($this->tags), array_unique($this->functions));
+ }
+
+ return $node;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getPriority()
+ {
+ return 0;
+ }
+}
diff --git a/lib/twig/lib/Twig/NodeVisitorInterface.php b/lib/twig/lib/Twig/NodeVisitorInterface.php
new file mode 100755
index 0000000..e0123b5
--- /dev/null
+++ b/lib/twig/lib/Twig/NodeVisitorInterface.php
@@ -0,0 +1,48 @@
+
+ */
+interface Twig_NodeVisitorInterface
+{
+ /**
+ * Called before child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ function enterNode(Twig_NodeInterface $node, Twig_Environment $env);
+
+ /**
+ * Called after child nodes are visited.
+ *
+ * @param Twig_NodeInterface $node The node to visit
+ * @param Twig_Environment $env The Twig environment instance
+ *
+ * @return Twig_NodeInterface The modified node
+ */
+ function leaveNode(Twig_NodeInterface $node, Twig_Environment $env);
+
+ /**
+ * Returns the priority for this visitor.
+ *
+ * Priority should be between -10 and 10 (0 is the default).
+ *
+ * @return integer The priority level
+ */
+ function getPriority();
+}
diff --git a/lib/twig/lib/Twig/Parser.php b/lib/twig/lib/Twig/Parser.php
new file mode 100755
index 0000000..72d3637
--- /dev/null
+++ b/lib/twig/lib/Twig/Parser.php
@@ -0,0 +1,370 @@
+
+ */
+class Twig_Parser implements Twig_ParserInterface
+{
+ protected $stack = array();
+ protected $stream;
+ protected $parent;
+ protected $handlers;
+ protected $visitors;
+ protected $expressionParser;
+ protected $blocks;
+ protected $blockStack;
+ protected $macros;
+ protected $env;
+ protected $reservedMacroNames;
+ protected $importedFunctions;
+ protected $tmpVarCount;
+ protected $traits;
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ */
+ public function __construct(Twig_Environment $env)
+ {
+ $this->env = $env;
+ }
+
+ public function getEnvironment()
+ {
+ return $this->env;
+ }
+
+ public function getVarName()
+ {
+ return sprintf('__internal_%s_%d', substr($this->env->getTemplateClass($this->stream->getFilename()), strlen($this->env->getTemplateClassPrefix())), ++$this->tmpVarCount);
+ }
+
+ /**
+ * Converts a token stream to a node tree.
+ *
+ * @param Twig_TokenStream $stream A token stream instance
+ *
+ * @return Twig_Node_Module A node tree
+ */
+ public function parse(Twig_TokenStream $stream)
+ {
+ // push all variables into the stack to keep the current state of the parser
+ $vars = get_object_vars($this);
+ unset($vars['stack'], $vars['env'], $vars['handlers'], $vars['visitors'], $vars['expressionParser']);
+ $this->stack[] = $vars;
+
+ $this->tmpVarCount = 0;
+
+ // tag handlers
+ if (null === $this->handlers) {
+ $this->handlers = $this->env->getTokenParsers();
+ $this->handlers->setParser($this);
+ }
+
+ // node visitors
+ if (null === $this->visitors) {
+ $this->visitors = $this->env->getNodeVisitors();
+ }
+
+ if (null === $this->expressionParser) {
+ $this->expressionParser = new Twig_ExpressionParser($this, $this->env->getUnaryOperators(), $this->env->getBinaryOperators());
+ }
+
+ $this->stream = $stream;
+ $this->parent = null;
+ $this->blocks = array();
+ $this->macros = array();
+ $this->traits = array();
+ $this->blockStack = array();
+ $this->importedFunctions = array(array());
+
+ try {
+ $body = $this->subparse(null);
+
+ if (null !== $this->parent) {
+ if (null === $body = $this->filterBodyNodes($body)) {
+ $body = new Twig_Node();
+ }
+ }
+ } catch (Twig_Error_Syntax $e) {
+ if (null === $e->getTemplateFile()) {
+ $e->setTemplateFile($this->stream->getFilename());
+ }
+
+ throw $e;
+ }
+
+ $node = new Twig_Node_Module(new Twig_Node_Body(array($body)), $this->parent, new Twig_Node($this->blocks), new Twig_Node($this->macros), new Twig_Node($this->traits), $this->stream->getFilename());
+
+ $traverser = new Twig_NodeTraverser($this->env, $this->visitors);
+
+ $node = $traverser->traverse($node);
+
+ // restore previous stack so previous parse() call can resume working
+ foreach (array_pop($this->stack) as $key => $val) {
+ $this->$key = $val;
+ }
+
+ return $node;
+ }
+
+ public function subparse($test, $dropNeedle = false)
+ {
+ $lineno = $this->getCurrentToken()->getLine();
+ $rv = array();
+ while (!$this->stream->isEOF()) {
+ switch ($this->getCurrentToken()->getType()) {
+ case Twig_Token::TEXT_TYPE:
+ $token = $this->stream->next();
+ $rv[] = new Twig_Node_Text($token->getValue(), $token->getLine());
+ break;
+
+ case Twig_Token::VAR_START_TYPE:
+ $token = $this->stream->next();
+ $expr = $this->expressionParser->parseExpression();
+ $this->stream->expect(Twig_Token::VAR_END_TYPE);
+ $rv[] = new Twig_Node_Print($expr, $token->getLine());
+ break;
+
+ case Twig_Token::BLOCK_START_TYPE:
+ $this->stream->next();
+ $token = $this->getCurrentToken();
+
+ if ($token->getType() !== Twig_Token::NAME_TYPE) {
+ throw new Twig_Error_Syntax('A block must start with a tag name', $token->getLine(), $this->stream->getFilename());
+ }
+
+ if (null !== $test && call_user_func($test, $token)) {
+ if ($dropNeedle) {
+ $this->stream->next();
+ }
+
+ if (1 === count($rv)) {
+ return $rv[0];
+ }
+
+ return new Twig_Node($rv, array(), $lineno);
+ }
+
+ $subparser = $this->handlers->getTokenParser($token->getValue());
+ if (null === $subparser) {
+ if (null !== $test) {
+ throw new Twig_Error_Syntax(sprintf('Unexpected tag name "%s" (expecting closing tag for the "%s" tag defined near line %s)', $token->getValue(), $test[0]->getTag(), $lineno), $token->getLine(), $this->stream->getFilename());
+ }
+
+ $message = sprintf('Unknown tag name "%s"', $token->getValue());
+ if ($alternatives = $this->env->computeAlternatives($token->getValue(), array_keys($this->env->getTags()))) {
+ $message = sprintf('%s. Did you mean "%s"', $message, implode('", "', $alternatives));
+ }
+
+ throw new Twig_Error_Syntax($message, $token->getLine(), $this->stream->getFilename());
+ }
+
+ $this->stream->next();
+
+ $node = $subparser->parse($token);
+ if (null !== $node) {
+ $rv[] = $node;
+ }
+ break;
+
+ default:
+ throw new Twig_Error_Syntax('Lexer or parser ended up in unsupported state.', -1, $this->stream->getFilename());
+ }
+ }
+
+ if (1 === count($rv)) {
+ return $rv[0];
+ }
+
+ return new Twig_Node($rv, array(), $lineno);
+ }
+
+ public function addHandler($name, $class)
+ {
+ $this->handlers[$name] = $class;
+ }
+
+ public function addNodeVisitor(Twig_NodeVisitorInterface $visitor)
+ {
+ $this->visitors[] = $visitor;
+ }
+
+ public function getBlockStack()
+ {
+ return $this->blockStack;
+ }
+
+ public function peekBlockStack()
+ {
+ return $this->blockStack[count($this->blockStack) - 1];
+ }
+
+ public function popBlockStack()
+ {
+ array_pop($this->blockStack);
+ }
+
+ public function pushBlockStack($name)
+ {
+ $this->blockStack[] = $name;
+ }
+
+ public function hasBlock($name)
+ {
+ return isset($this->blocks[$name]);
+ }
+
+ public function setBlock($name, $value)
+ {
+ $this->blocks[$name] = new Twig_Node_Body(array($value));
+ }
+
+ public function hasMacro($name)
+ {
+ return isset($this->macros[$name]);
+ }
+
+ public function setMacro($name, Twig_Node_Macro $node)
+ {
+ if (null === $this->reservedMacroNames) {
+ $this->reservedMacroNames = array();
+ $r = new ReflectionClass($this->env->getBaseTemplateClass());
+ foreach ($r->getMethods() as $method) {
+ $this->reservedMacroNames[] = $method->getName();
+ }
+ }
+
+ if (in_array($name, $this->reservedMacroNames)) {
+ throw new Twig_Error_Syntax(sprintf('"%s" cannot be used as a macro name as it is a reserved keyword', $name), $node->getLine());
+ }
+
+ $this->macros[$name] = $node;
+ }
+
+ public function addTrait($trait)
+ {
+ $this->traits[] = $trait;
+ }
+
+ public function hasTraits()
+ {
+ return count($this->traits) > 0;
+ }
+
+ public function addImportedFunction($alias, $name, Twig_Node_Expression $node)
+ {
+ $this->importedFunctions[0][$alias] = array('name' => $name, 'node' => $node);
+ }
+
+ public function getImportedFunction($alias)
+ {
+ foreach ($this->importedFunctions as $functions) {
+ if (isset($functions[$alias])) {
+ return $functions[$alias];
+ }
+ }
+ }
+
+ public function isMainScope()
+ {
+ return 1 === count($this->importedFunctions);
+ }
+
+ public function pushLocalScope()
+ {
+ array_unshift($this->importedFunctions, array());
+ }
+
+ public function popLocalScope()
+ {
+ array_shift($this->importedFunctions);
+ }
+
+ /**
+ * Gets the expression parser.
+ *
+ * @return Twig_ExpressionParser The expression parser
+ */
+ public function getExpressionParser()
+ {
+ return $this->expressionParser;
+ }
+
+ public function getParent()
+ {
+ return $this->parent;
+ }
+
+ public function setParent($parent)
+ {
+ $this->parent = $parent;
+ }
+
+ /**
+ * Gets the token stream.
+ *
+ * @return Twig_TokenStream The token stream
+ */
+ public function getStream()
+ {
+ return $this->stream;
+ }
+
+ /**
+ * Gets the current token.
+ *
+ * @return Twig_Token The current token
+ */
+ public function getCurrentToken()
+ {
+ return $this->stream->getCurrent();
+ }
+
+ protected function filterBodyNodes(Twig_NodeInterface $node)
+ {
+ // check that the body does not contain non-empty output nodes
+ if (
+ ($node instanceof Twig_Node_Text && !ctype_space($node->getAttribute('data')))
+ ||
+ (!$node instanceof Twig_Node_Text && !$node instanceof Twig_Node_BlockReference && $node instanceof Twig_NodeOutputInterface)
+ ) {
+ if (false !== strpos((string) $node, chr(0xEF).chr(0xBB).chr(0xBF))) {
+ throw new Twig_Error_Syntax('A template that extends another one cannot have a body but a byte order mark (BOM) has been detected; it must be removed.', $node->getLine(), $this->stream->getFilename());
+ } else {
+ throw new Twig_Error_Syntax('A template that extends another one cannot have a body.', $node->getLine(), $this->stream->getFilename());
+ }
+ }
+
+ // bypass "set" nodes as they "capture" the output
+ if ($node instanceof Twig_Node_Set) {
+ return $node;
+ }
+
+ if ($node instanceof Twig_NodeOutputInterface) {
+ return;
+ }
+
+ foreach ($node as $k => $n) {
+ if (null !== $n && null === $n = $this->filterBodyNodes($n)) {
+ $node->removeNode($k);
+ }
+ }
+
+ return $node;
+ }
+}
diff --git a/lib/twig/lib/Twig/ParserInterface.php b/lib/twig/lib/Twig/ParserInterface.php
new file mode 100755
index 0000000..4cb6d28
--- /dev/null
+++ b/lib/twig/lib/Twig/ParserInterface.php
@@ -0,0 +1,28 @@
+
+ */
+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 parse(Twig_TokenStream $stream);
+}
diff --git a/lib/twig/lib/Twig/Sandbox/SecurityError.php b/lib/twig/lib/Twig/Sandbox/SecurityError.php
new file mode 100755
index 0000000..debabb7
--- /dev/null
+++ b/lib/twig/lib/Twig/Sandbox/SecurityError.php
@@ -0,0 +1,20 @@
+
+ */
+class Twig_Sandbox_SecurityError extends Twig_Error
+{
+}
diff --git a/lib/twig/lib/Twig/Sandbox/SecurityPolicy.php b/lib/twig/lib/Twig/Sandbox/SecurityPolicy.php
new file mode 100755
index 0000000..ba912ef
--- /dev/null
+++ b/lib/twig/lib/Twig/Sandbox/SecurityPolicy.php
@@ -0,0 +1,120 @@
+
+ */
+class Twig_Sandbox_SecurityPolicy implements Twig_Sandbox_SecurityPolicyInterface
+{
+ protected $allowedTags;
+ protected $allowedFilters;
+ protected $allowedMethods;
+ protected $allowedProperties;
+ protected $allowedFunctions;
+
+ public function __construct(array $allowedTags = array(), array $allowedFilters = array(), array $allowedMethods = array(), array $allowedProperties = array(), array $allowedFunctions = array())
+ {
+ $this->allowedTags = $allowedTags;
+ $this->allowedFilters = $allowedFilters;
+ $this->setAllowedMethods($allowedMethods);
+ $this->allowedProperties = $allowedProperties;
+ $this->allowedFunctions = $allowedFunctions;
+ }
+
+ public function setAllowedTags(array $tags)
+ {
+ $this->allowedTags = $tags;
+ }
+
+ public function setAllowedFilters(array $filters)
+ {
+ $this->allowedFilters = $filters;
+ }
+
+ public function setAllowedMethods(array $methods)
+ {
+ $this->allowedMethods = array();
+ foreach ($methods as $class => $m) {
+ $this->allowedMethods[$class] = array_map('strtolower', is_array($m) ? $m : array($m));
+ }
+ }
+
+ public function setAllowedProperties(array $properties)
+ {
+ $this->allowedProperties = $properties;
+ }
+
+ public function setAllowedFunctions(array $functions)
+ {
+ $this->allowedFunctions = $functions;
+ }
+
+ public function checkSecurity($tags, $filters, $functions)
+ {
+ foreach ($tags as $tag) {
+ if (!in_array($tag, $this->allowedTags)) {
+ throw new Twig_Sandbox_SecurityError(sprintf('Tag "%s" is not allowed.', $tag));
+ }
+ }
+
+ foreach ($filters as $filter) {
+ if (!in_array($filter, $this->allowedFilters)) {
+ throw new Twig_Sandbox_SecurityError(sprintf('Filter "%s" is not allowed.', $filter));
+ }
+ }
+
+ foreach ($functions as $function) {
+ if (!in_array($function, $this->allowedFunctions)) {
+ throw new Twig_Sandbox_SecurityError(sprintf('Function "%s" is not allowed.', $function));
+ }
+ }
+ }
+
+ public function checkMethodAllowed($obj, $method)
+ {
+ if ($obj instanceof Twig_TemplateInterface || $obj instanceof Twig_Markup) {
+ return true;
+ }
+
+ $allowed = false;
+ $method = strtolower($method);
+ foreach ($this->allowedMethods as $class => $methods) {
+ if ($obj instanceof $class) {
+ $allowed = in_array($method, $methods);
+
+ break;
+ }
+ }
+
+ if (!$allowed) {
+ throw new Twig_Sandbox_SecurityError(sprintf('Calling "%s" method on a "%s" object is not allowed.', $method, get_class($obj)));
+ }
+ }
+
+ public function checkPropertyAllowed($obj, $property)
+ {
+ $allowed = false;
+ foreach ($this->allowedProperties as $class => $properties) {
+ if ($obj instanceof $class) {
+ $allowed = in_array($property, is_array($properties) ? $properties : array($properties));
+
+ break;
+ }
+ }
+
+ if (!$allowed) {
+ throw new Twig_Sandbox_SecurityError(sprintf('Calling "%s" property on a "%s" object is not allowed.', $property, get_class($obj)));
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/Sandbox/SecurityPolicyInterface.php b/lib/twig/lib/Twig/Sandbox/SecurityPolicyInterface.php
new file mode 100755
index 0000000..d5015af
--- /dev/null
+++ b/lib/twig/lib/Twig/Sandbox/SecurityPolicyInterface.php
@@ -0,0 +1,25 @@
+
+ */
+interface Twig_Sandbox_SecurityPolicyInterface
+{
+ function checkSecurity($tags, $filters, $functions);
+
+ function checkMethodAllowed($obj, $method);
+
+ function checkPropertyAllowed($obj, $method);
+}
diff --git a/lib/twig/lib/Twig/Template.php b/lib/twig/lib/Twig/Template.php
new file mode 100755
index 0000000..1862064
--- /dev/null
+++ b/lib/twig/lib/Twig/Template.php
@@ -0,0 +1,462 @@
+
+ */
+abstract class Twig_Template implements Twig_TemplateInterface
+{
+ static protected $cache = array();
+
+ protected $parent;
+ protected $parents;
+ protected $env;
+ protected $blocks;
+ protected $traits;
+
+ /**
+ * Constructor.
+ *
+ * @param Twig_Environment $env A Twig_Environment instance
+ */
+ public function __construct(Twig_Environment $env)
+ {
+ $this->env = $env;
+ $this->blocks = array();
+ $this->traits = array();
+ }
+
+ /**
+ * Returns the template name.
+ *
+ * @return string The template name
+ */
+ abstract public function getTemplateName();
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getEnvironment()
+ {
+ return $this->env;
+ }
+
+ /**
+ * Returns the parent template.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @return Twig_TemplateInterface|false The parent template or false if there is no parent
+ */
+ public function getParent(array $context)
+ {
+ if (null !== $this->parent) {
+ return $this->parent;
+ }
+
+ $parent = $this->doGetParent($context);
+ if (false === $parent) {
+ return false;
+ } elseif ($parent instanceof Twig_Template) {
+ $name = $parent->getTemplateName();
+ $this->parents[$name] = $parent;
+ $parent = $name;
+ } elseif (!isset($this->parents[$parent])) {
+ $this->parents[$parent] = $this->env->loadTemplate($parent);
+ }
+
+ return $this->parents[$parent];
+ }
+
+ protected function doGetParent(array $context)
+ {
+ return false;
+ }
+
+ public function isTraitable()
+ {
+ return true;
+ }
+
+ /**
+ * Displays a parent block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to display from the parent
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ */
+ public function displayParentBlock($name, array $context, array $blocks = array())
+ {
+ $name = (string) $name;
+
+ if (isset($this->traits[$name])) {
+ $this->traits[$name][0]->displayBlock($name, $context, $blocks);
+ } elseif (false !== $parent = $this->getParent($context)) {
+ $parent->displayBlock($name, $context, $blocks);
+ } else {
+ throw new Twig_Error_Runtime(sprintf('The template has no parent and no traits defining the "%s" block', $name), -1, $this->getTemplateName());
+ }
+ }
+
+ /**
+ * Displays a block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to display
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ */
+ public function displayBlock($name, array $context, array $blocks = array())
+ {
+ $name = (string) $name;
+
+ if (isset($blocks[$name])) {
+ $b = $blocks;
+ unset($b[$name]);
+ call_user_func($blocks[$name], $context, $b);
+ } elseif (isset($this->blocks[$name])) {
+ call_user_func($this->blocks[$name], $context, $blocks);
+ } elseif (false !== $parent = $this->getParent($context)) {
+ $parent->displayBlock($name, $context, array_merge($this->blocks, $blocks));
+ }
+ }
+
+ /**
+ * Renders a parent block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to render from the parent
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ *
+ * @return string The rendered block
+ */
+ public function renderParentBlock($name, array $context, array $blocks = array())
+ {
+ ob_start();
+ $this->displayParentBlock($name, $context, $blocks);
+
+ return ob_get_clean();
+ }
+
+ /**
+ * Renders a block.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @param string $name The block name to render
+ * @param array $context The context
+ * @param array $blocks The current set of blocks
+ *
+ * @return string The rendered block
+ */
+ public function renderBlock($name, array $context, array $blocks = array())
+ {
+ ob_start();
+ $this->displayBlock($name, $context, $blocks);
+
+ return ob_get_clean();
+ }
+
+ /**
+ * Returns whether a block exists or not.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * This method does only return blocks defined in the current template
+ * or defined in "used" traits.
+ *
+ * It does not return blocks from parent templates as the parent
+ * template name can be dynamic, which is only known based on the
+ * current context.
+ *
+ * @param string $name The block name
+ *
+ * @return Boolean true if the block exists, false otherwise
+ */
+ public function hasBlock($name)
+ {
+ return isset($this->blocks[(string) $name]);
+ }
+
+ /**
+ * Returns all block names.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @return array An array of block names
+ *
+ * @see hasBlock
+ */
+ public function getBlockNames()
+ {
+ return array_keys($this->blocks);
+ }
+
+ /**
+ * Returns all blocks.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * @return array An array of blocks
+ *
+ * @see hasBlock
+ */
+ public function getBlocks()
+ {
+ return $this->blocks;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function display(array $context, array $blocks = array())
+ {
+ $this->displayWithErrorHandling($this->mergeContextWithGlobals($context), $blocks);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function render(array $context)
+ {
+ $level = ob_get_level();
+ ob_start();
+ try {
+ $this->display($context);
+ } catch (Exception $e) {
+ while (ob_get_level() > $level) {
+ ob_end_clean();
+ }
+
+ throw $e;
+ }
+
+ return ob_get_clean();
+ }
+
+ protected function mergeContextWithGlobals(array $context)
+ {
+ // we don't use array_merge as the context being generally
+ // bigger than globals, this code is faster.
+ foreach ($this->env->getGlobals() as $key => $value) {
+ if (!array_key_exists($key, $context)) {
+ $context[$key] = $value;
+ }
+ }
+
+ return $context;
+ }
+
+ protected function displayWithErrorHandling(array $context, array $blocks = array())
+ {
+ try {
+ $this->doDisplay($context, $blocks);
+ } catch (Twig_Error $e) {
+ throw $e;
+ } catch (Exception $e) {
+ throw new Twig_Error_Runtime(sprintf('An exception has been thrown during the rendering of a template ("%s").', $e->getMessage()), -1, null, $e);
+ }
+ }
+
+ /**
+ * Auto-generated method to display the template with the given context.
+ *
+ * @param array $context An array of parameters to pass to the template
+ * @param array $blocks An array of blocks to pass to the template
+ */
+ abstract protected function doDisplay(array $context, array $blocks = array());
+
+ /**
+ * Returns a variable from the context.
+ *
+ * This method is for internal use only and should never be called
+ * directly.
+ *
+ * This method should not be overriden in a sub-class as this is an
+ * implementation detail that has been introduced to optimize variable
+ * access for versions of PHP before 5.4. This is not a way to override
+ * the way to get a variable value.
+ *
+ * @param array $context The context
+ * @param string $item The variable to return from the context
+ * @param Boolean $ignoreStrictCheck Whether to ignore the strict variable check or not
+ *
+ * @return The content of the context variable
+ *
+ * @throws Twig_Error_Runtime if the variable does not exist and Twig is running in strict mode
+ */
+ final protected function getContext($context, $item, $ignoreStrictCheck = false)
+ {
+ if (!array_key_exists($item, $context)) {
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+
+ throw new Twig_Error_Runtime(sprintf('Variable "%s" does not exist', $item));
+ }
+
+ return $context[$item];
+ }
+
+ /**
+ * Returns the attribute value for a given array/object.
+ *
+ * @param mixed $object The object or array from where to get the item
+ * @param mixed $item The item to get from the array or object
+ * @param array $arguments An array of arguments to pass if the item is an object method
+ * @param string $type The type of attribute (@see Twig_TemplateInterface)
+ * @param Boolean $isDefinedTest Whether this is only a defined check
+ * @param Boolean $ignoreStrictCheck Whether to ignore the strict attribute check or not
+ *
+ * @return mixed The attribute value, or a Boolean when $isDefinedTest is true, or null when the attribute is not set and $ignoreStrictCheck is true
+ *
+ * @throws Twig_Error_Runtime if the attribute does not exist and Twig is running in strict mode and $isDefinedTest is false
+ */
+ protected function getAttribute($object, $item, array $arguments = array(), $type = Twig_TemplateInterface::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false)
+ {
+ $item = (string) $item;
+
+ // array
+ if (Twig_TemplateInterface::METHOD_CALL !== $type) {
+ if ((is_array($object) && array_key_exists($item, $object))
+ || ($object instanceof ArrayAccess && isset($object[$item]))
+ ) {
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ return $object[$item];
+ }
+
+ if (Twig_TemplateInterface::ARRAY_CALL === $type) {
+ if ($isDefinedTest) {
+ return false;
+ }
+
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+
+ if (is_object($object)) {
+ throw new Twig_Error_Runtime(sprintf('Key "%s" in object (with ArrayAccess) of type "%s" does not exist', $item, get_class($object)));
+ // array
+ } else {
+ throw new Twig_Error_Runtime(sprintf('Key "%s" for array with keys "%s" does not exist', $item, implode(', ', array_keys($object))));
+ }
+ }
+ }
+
+ if (!is_object($object)) {
+ if ($isDefinedTest) {
+ return false;
+ }
+
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+
+ throw new Twig_Error_Runtime(sprintf('Item "%s" for "%s" does not exist', $item, is_array($object) ? 'Array' : $object));
+ }
+
+ $class = get_class($object);
+
+ // object property
+ if (Twig_TemplateInterface::METHOD_CALL !== $type) {
+ /* apparently, this is not needed as this is already covered by the array_key_exists() call below
+ if (!isset(self::$cache[$class]['properties'])) {
+ foreach (get_object_vars($object) as $k => $v) {
+ self::$cache[$class]['properties'][$k] = true;
+ }
+ }
+ */
+
+ if (isset($object->$item) || array_key_exists($item, $object)) {
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item);
+ }
+
+ return $object->$item;
+ }
+ }
+
+ // object method
+ if (!isset(self::$cache[$class]['methods'])) {
+ self::$cache[$class]['methods'] = array_change_key_case(array_flip(get_class_methods($object)));
+ }
+
+ $lcItem = strtolower($item);
+ if (isset(self::$cache[$class]['methods'][$lcItem])) {
+ $method = $item;
+ } elseif (isset(self::$cache[$class]['methods']['get'.$lcItem])) {
+ $method = 'get'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['is'.$lcItem])) {
+ $method = 'is'.$item;
+ } elseif (isset(self::$cache[$class]['methods']['__call'])) {
+ $method = $item;
+ } else {
+ if ($isDefinedTest) {
+ return false;
+ }
+
+ if ($ignoreStrictCheck || !$this->env->isStrictVariables()) {
+ return null;
+ }
+
+ throw new Twig_Error_Runtime(sprintf('Method "%s" for object "%s" does not exist', $item, get_class($object)));
+ }
+
+ if ($isDefinedTest) {
+ return true;
+ }
+
+ if ($this->env->hasExtension('sandbox')) {
+ $this->env->getExtension('sandbox')->checkMethodAllowed($object, $method);
+ }
+
+ $ret = call_user_func_array(array($object, $method), $arguments);
+
+ // hack to be removed when macro calls are refactored
+ if ($object instanceof Twig_TemplateInterface) {
+ return $ret === '' ? '' : new Twig_Markup($ret, $this->env->getCharset());
+ }
+
+ return $ret;
+ }
+
+ /**
+ * This method is only useful when testing Twig. Do not use it.
+ */
+ static public function clearCache()
+ {
+ self::$cache = array();
+ }
+}
diff --git a/lib/twig/lib/Twig/TemplateInterface.php b/lib/twig/lib/Twig/TemplateInterface.php
new file mode 100755
index 0000000..08da116
--- /dev/null
+++ b/lib/twig/lib/Twig/TemplateInterface.php
@@ -0,0 +1,47 @@
+
+ */
+interface Twig_TemplateInterface
+{
+ const ANY_CALL = 'any';
+ const ARRAY_CALL = 'array';
+ const METHOD_CALL = 'method';
+
+ /**
+ * Renders the template with the given context and returns it as string.
+ *
+ * @param array $context An array of parameters to pass to the template
+ *
+ * @return string The rendered template
+ */
+ function render(array $context);
+
+ /**
+ * Displays the template with the given context.
+ *
+ * @param array $context An array of parameters to pass to the template
+ * @param array $blocks An array of blocks to pass to the template
+ */
+ function display(array $context, array $blocks = array());
+
+ /**
+ * Returns the bound environment for this template.
+ *
+ * @return Twig_Environment The current environment
+ */
+ function getEnvironment();
+}
diff --git a/lib/twig/lib/Twig/Test/Function.php b/lib/twig/lib/Twig/Test/Function.php
new file mode 100755
index 0000000..1240a0f
--- /dev/null
+++ b/lib/twig/lib/Twig/Test/Function.php
@@ -0,0 +1,31 @@
+
+ */
+class Twig_Test_Function implements Twig_TestInterface
+{
+ protected $function;
+
+ public function __construct($function)
+ {
+ $this->function = $function;
+ }
+
+ public function compile()
+ {
+ return $this->function;
+ }
+}
diff --git a/lib/twig/lib/Twig/Test/Method.php b/lib/twig/lib/Twig/Test/Method.php
new file mode 100755
index 0000000..a3b3948
--- /dev/null
+++ b/lib/twig/lib/Twig/Test/Method.php
@@ -0,0 +1,32 @@
+
+ */
+class Twig_Test_Method implements Twig_TestInterface
+{
+ protected $extension, $method;
+
+ public function __construct(Twig_ExtensionInterface $extension, $method)
+ {
+ $this->extension = $extension;
+ $this->method = $method;
+ }
+
+ public function compile()
+ {
+ return sprintf('$this->env->getExtension(\'%s\')->%s', $this->extension->getName(), $this->method);
+ }
+}
diff --git a/lib/twig/lib/Twig/Test/Node.php b/lib/twig/lib/Twig/Test/Node.php
new file mode 100755
index 0000000..47a978e
--- /dev/null
+++ b/lib/twig/lib/Twig/Test/Node.php
@@ -0,0 +1,35 @@
+
+ */
+class Twig_Test_Node implements Twig_TestInterface
+{
+ protected $class;
+
+ public function __construct($class)
+ {
+ $this->class = $class;
+ }
+
+ public function getClass()
+ {
+ return $this->class;
+ }
+
+ public function compile()
+ {
+ }
+}
diff --git a/lib/twig/lib/Twig/TestInterface.php b/lib/twig/lib/Twig/TestInterface.php
new file mode 100755
index 0000000..c2ff725
--- /dev/null
+++ b/lib/twig/lib/Twig/TestInterface.php
@@ -0,0 +1,26 @@
+
+ */
+interface Twig_TestInterface
+{
+ /**
+ * Compiles a test.
+ *
+ * @return string The PHP code for the test
+ */
+ function compile();
+}
diff --git a/lib/twig/lib/Twig/Token.php b/lib/twig/lib/Twig/Token.php
new file mode 100755
index 0000000..918bb91
--- /dev/null
+++ b/lib/twig/lib/Twig/Token.php
@@ -0,0 +1,219 @@
+
+ */
+class Twig_Token
+{
+ protected $value;
+ protected $type;
+ protected $lineno;
+
+ const EOF_TYPE = -1;
+ const TEXT_TYPE = 0;
+ const BLOCK_START_TYPE = 1;
+ const VAR_START_TYPE = 2;
+ const BLOCK_END_TYPE = 3;
+ const VAR_END_TYPE = 4;
+ const NAME_TYPE = 5;
+ const NUMBER_TYPE = 6;
+ const STRING_TYPE = 7;
+ const OPERATOR_TYPE = 8;
+ const PUNCTUATION_TYPE = 9;
+ const INTERPOLATION_START_TYPE = 10;
+ const INTERPOLATION_END_TYPE = 11;
+
+ /**
+ * Constructor.
+ *
+ * @param integer $type The type of the token
+ * @param string $value The token value
+ * @param integer $lineno The line position in the source
+ */
+ public function __construct($type, $value, $lineno)
+ {
+ $this->type = $type;
+ $this->value = $value;
+ $this->lineno = $lineno;
+ }
+
+ /**
+ * Returns a string representation of the token.
+ *
+ * @return string A string representation of the token
+ */
+ public function __toString()
+ {
+ return sprintf('%s(%s)', self::typeToString($this->type, true, $this->lineno), $this->value);
+ }
+
+ /**
+ * Tests the current token for a type and/or a value.
+ *
+ * Parameters may be:
+ * * just type
+ * * type and value (or array of possible values)
+ * * just value (or array of possible values) (NAME_TYPE is used as type)
+ *
+ * @param array|integer $type The type to test
+ * @param array|string|null $values The token value
+ *
+ * @return Boolean
+ */
+ public function test($type, $values = null)
+ {
+ if (null === $values && !is_int($type)) {
+ $values = $type;
+ $type = self::NAME_TYPE;
+ }
+
+ return ($this->type === $type) && (
+ null === $values ||
+ (is_array($values) && in_array($this->value, $values)) ||
+ $this->value == $values
+ );
+ }
+
+ /**
+ * Gets the line.
+ *
+ * @return integer The source line
+ */
+ public function getLine()
+ {
+ return $this->lineno;
+ }
+
+ /**
+ * Gets the token type.
+ *
+ * @return integer The token type
+ */
+ public function getType()
+ {
+ return $this->type;
+ }
+
+ /**
+ * Gets the token value.
+ *
+ * @return string The token value
+ */
+ public function getValue()
+ {
+ return $this->value;
+ }
+
+ /**
+ * Returns the constant representation (internal) of a given type.
+ *
+ * @param integer $type The type as an integer
+ * @param Boolean $short Whether to return a short representation or not
+ * @param integer $line The code line
+ *
+ * @return string The string representation
+ */
+ static public function typeToString($type, $short = false, $line = -1)
+ {
+ switch ($type) {
+ case self::EOF_TYPE:
+ $name = 'EOF_TYPE';
+ break;
+ case self::TEXT_TYPE:
+ $name = 'TEXT_TYPE';
+ break;
+ case self::BLOCK_START_TYPE:
+ $name = 'BLOCK_START_TYPE';
+ break;
+ case self::VAR_START_TYPE:
+ $name = 'VAR_START_TYPE';
+ break;
+ case self::BLOCK_END_TYPE:
+ $name = 'BLOCK_END_TYPE';
+ break;
+ case self::VAR_END_TYPE:
+ $name = 'VAR_END_TYPE';
+ break;
+ case self::NAME_TYPE:
+ $name = 'NAME_TYPE';
+ break;
+ case self::NUMBER_TYPE:
+ $name = 'NUMBER_TYPE';
+ break;
+ case self::STRING_TYPE:
+ $name = 'STRING_TYPE';
+ break;
+ case self::OPERATOR_TYPE:
+ $name = 'OPERATOR_TYPE';
+ break;
+ case self::PUNCTUATION_TYPE:
+ $name = 'PUNCTUATION_TYPE';
+ break;
+ case self::INTERPOLATION_START_TYPE:
+ $name = 'INTERPOLATION_START_TYPE';
+ break;
+ case self::INTERPOLATION_END_TYPE:
+ $name = 'INTERPOLATION_END_TYPE';
+ break;
+ default:
+ throw new Twig_Error_Syntax(sprintf('Token of type "%s" does not exist.', $type), $line);
+ }
+
+ return $short ? $name : 'Twig_Token::'.$name;
+ }
+
+ /**
+ * Returns the english representation of a given type.
+ *
+ * @param integer $type The type as an integer
+ * @param integer $line The code line
+ *
+ * @return string The string representation
+ */
+ static public function typeToEnglish($type, $line = -1)
+ {
+ switch ($type) {
+ case self::EOF_TYPE:
+ return 'end of template';
+ case self::TEXT_TYPE:
+ return 'text';
+ case self::BLOCK_START_TYPE:
+ return 'begin of statement block';
+ case self::VAR_START_TYPE:
+ return 'begin of print statement';
+ case self::BLOCK_END_TYPE:
+ return 'end of statement block';
+ case self::VAR_END_TYPE:
+ return 'end of print statement';
+ case self::NAME_TYPE:
+ return 'name';
+ case self::NUMBER_TYPE:
+ return 'number';
+ case self::STRING_TYPE:
+ return 'string';
+ case self::OPERATOR_TYPE:
+ return 'operator';
+ case self::PUNCTUATION_TYPE:
+ return 'punctuation';
+ case self::INTERPOLATION_START_TYPE:
+ return 'begin of string interpolation';
+ case self::INTERPOLATION_END_TYPE:
+ return 'end of string interpolation';
+ default:
+ throw new Twig_Error_Syntax(sprintf('Token of type "%s" does not exist.', $type), $line);
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser.php b/lib/twig/lib/Twig/TokenParser.php
new file mode 100755
index 0000000..ab18bfa
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser.php
@@ -0,0 +1,34 @@
+
+ */
+abstract class Twig_TokenParser implements Twig_TokenParserInterface
+{
+ /**
+ * @var Twig_Parser
+ */
+ protected $parser;
+
+ /**
+ * Sets the parser associated with this token parser
+ *
+ * @param $parser A Twig_Parser instance
+ */
+ public function setParser(Twig_Parser $parser)
+ {
+ $this->parser = $parser;
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/AutoEscape.php b/lib/twig/lib/Twig/TokenParser/AutoEscape.php
new file mode 100755
index 0000000..880e664
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/AutoEscape.php
@@ -0,0 +1,77 @@
+
+ * {% 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 %}
+ *
+ */
+class Twig_TokenParser_AutoEscape 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();
+ $value = $this->parser->getStream()->expect(Twig_Token::NAME_TYPE)->getValue();
+ if (!in_array($value, array('true', 'false'))) {
+ throw new Twig_Error_Syntax("Autoescape value must be 'true' or 'false'", $lineno);
+ }
+ $value = 'true' === $value ? 'html' : false;
+
+ if ($this->parser->getStream()->test(Twig_Token::NAME_TYPE)) {
+ if (false === $value) {
+ throw new Twig_Error_Syntax('Unexpected escaping strategy as you set autoescaping to false.', $lineno);
+ }
+
+ $value = $this->parser->getStream()->next()->getValue();
+ }
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_AutoEscape($value, $body, $lineno, $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endautoescape');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'autoescape';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Block.php b/lib/twig/lib/Twig/TokenParser/Block.php
new file mode 100755
index 0000000..36643f7
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Block.php
@@ -0,0 +1,83 @@
+
+ * {% block head %}
+ *
+ * {% block title %}{% endblock %} - My Webpage
+ * {% endblock %}
+ *
+ */
+class Twig_TokenParser_Block 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();
+ $stream = $this->parser->getStream();
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ if ($this->parser->hasBlock($name)) {
+ throw new Twig_Error_Syntax("The block '$name' has already been defined", $lineno);
+ }
+ $this->parser->pushLocalScope();
+ $this->parser->pushBlockStack($name);
+
+ if ($stream->test(Twig_Token::BLOCK_END_TYPE)) {
+ $stream->next();
+
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ if ($stream->test(Twig_Token::NAME_TYPE)) {
+ $value = $stream->next()->getValue();
+
+ if ($value != $name) {
+ throw new Twig_Error_Syntax(sprintf("Expected endblock for block '$name' (but %s given)", $value), $lineno);
+ }
+ }
+ } else {
+ $body = new Twig_Node(array(
+ new Twig_Node_Print($this->parser->getExpressionParser()->parseExpression(), $lineno),
+ ));
+ }
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $block = new Twig_Node_Block($name, $body, $lineno);
+ $this->parser->setBlock($name, $block);
+ $this->parser->popBlockStack();
+ $this->parser->popLocalScope();
+
+ return new Twig_Node_BlockReference($name, $lineno, $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endblock');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'block';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Do.php b/lib/twig/lib/Twig/TokenParser/Do.php
new file mode 100755
index 0000000..593d1c6
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Do.php
@@ -0,0 +1,42 @@
+parser->getExpressionParser()->parseExpression();
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Do($expr, $token->getLine(), $this->getTag());
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'do';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Extends.php b/lib/twig/lib/Twig/TokenParser/Extends.php
new file mode 100755
index 0000000..54f49ad
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Extends.php
@@ -0,0 +1,54 @@
+
+ * {% extends "base.html" %}
+ *
+ */
+class Twig_TokenParser_Extends 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)
+ {
+ if (!$this->parser->isMainScope()) {
+ throw new Twig_Error_Syntax('Cannot extend from a block', $token->getLine());
+ }
+
+ if (null !== $this->parser->getParent()) {
+ throw new Twig_Error_Syntax('Multiple extends tags are forbidden', $token->getLine());
+ }
+ $this->parser->setParent($this->parser->getExpressionParser()->parseExpression());
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return null;
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'extends';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Filter.php b/lib/twig/lib/Twig/TokenParser/Filter.php
new file mode 100755
index 0000000..2b97475
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Filter.php
@@ -0,0 +1,61 @@
+
+ * {% filter upper %}
+ * This text becomes uppercase
+ * {% endfilter %}
+ *
+ */
+class Twig_TokenParser_Filter 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)
+ {
+ $name = $this->parser->getVarName();
+ $ref = new Twig_Node_Expression_BlockReference(new Twig_Node_Expression_Constant($name, $token->getLine()), true, $token->getLine(), $this->getTag());
+
+ $filter = $this->parser->getExpressionParser()->parseFilterExpressionRaw($ref, $this->getTag());
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $block = new Twig_Node_Block($name, $body, $token->getLine());
+ $this->parser->setBlock($name, $block);
+
+ return new Twig_Node_Print($filter, $token->getLine(), $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endfilter');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'filter';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Flush.php b/lib/twig/lib/Twig/TokenParser/Flush.php
new file mode 100755
index 0000000..4e15e78
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Flush.php
@@ -0,0 +1,42 @@
+parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Flush($token->getLine(), $this->getTag());
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'flush';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/For.php b/lib/twig/lib/Twig/TokenParser/For.php
new file mode 100755
index 0000000..2cbb580
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/For.php
@@ -0,0 +1,89 @@
+
+ *
+ * {% for user in users %}
+ * {{ user.username|e }}
+ * {% endfor %}
+ *
+ *
+ */
+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';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/From.php b/lib/twig/lib/Twig/TokenParser/From.php
new file mode 100755
index 0000000..4e20f5c
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/From.php
@@ -0,0 +1,74 @@
+
+ * {% from 'forms.html' import forms %}
+ *
+ */
+class Twig_TokenParser_From 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)
+ {
+ $macro = $this->parser->getExpressionParser()->parseExpression();
+ $stream = $this->parser->getStream();
+ $stream->expect('import');
+
+ $targets = array();
+ do {
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+
+ $alias = $name;
+ if ($stream->test('as')) {
+ $stream->next();
+
+ $alias = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ }
+
+ $targets[$name] = $alias;
+
+ if (!$stream->test(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+
+ $stream->next();
+ } while (true);
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $node = new Twig_Node_Import($macro, new Twig_Node_Expression_AssignName($this->parser->getVarName(), $token->getLine()), $token->getLine(), $this->getTag());
+
+ foreach($targets as $name => $alias) {
+ $this->parser->addImportedFunction($alias, 'get'.$name, $node->getNode('var'));
+ }
+
+ return $node;
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'from';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/If.php b/lib/twig/lib/Twig/TokenParser/If.php
new file mode 100755
index 0000000..1a694af
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/If.php
@@ -0,0 +1,93 @@
+
+ * {% if users %}
+ *
+ * {% for user in users %}
+ * {{ user.username|e }}
+ * {% endfor %}
+ *
+ * {% endif %}
+ *
+ */
+class Twig_TokenParser_If 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();
+ $expr = $this->parser->getExpressionParser()->parseExpression();
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideIfFork'));
+ $tests = array($expr, $body);
+ $else = null;
+
+ $end = false;
+ while (!$end) {
+ switch ($this->parser->getStream()->next()->getValue()) {
+ case 'else':
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $else = $this->parser->subparse(array($this, 'decideIfEnd'));
+ break;
+
+ case 'elseif':
+ $expr = $this->parser->getExpressionParser()->parseExpression();
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideIfFork'));
+ $tests[] = $expr;
+ $tests[] = $body;
+ break;
+
+ case 'endif':
+ $end = true;
+ break;
+
+ default:
+ throw new Twig_Error_Syntax(sprintf('Unexpected end of template. Twig was looking for the following tags "else", "elseif", or "endif" to close the "if" block started at line %d)', $lineno), -1);
+ }
+ }
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_If(new Twig_Node($tests), $else, $lineno, $this->getTag());
+ }
+
+ public function decideIfFork(Twig_Token $token)
+ {
+ return $token->test(array('elseif', 'else', 'endif'));
+ }
+
+ public function decideIfEnd(Twig_Token $token)
+ {
+ return $token->test(array('endif'));
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'if';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Import.php b/lib/twig/lib/Twig/TokenParser/Import.php
new file mode 100755
index 0000000..5219289
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Import.php
@@ -0,0 +1,47 @@
+
+ * {% import 'forms.html' as forms %}
+ *
+ */
+class Twig_TokenParser_Import 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)
+ {
+ $macro = $this->parser->getExpressionParser()->parseExpression();
+ $this->parser->getStream()->expect('as');
+ $var = new Twig_Node_Expression_AssignName($this->parser->getStream()->expect(Twig_Token::NAME_TYPE)->getValue(), $token->getLine());
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Import($macro, $var, $token->getLine(), $this->getTag());
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'import';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Include.php b/lib/twig/lib/Twig/TokenParser/Include.php
new file mode 100755
index 0000000..6725b8f
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Include.php
@@ -0,0 +1,71 @@
+
+ * {% include 'header.html' %}
+ * Body
+ * {% include 'footer.html' %}
+ *
+ */
+class Twig_TokenParser_Include 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)
+ {
+ $expr = $this->parser->getExpressionParser()->parseExpression();
+
+ $ignoreMissing = false;
+ if ($this->parser->getStream()->test(Twig_Token::NAME_TYPE, 'ignore')) {
+ $this->parser->getStream()->next();
+ $this->parser->getStream()->expect(Twig_Token::NAME_TYPE, 'missing');
+
+ $ignoreMissing = true;
+ }
+
+ $variables = null;
+ if ($this->parser->getStream()->test(Twig_Token::NAME_TYPE, 'with')) {
+ $this->parser->getStream()->next();
+
+ $variables = $this->parser->getExpressionParser()->parseExpression();
+ }
+
+ $only = false;
+ if ($this->parser->getStream()->test(Twig_Token::NAME_TYPE, 'only')) {
+ $this->parser->getStream()->next();
+
+ $only = true;
+ }
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Include($expr, $variables, $only, $ignoreMissing, $token->getLine(), $this->getTag());
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'include';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Macro.php b/lib/twig/lib/Twig/TokenParser/Macro.php
new file mode 100755
index 0000000..ffd5848
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Macro.php
@@ -0,0 +1,69 @@
+
+ * {% macro input(name, value, type, size) %}
+ *
+ * {% endmacro %}
+ *
+ */
+class Twig_TokenParser_Macro 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();
+ $name = $this->parser->getStream()->expect(Twig_Token::NAME_TYPE)->getValue();
+
+ $arguments = $this->parser->getExpressionParser()->parseArguments();
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $this->parser->pushLocalScope();
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ if ($this->parser->getStream()->test(Twig_Token::NAME_TYPE)) {
+ $value = $this->parser->getStream()->next()->getValue();
+
+ if ($value != $name) {
+ throw new Twig_Error_Syntax(sprintf("Expected endmacro for macro '$name' (but %s given)", $value), $lineno);
+ }
+ }
+ $this->parser->popLocalScope();
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $this->parser->setMacro($name, new Twig_Node_Macro($name, new Twig_Node_Body(array($body)), $arguments, $lineno, $this->getTag()));
+
+ return null;
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endmacro');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'macro';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Sandbox.php b/lib/twig/lib/Twig/TokenParser/Sandbox.php
new file mode 100755
index 0000000..0277c70
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Sandbox.php
@@ -0,0 +1,55 @@
+
+ * {% sandbox %}
+ * {% include 'user.html' %}
+ * {% endsandbox %}
+ *
+ *
+ * @see http://www.twig-project.org/doc/api.html#sandbox-extension for details
+ */
+class Twig_TokenParser_Sandbox 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)
+ {
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Sandbox($body, $token->getLine(), $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endsandbox');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'sandbox';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Set.php b/lib/twig/lib/Twig/TokenParser/Set.php
new file mode 100755
index 0000000..3b4479c
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Set.php
@@ -0,0 +1,84 @@
+
+ * {% set foo = 'foo' %}
+ *
+ * {% set foo = [1, 2] %}
+ *
+ * {% set foo = {'foo': 'bar'} %}
+ *
+ * {% set foo = 'foo' ~ 'bar' %}
+ *
+ * {% set foo, bar = 'foo', 'bar' %}
+ *
+ * {% set foo %}Some content{% endset %}
+ *
+ */
+class Twig_TokenParser_Set 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();
+ $stream = $this->parser->getStream();
+ $names = $this->parser->getExpressionParser()->parseAssignmentExpression();
+
+ $capture = false;
+ if ($stream->test(Twig_Token::OPERATOR_TYPE, '=')) {
+ $stream->next();
+ $values = $this->parser->getExpressionParser()->parseMultitargetExpression();
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ if (count($names) !== count($values)) {
+ throw new Twig_Error_Syntax("When using set, you must have the same number of variables and assignements.", $lineno);
+ }
+ } else {
+ $capture = true;
+
+ if (count($names) > 1) {
+ throw new Twig_Error_Syntax("When using set with a block, you cannot have a multi-target.", $lineno);
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $values = $this->parser->subparse(array($this, 'decideBlockEnd'), true);
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ }
+
+ return new Twig_Node_Set($capture, $names, $values, $lineno, $this->getTag());
+ }
+
+ public function decideBlockEnd(Twig_Token $token)
+ {
+ return $token->test('endset');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'set';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Spaceless.php b/lib/twig/lib/Twig/TokenParser/Spaceless.php
new file mode 100755
index 0000000..1e3fa8f
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Spaceless.php
@@ -0,0 +1,59 @@
+
+ * {% spaceless %}
+ *
+ * foo
+ *
+ * {% endspaceless %}
+ *
+ * {# output will be foo
#}
+ *
+ */
+class Twig_TokenParser_Spaceless 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();
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+ $body = $this->parser->subparse(array($this, 'decideSpacelessEnd'), true);
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Spaceless($body, $lineno, $this->getTag());
+ }
+
+ public function decideSpacelessEnd(Twig_Token $token)
+ {
+ return $token->test('endspaceless');
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'spaceless';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParser/Use.php b/lib/twig/lib/Twig/TokenParser/Use.php
new file mode 100755
index 0000000..beafc80
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParser/Use.php
@@ -0,0 +1,85 @@
+
+ * {% extends "base.html" %}
+ *
+ * {% use "blocks.html" %}
+ *
+ * {% block title %}{% endblock %}
+ * {% block content %}{% endblock %}
+ *
+ *
+ * @see http://www.twig-project.org/doc/templates.html#horizontal-reuse for details.
+ */
+class Twig_TokenParser_Use 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)
+ {
+ $template = $this->parser->getExpressionParser()->parseExpression();
+
+ if (!$template instanceof Twig_Node_Expression_Constant) {
+ throw new Twig_Error_Syntax('The template references in a "use" statement must be a string.', $token->getLine());
+ }
+
+ $stream = $this->parser->getStream();
+
+ $targets = array();
+ if ($stream->test('with')) {
+ $stream->next();
+
+ do {
+ $name = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+
+ $alias = $name;
+ if ($stream->test('as')) {
+ $stream->next();
+
+ $alias = $stream->expect(Twig_Token::NAME_TYPE)->getValue();
+ }
+
+ $targets[$name] = new Twig_Node_Expression_Constant($alias, -1);
+
+ if (!$stream->test(Twig_Token::PUNCTUATION_TYPE, ',')) {
+ break;
+ }
+
+ $stream->next();
+ } while (true);
+ }
+
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+
+ $this->parser->addTrait(new Twig_Node(array('template' => $template, 'targets' => new Twig_Node($targets))));
+
+ return null;
+ }
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ public function getTag()
+ {
+ return 'use';
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParserBroker.php b/lib/twig/lib/Twig/TokenParserBroker.php
new file mode 100755
index 0000000..b214e99
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParserBroker.php
@@ -0,0 +1,113 @@
+
+ */
+class Twig_TokenParserBroker implements Twig_TokenParserBrokerInterface
+{
+ protected $parser;
+ protected $parsers = array();
+ protected $brokers = array();
+
+ /**
+ * Constructor.
+ *
+ * @param array|Traversable $parsers A Traversable of Twig_TokenParserInterface instances
+ * @param array|Traversable $brokers A Traversable of Twig_TokenParserBrokerInterface instances
+ */
+ public function __construct($parsers = array(), $brokers = array())
+ {
+ foreach ($parsers as $parser) {
+ if (!$parser instanceof Twig_TokenParserInterface) {
+ throw new Twig_Error('$parsers must a an array of Twig_TokenParserInterface');
+ }
+ $this->parsers[$parser->getTag()] = $parser;
+ }
+ foreach ($brokers as $broker) {
+ if (!$broker instanceof Twig_TokenParserBrokerInterface) {
+ throw new Twig_Error('$brokers must a an array of Twig_TokenParserBrokerInterface');
+ }
+ $this->brokers[] = $broker;
+ }
+ }
+
+ /**
+ * Adds a TokenParser.
+ *
+ * @param Twig_TokenParserInterface $parser A Twig_TokenParserInterface instance
+ */
+ public function addTokenParser(Twig_TokenParserInterface $parser)
+ {
+ $this->parsers[$parser->getTag()] = $parser;
+ }
+
+ /**
+ * Adds a TokenParserBroker.
+ *
+ * @param Twig_TokenParserBroker $broker A Twig_TokenParserBroker instance
+ */
+ public function addTokenParserBroker(Twig_TokenParserBroker $broker)
+ {
+ $this->brokers[] = $broker;
+ }
+
+ /**
+ * Gets a suitable TokenParser for a tag.
+ *
+ * First looks in parsers, then in brokers.
+ *
+ * @param string $tag A tag name
+ *
+ * @return null|Twig_TokenParserInterface A Twig_TokenParserInterface or null if no suitable TokenParser was found
+ */
+ public function getTokenParser($tag)
+ {
+ if (isset($this->parsers[$tag])) {
+ return $this->parsers[$tag];
+ }
+ $broker = end($this->brokers);
+ while (false !== $broker) {
+ $parser = $broker->getTokenParser($tag);
+ if (null !== $parser) {
+ return $parser;
+ }
+ $broker = prev($this->brokers);
+ }
+
+ return null;
+ }
+
+ public function getParsers()
+ {
+ return $this->parsers;
+ }
+
+ public function getParser()
+ {
+ return $this->parser;
+ }
+
+ public function setParser(Twig_ParserInterface $parser)
+ {
+ $this->parser = $parser;
+ foreach ($this->parsers as $tokenParser) {
+ $tokenParser->setParser($parser);
+ }
+ foreach ($this->brokers as $broker) {
+ $broker->setParser($parser);
+ }
+ }
+}
diff --git a/lib/twig/lib/Twig/TokenParserBrokerInterface.php b/lib/twig/lib/Twig/TokenParserBrokerInterface.php
new file mode 100755
index 0000000..3ce8ca2
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParserBrokerInterface.php
@@ -0,0 +1,45 @@
+
+ */
+interface Twig_TokenParserBrokerInterface
+{
+ /**
+ * Gets a TokenParser suitable for a tag.
+ *
+ * @param string $tag A tag name
+ *
+ * @return null|Twig_TokenParserInterface A Twig_TokenParserInterface or null if no suitable TokenParser was found
+ */
+ function getTokenParser($tag);
+
+ /**
+ * Calls Twig_TokenParserInterface::setParser on all parsers the implementation knows of.
+ *
+ * @param Twig_ParserInterface $parser A Twig_ParserInterface interface
+ */
+ function setParser(Twig_ParserInterface $parser);
+
+ /**
+ * Gets the Twig_ParserInterface.
+ *
+ * @return null|Twig_ParserInterface A Twig_ParserInterface instance of null
+ */
+ function getParser();
+}
diff --git a/lib/twig/lib/Twig/TokenParserInterface.php b/lib/twig/lib/Twig/TokenParserInterface.php
new file mode 100755
index 0000000..192c018
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenParserInterface.php
@@ -0,0 +1,42 @@
+
+ */
+interface Twig_TokenParserInterface
+{
+ /**
+ * Sets the parser associated with this token parser
+ *
+ * @param $parser A Twig_Parser instance
+ */
+ function setParser(Twig_Parser $parser);
+
+ /**
+ * Parses a token and returns a node.
+ *
+ * @param Twig_Token $token A Twig_Token instance
+ *
+ * @return Twig_NodeInterface A Twig_NodeInterface instance
+ */
+ function parse(Twig_Token $token);
+
+ /**
+ * Gets the tag name associated with this token parser.
+ *
+ * @return string The tag name
+ */
+ function getTag();
+}
diff --git a/lib/twig/lib/Twig/TokenStream.php b/lib/twig/lib/Twig/TokenStream.php
new file mode 100755
index 0000000..a2002b4
--- /dev/null
+++ b/lib/twig/lib/Twig/TokenStream.php
@@ -0,0 +1,140 @@
+
+ */
+class Twig_TokenStream
+{
+ protected $tokens;
+ protected $current;
+ protected $filename;
+
+ /**
+ * Constructor.
+ *
+ * @param array $tokens An array of tokens
+ * @param string $filename The name of the filename which tokens are associated with
+ */
+ public function __construct(array $tokens, $filename = null)
+ {
+ $this->tokens = $tokens;
+ $this->current = 0;
+ $this->filename = $filename;
+ }
+
+ /**
+ * Returns a string representation of the token stream.
+ *
+ * @return string
+ */
+ public function __toString()
+ {
+ return implode("\n", $this->tokens);
+ }
+
+ /**
+ * Sets the pointer to the next token and returns the old one.
+ *
+ * @return Twig_Token
+ */
+ public function next()
+ {
+ if (!isset($this->tokens[++$this->current])) {
+ throw new Twig_Error_Syntax('Unexpected end of template', -1, $this->filename);
+ }
+
+ return $this->tokens[$this->current - 1];
+ }
+
+ /**
+ * Tests a token and returns it or throws a syntax error.
+ *
+ * @return Twig_Token
+ */
+ public function expect($type, $value = null, $message = null)
+ {
+ $token = $this->tokens[$this->current];
+ if (!$token->test($type, $value)) {
+ $line = $token->getLine();
+ throw new Twig_Error_Syntax(sprintf('%sUnexpected token "%s" of value "%s" ("%s" expected%s)',
+ $message ? $message.'. ' : '',
+ Twig_Token::typeToEnglish($token->getType(), $line), $token->getValue(),
+ Twig_Token::typeToEnglish($type, $line), $value ? sprintf(' with value "%s"', $value) : ''),
+ $line,
+ $this->filename
+ );
+ }
+ $this->next();
+
+ return $token;
+ }
+
+ /**
+ * Looks at the next token.
+ *
+ * @param integer $number
+ *
+ * @return Twig_Token
+ */
+ public function look($number = 1)
+ {
+ if (!isset($this->tokens[$this->current + $number])) {
+ throw new Twig_Error_Syntax('Unexpected end of template', -1, $this->filename);
+ }
+
+ return $this->tokens[$this->current + $number];
+ }
+
+ /**
+ * Tests the current token
+ *
+ * @return bool
+ */
+ public function test($primary, $secondary = null)
+ {
+ return $this->tokens[$this->current]->test($primary, $secondary);
+ }
+
+ /**
+ * Checks if end of stream was reached
+ *
+ * @return bool
+ */
+ public function isEOF()
+ {
+ return $this->tokens[$this->current]->getType() === Twig_Token::EOF_TYPE;
+ }
+
+ /**
+ * Gets the current token
+ *
+ * @return Twig_Token
+ */
+ public function getCurrent()
+ {
+ return $this->tokens[$this->current];
+ }
+
+ /**
+ * Gets the filename associated with this stream
+ *
+ * @return string
+ */
+ public function getFilename()
+ {
+ return $this->filename;
+ }
+}
diff --git a/lib/twig/package.xml.tpl b/lib/twig/package.xml.tpl
new file mode 100755
index 0000000..f9a9b89
--- /dev/null
+++ b/lib/twig/package.xml.tpl
@@ -0,0 +1,64 @@
+
+
+ Twig
+ pear.twig-project.org
+ Twig is a PHP template engine.
+
+ 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.
+
+
+ Fabien Potencier
+ fabpot
+ fabien.potencier@symfony-project.org
+ yes
+
+
+ Armin Ronacher
+ armin
+ armin.ronacher@active-4.com
+ no
+
+ {{ date }}
+ {{ time }}
+
+ {{ version }}
+ {{ api_version }}
+
+
+ {{ stability }}
+ {{ stability }}
+
+ BSD Style
+ -
+
+
+
+
+
+
+
+
+{{ files }}
+
+
+
+
+
+
+
+ 5.2.4
+
+
+ 1.4.0
+
+
+
+
+
diff --git a/lib/twig/phpunit.xml.dist b/lib/twig/phpunit.xml.dist
new file mode 100755
index 0000000..6c5046f
--- /dev/null
+++ b/lib/twig/phpunit.xml.dist
@@ -0,0 +1,25 @@
+
+
+
+
+
+ ./test/Twig/
+
+
+
+
+
+ ./lib/Twig/
+
+
+
diff --git a/lib/twig/test/Twig/Tests/AutoloaderTest.php b/lib/twig/test/Twig/Tests/AutoloaderTest.php
new file mode 100755
index 0000000..c8b7999
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/AutoloaderTest.php
@@ -0,0 +1,21 @@
+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');
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/CompilerTest.php b/lib/twig/test/Twig/Tests/CompilerTest.php
new file mode 100755
index 0000000..ebe79ae
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/CompilerTest.php
@@ -0,0 +1,33 @@
+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);
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/ErrorTest.php b/lib/twig/test/Twig/Tests/ErrorTest.php
new file mode 100755
index 0000000..a63b5fa
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/ErrorTest.php
@@ -0,0 +1,81 @@
+ "\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...');
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/ExpressionParserTest.php b/lib/twig/test/Twig/Tests/ExpressionParserTest.php
new file mode 100755
index 0000000..b3f300f
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/ExpressionParserTest.php
@@ -0,0 +1,217 @@
+ 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
+ ),
+ ),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Extension/CoreTest.php b/lib/twig/test/Twig/Tests/Extension/CoreTest.php
new file mode 100755
index 0000000..89a7750
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Extension/CoreTest.php
@@ -0,0 +1,114 @@
+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, 'éÄ');
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Extension/SandboxTest.php b/lib/twig/test/Twig/Tests/Extension/SandboxTest.php
new file mode 100755
index 0000000..0768c65
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Extension/SandboxTest.php
@@ -0,0 +1,209 @@
+ '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' => <<{{ text }}{% endmacro %}
+{{ _self.test('username') }}
+EOF
+ ), array('macro'), array('escape'));
+
+ $this->assertEquals('username
', $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';
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/FileCachingTest.php b/lib/twig/test/Twig/Tests/FileCachingTest.php
new file mode 100755
index 0000000..2c77c06
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/FileCachingTest.php
@@ -0,0 +1,70 @@
+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);
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test b/lib/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test
new file mode 100755
index 0000000..02245e9
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/exceptions/unclosed_tag.test
@@ -0,0 +1,20 @@
+--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
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/array.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/array.test
new file mode 100755
index 0000000..c69b119
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/array.test
@@ -0,0 +1,61 @@
+--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
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/array_call.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/array_call.test
new file mode 100755
index 0000000..f3df328
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/array_call.test
@@ -0,0 +1,14 @@
+--TEST--
+Twig supports method calls
+--TEMPLATE--
+{{ items.foo }}
+{{ items['foo'] }}
+{{ items[foo] }}
+{{ items[items[foo]] }}
+--DATA--
+return array('foo' => 'bar', 'items' => array('foo' => 'bar', 'bar' => 'foo'))
+--EXPECT--
+bar
+bar
+foo
+bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/binary.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/binary.test
new file mode 100755
index 0000000..f5e6845
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/binary.test
@@ -0,0 +1,46 @@
+--TEST--
+Twig supports binary operations (+, -, *, /, ~, %, and, or)
+--TEMPLATE--
+{{ 1 + 1 }}
+{{ 2 - 1 }}
+{{ 2 * 2 }}
+{{ 2 / 2 }}
+{{ 3 % 2 }}
+{{ 1 and 1 }}
+{{ 1 and 0 }}
+{{ 0 and 1 }}
+{{ 0 and 0 }}
+{{ 1 or 1 }}
+{{ 1 or 0 }}
+{{ 0 or 1 }}
+{{ 0 or 0 }}
+{{ 0 or 1 and 0 }}
+{{ 1 or 0 and 1 }}
+{{ "foo" ~ "bar" }}
+{{ foo ~ "bar" }}
+{{ "foo" ~ bar }}
+{{ foo ~ bar }}
+{{ 20 // 7 }}
+--DATA--
+return array('foo' => 'bar', 'bar' => 'foo')
+--EXPECT--
+2
+1
+4
+1
+1
+1
+
+
+
+1
+1
+1
+
+
+1
+foobar
+barbar
+foofoo
+barfoo
+2
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/comparison.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/comparison.test
new file mode 100755
index 0000000..726b850
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/comparison.test
@@ -0,0 +1,14 @@
+--TEST--
+Twig supports comparison operators (==, !=, <, >, >=, <=)
+--TEMPLATE--
+{{ 1 > 2 }}/{{ 1 > 1 }}/{{ 1 >= 2 }}/{{ 1 >= 1 }}
+{{ 1 < 2 }}/{{ 1 < 1 }}/{{ 1 <= 2 }}/{{ 1 <= 1 }}
+{{ 1 == 1 }}/{{ 1 == 2 }}
+{{ 1 != 1 }}/{{ 1 != 2 }}
+--DATA--
+return array()
+--EXPECT--
+///1
+1//1/1
+1/
+/1
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/dotdot.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/dotdot.test
new file mode 100755
index 0000000..9cd0676
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/dotdot.test
@@ -0,0 +1,20 @@
+--TEST--
+Twig supports the .. operator
+--TEMPLATE--
+{% for i in 0..10 %}{{ i }} {% endfor %}
+
+{% for letter in 'a'..'z' %}{{ letter }} {% endfor %}
+
+{% for letter in 'a'|upper..'z'|upper %}{{ letter }} {% endfor %}
+
+{% for i in foo[0]..foo[1] %}{{ i }} {% endfor %}
+
+{% for i in 0 + 1 .. 10 - 1 %}{{ i }} {% endfor %}
+--DATA--
+return array('foo' => array(1, 10))
+--EXPECT--
+0 1 2 3 4 5 6 7 8 9 10
+a b c d e f g h i j k l m n o p q r s t u v w x y z
+A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+1 2 3 4 5 6 7 8 9 10
+1 2 3 4 5 6 7 8 9
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/grouping.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/grouping.test
new file mode 100755
index 0000000..79f8e0b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/grouping.test
@@ -0,0 +1,8 @@
+--TEST--
+Twig supports grouping of expressions
+--TEMPLATE--
+{{ (2 + 2) / 2 }}
+--DATA--
+return array()
+--EXPECT--
+2
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/literals.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/literals.test
new file mode 100755
index 0000000..7ae3bae
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/literals.test
@@ -0,0 +1,22 @@
+--TEST--
+Twig supports literals
+--TEMPLATE--
+1 {{ true }}
+2 {{ TRUE }}
+3 {{ false }}
+4 {{ FALSE }}
+5 {{ none }}
+6 {{ NONE }}
+7 {{ null }}
+8 {{ NULL }}
+--DATA--
+return array()
+--EXPECT--
+1 1
+2 1
+3
+4
+5
+6
+7
+8
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/magic_call.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/magic_call.test
new file mode 100755
index 0000000..159db96
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/magic_call.test
@@ -0,0 +1,27 @@
+--TEST--
+Twig supports __call() for attributes
+--TEMPLATE--
+{{ foo.foo }}
+{{ foo.bar }}
+--DATA--
+class TestClassForMagicCallAttributes
+{
+ public function getBar()
+ {
+ return 'bar_from_getbar';
+ }
+
+ public function __call($method, $arguments)
+ {
+ if ('foo' === $method)
+ {
+ return 'foo_from_call';
+ }
+
+ return false;
+ }
+}
+return array('foo' => new TestClassForMagicCallAttributes())
+--EXPECT--
+foo_from_call
+bar_from_getbar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/method_call.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/method_call.test
new file mode 100755
index 0000000..9d84a4c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/method_call.test
@@ -0,0 +1,28 @@
+--TEST--
+Twig supports method calls
+--TEMPLATE--
+{{ items.foo.foo }}
+{{ items.foo.getFoo() }}
+{{ items.foo.bar }}
+{{ items.foo['bar'] }}
+{{ items.foo.bar('a', 43) }}
+{{ items.foo.bar(foo) }}
+{{ items.foo.self.foo() }}
+{{ items.foo.is }}
+{{ items.foo.in }}
+{{ items.foo.not }}
+--DATA--
+return array('foo' => 'bar', 'items' => array('foo' => new Foo(), 'bar' => 'foo'))
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+foo
+foo
+bar
+
+bar_a-43
+bar_bar
+foo
+is
+in
+not
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/postfix.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/postfix.test
new file mode 100755
index 0000000..db047c0
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/postfix.test
@@ -0,0 +1,21 @@
+--TEST--
+Twig parses postfix expressions
+--TEMPLATE--
+
+{% macro foo() %}foo{% endmacro %}
+
+{{ 'a' }}
+{{ 'a'|upper }}
+{{ ('a')|upper }}
+{{ -1|upper }}
+{{ _self.foo() }}
+{{ (_self).foo() }}
+--DATA--
+return array();
+--EXPECT--
+a
+A
+A
+-1
+foo
+foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/strings.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/strings.test
new file mode 100755
index 0000000..a911661
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/strings.test
@@ -0,0 +1,10 @@
+--TEST--
+Twig supports string interpolation
+--TEMPLATE--
+{{ "foo #{"foo #{bar} baz"} baz" }}
+{{ "foo #{bar}#{bar} baz" }}
+--DATA--
+return array('bar' => 'BAR');
+--EXPECT--
+foo foo BAR baz baz
+foo BARBAR baz
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator.test
new file mode 100755
index 0000000..0e6fa96
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/ternary_operator.test
@@ -0,0 +1,18 @@
+--TEST--
+Twig supports the ternary operator
+--TEMPLATE--
+{{ 1 ? 'YES' : 'NO' }}
+{{ 0 ? 'YES' : 'NO' }}
+{{ 0 ? 'YES' : (1 ? 'YES1' : 'NO1') }}
+{{ 0 ? 'YES' : (0 ? 'YES1' : 'NO1') }}
+{{ 1 == 1 ? 'foo ':'' }}
+{{ foo ~ (bar ? ('-' ~ bar) : '') }}
+--DATA--
+return array('foo' => 'foo', 'bar' => 'bar')
+--EXPECT--
+YES
+NO
+YES1
+NO1
+foo
+foo-bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/unary.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/unary.test
new file mode 100755
index 0000000..b79219a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/unary.test
@@ -0,0 +1,12 @@
+--TEST--
+Twig supports unary operators (not, -, +)
+--TEMPLATE--
+{{ not 1 }}/{{ not 0 }}
+{{ +1 + 1 }}/{{ -1 - 1 }}
+{{ not (false or true) }}
+--DATA--
+return array()
+--EXPECT--
+/1
+2/-2
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/expressions/unary_precedence.test b/lib/twig/test/Twig/Tests/Fixtures/expressions/unary_precedence.test
new file mode 100755
index 0000000..cc6eef8
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/expressions/unary_precedence.test
@@ -0,0 +1,14 @@
+--TEST--
+Twig unary operators precedence
+--TEMPLATE--
+{{ -1 - 1 }}
+{{ -1 - -1 }}
+{{ -1 * -1 }}
+{{ 4 / -1 * 5 }}
+--DATA--
+return array()
+--EXPECT--
+-2
+0
+1
+-20
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/convert_encoding.test b/lib/twig/test/Twig/Tests/Fixtures/filters/convert_encoding.test
new file mode 100755
index 0000000..380b04b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/convert_encoding.test
@@ -0,0 +1,10 @@
+--TEST--
+"convert_encoding" filter
+--CONDITION--
+function_exists('iconv') || function_exists('mb_convert_encoding')
+--TEMPLATE--
+{{ "愛していますか?"|convert_encoding('ISO-2022-JP', 'UTF-8')|convert_encoding('UTF-8', 'ISO-2022-JP') }}
+--DATA--
+return array()
+--EXPECT--
+愛していますか?
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/date.test b/lib/twig/test/Twig/Tests/Fixtures/filters/date.test
new file mode 100755
index 0000000..edfe596
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/date.test
@@ -0,0 +1,37 @@
+--TEST--
+"date" filter
+--TEMPLATE--
+{{ date1|date }}
+{{ date1|date('d/m/Y') }}
+{{ date1|date('d/m/Y H:i:s', 'Europe/Paris') }}
+{{ date2|date }}
+{{ date2|date('d/m/Y') }}
+{{ date2|date('d/m/Y H:i:s', 'Europe/Paris') }}
+{{ date3|date }}
+{{ date3|date('d/m/Y') }}
+{{ date4|date }}
+{{ date4|date('d/m/Y') }}
+{{ date5|date }}
+{{ date5|date('d/m/Y') }}
+--DATA--
+date_default_timezone_set('UTC');
+return array(
+ 'date1' => mktime(13, 45, 0, 10, 4, 2010),
+ 'date2' => new DateTime('2010-10-04 13:45'),
+ 'date3' => '2010-10-04 13:45',
+ 'date4' => 1286199900,
+ 'date5' => -86410,
+)
+--EXPECT--
+October 4, 2010 13:45
+04/10/2010
+04/10/2010 15:45:00
+October 4, 2010 13:45
+04/10/2010
+04/10/2010 15:45:00
+October 4, 2010 13:45
+04/10/2010
+October 4, 2010 13:45
+04/10/2010
+December 30, 1969 23:59
+30/12/1969
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/date_default_format.test b/lib/twig/test/Twig/Tests/Fixtures/filters/date_default_format.test
new file mode 100755
index 0000000..11a1ef4
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/date_default_format.test
@@ -0,0 +1,14 @@
+--TEST--
+"date" filter
+--TEMPLATE--
+{{ date1|date }}
+{{ date1|date('d/m/Y') }}
+--DATA--
+date_default_timezone_set('UTC');
+$twig->getExtension('core')->setDateFormat('Y-m-d', '%d days %h hours');
+return array(
+ 'date1' => mktime(13, 45, 0, 10, 4, 2010),
+)
+--EXPECT--
+2010-10-04
+04/10/2010
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/date_default_format_interval.test b/lib/twig/test/Twig/Tests/Fixtures/filters/date_default_format_interval.test
new file mode 100755
index 0000000..e6d3707
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/date_default_format_interval.test
@@ -0,0 +1,16 @@
+--TEST--
+"date" filter (interval support as of PHP 5.3)
+--CONDITION--
+version_compare(phpversion(), '5.3.0', '>=')
+--TEMPLATE--
+{{ date2|date }}
+{{ date2|date('%d days') }}
+--DATA--
+date_default_timezone_set('UTC');
+$twig->getExtension('core')->setDateFormat('Y-m-d', '%d days %h hours');
+return array(
+ 'date2' => new DateInterval('P2D'),
+)
+--EXPECT--
+2 days 0 hours
+2 days
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/date_interval.test b/lib/twig/test/Twig/Tests/Fixtures/filters/date_interval.test
new file mode 100755
index 0000000..2d5adc1
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/date_interval.test
@@ -0,0 +1,16 @@
+--TEST--
+"date" filter (interval support as of PHP 5.3)
+--CONDITION--
+version_compare(phpversion(), '5.3.0', '>=')
+--TEMPLATE--
+{{ date6|date }}
+{{ date6|date('%d days %h hours') }}
+--DATA--
+date_default_timezone_set('UTC');
+return array(
+ 'date5' => -86410,
+ 'date6' => new DateInterval('P2D'),
+)
+--EXPECT--
+2 days
+2 days 0 hours
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/default.test b/lib/twig/test/Twig/Tests/Fixtures/filters/default.test
new file mode 100755
index 0000000..22e86e4
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/default.test
@@ -0,0 +1,150 @@
+--TEST--
+"default" filter
+--TEMPLATE--
+Variable:
+{{ definedVar |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ zeroVar |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ emptyVar |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ nullVar |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ undefinedVar |default('default') is sameas('default') ? 'ok' : 'ko' }}
+Array access:
+{{ nested.definedVar |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ nested['definedVar'] |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ nested.zeroVar |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ nested.emptyVar |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ nested.nullVar |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ nested.undefinedVar |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ nested['undefinedVar'] |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ undefinedVar.foo |default('default') is sameas('default') ? 'ok' : 'ko' }}
+Plain values:
+{{ 'defined' |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ 0 |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ '' |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ null |default('default') is sameas('default') ? 'ok' : 'ko' }}
+Precedence:
+{{ 'o' ~ nullVar |default('k') }}
+{{ 'o' ~ nested.nullVar |default('k') }}
+Object methods:
+{{ object.foo |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ object.undefinedMethod |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ object.getFoo() |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ object.getFoo('a') |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ object.undefinedMethod() |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ object.undefinedMethod('a') |default('default') is sameas('default') ? 'ok' : 'ko' }}
+Deep nested:
+{{ nested.undefinedVar.foo.bar |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ nested.definedArray.0 |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ nested['definedArray'][0] |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ object.self.foo |default('default') is sameas('default') ? 'ko' : 'ok' }}
+{{ object.self.undefinedMethod |default('default') is sameas('default') ? 'ok' : 'ko' }}
+{{ object.undefinedMethod.self |default('default') is sameas('default') ? 'ok' : 'ko' }}
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new Foo(),
+)
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+Variable:
+ok
+ok
+ok
+ok
+ok
+Array access:
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+Plain values:
+ok
+ok
+ok
+ok
+Precedence:
+ok
+ok
+Object methods:
+ok
+ok
+ok
+ok
+ok
+ok
+Deep nested:
+ok
+ok
+ok
+ok
+ok
+ok
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'emptyVar' => '',
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new Foo(),
+)
+--CONFIG--
+return array('strict_variables' => true)
+--EXPECT--
+Variable:
+ok
+ok
+ok
+ok
+ok
+Array access:
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+Plain values:
+ok
+ok
+ok
+ok
+Precedence:
+ok
+ok
+Object methods:
+ok
+ok
+ok
+ok
+ok
+ok
+Deep nested:
+ok
+ok
+ok
+ok
+ok
+ok
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/dynamic_filter.test b/lib/twig/test/Twig/Tests/Fixtures/filters/dynamic_filter.test
new file mode 100755
index 0000000..93c5913
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/dynamic_filter.test
@@ -0,0 +1,10 @@
+--TEST--
+dynamic filter
+--TEMPLATE--
+{{ 'bar'|foo_path }}
+{{ 'bar'|a_foo_b_bar }}
+--DATA--
+return array()
+--EXPECT--
+foo/bar
+a/b/bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/escape.test b/lib/twig/test/Twig/Tests/Fixtures/filters/escape.test
new file mode 100755
index 0000000..a606c10
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/escape.test
@@ -0,0 +1,8 @@
+--TEST--
+"escape" filter
+--TEMPLATE--
+{{ "foo "|e }}
+--DATA--
+return array()
+--EXPECT--
+foo <br />
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/escape_non_supported_charset.test b/lib/twig/test/Twig/Tests/Fixtures/filters/escape_non_supported_charset.test
new file mode 100755
index 0000000..bba26a0
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/escape_non_supported_charset.test
@@ -0,0 +1,8 @@
+--TEST--
+"escape" filter
+--TEMPLATE--
+{{ "愛していますか? "|e }}
+--DATA--
+return array()
+--EXPECT--
+愛していますか? <br />
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/force_escape.test b/lib/twig/test/Twig/Tests/Fixtures/filters/force_escape.test
new file mode 100755
index 0000000..3690e71
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/force_escape.test
@@ -0,0 +1,18 @@
+--TEST--
+"escape" filter
+--TEMPLATE--
+{% set foo %}
+ foo
+{% endset %}
+
+{{ foo|e('html') -}}
+{{ foo|e('js') }}
+{% autoescape true %}
+ {{ foo }}
+{% endautoescape %}
+--DATA--
+return array()
+--EXPECT--
+ foo<br />
+ foo\x3cbr \x2f\x3e\x0a
+ foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/format.test b/lib/twig/test/Twig/Tests/Fixtures/filters/format.test
new file mode 100755
index 0000000..97221ff
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/format.test
@@ -0,0 +1,8 @@
+--TEST--
+"format" filter
+--TEMPLATE--
+{{ string|format(foo, 3) }}
+--DATA--
+return array('string' => '%s/%d', 'foo' => 'bar')
+--EXPECT--
+bar/3
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/join.test b/lib/twig/test/Twig/Tests/Fixtures/filters/join.test
new file mode 100755
index 0000000..8feef63
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/join.test
@@ -0,0 +1,12 @@
+--TEST--
+"join" filter
+--TEMPLATE--
+{{ ["foo", "bar"]|join(', ') }}
+{{ foo|join(', ') }}
+{{ bar|join(', ') }}
+--DATA--
+return array('foo' => new Foo(), 'bar' => new ArrayObject(array(3, 4)))
+--EXPECT--
+foo, bar
+1, 2
+3, 4
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/json_encode.test b/lib/twig/test/Twig/Tests/Fixtures/filters/json_encode.test
new file mode 100755
index 0000000..1738d40
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/json_encode.test
@@ -0,0 +1,12 @@
+--TEST--
+"json_encode" filter
+--TEMPLATE--
+{{ "foo"|json_encode|raw }}
+{{ foo|json_encode|raw }}
+{{ [foo, "foo"]|json_encode|raw }}
+--DATA--
+return array('foo' => new Twig_Markup('foo', 'UTF-8'))
+--EXPECT--
+"foo"
+"foo"
+["foo","foo"]
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/length.test b/lib/twig/test/Twig/Tests/Fixtures/filters/length.test
new file mode 100755
index 0000000..3347474
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/length.test
@@ -0,0 +1,14 @@
+--TEST--
+"length" filter
+--TEMPLATE--
+{{ array|length }}
+{{ string|length }}
+{{ number|length }}
+{{ markup|length }}
+--DATA--
+return array('array' => array(1, 4), 'string' => 'foo', 'number' => 1000, 'markup' => new Twig_Markup('foo', 'UTF-8'))
+--EXPECT--
+2
+3
+4
+3
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/length_utf8.test b/lib/twig/test/Twig/Tests/Fixtures/filters/length_utf8.test
new file mode 100755
index 0000000..5d5e243
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/length_utf8.test
@@ -0,0 +1,12 @@
+--TEST--
+"length" filter
+--CONDITION--
+function_exists('mb_get_info')
+--TEMPLATE--
+{{ string|length }}
+{{ markup|length }}
+--DATA--
+return array('string' => 'été', 'markup' => new Twig_Markup('foo', 'UTF-8'))
+--EXPECT--
+3
+3
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/merge.test b/lib/twig/test/Twig/Tests/Fixtures/filters/merge.test
new file mode 100755
index 0000000..357b352
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/merge.test
@@ -0,0 +1,14 @@
+--TEST--
+"merge" filter
+--TEMPLATE--
+{{ items|merge({'bar': 'foo'})|join }}
+{{ items|merge({'bar': 'foo'})|keys|join }}
+{{ {'bar': 'foo'}|merge(items)|join }}
+{{ {'bar': 'foo'}|merge(items)|keys|join }}
+--DATA--
+return array('items' => array('foo' => 'bar'))
+--EXPECT--
+barfoo
+foobar
+foobar
+barfoo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/nl2br.test b/lib/twig/test/Twig/Tests/Fixtures/filters/nl2br.test
new file mode 100755
index 0000000..6545a9b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/nl2br.test
@@ -0,0 +1,14 @@
+--TEST--
+"nl2br" filter
+--TEMPLATE--
+{{ "I like Twig.\nYou will like it too.\n\nEverybody like it!"|nl2br }}
+{{ text|nl2br }}
+--DATA--
+return array('text' => "If you have some HTML \nit will be escaped.")
+--EXPECT--
+I like Twig.
+You will like it too.
+
+Everybody like it!
+If you have some <strong>HTML</strong>
+it will be escaped.
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/number_format.test b/lib/twig/test/Twig/Tests/Fixtures/filters/number_format.test
new file mode 100755
index 0000000..639a865
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/number_format.test
@@ -0,0 +1,18 @@
+--TEST--
+"number_format" filter
+--TEMPLATE--
+{{ 20|number_format }}
+{{ 20.25|number_format }}
+{{ 20.25|number_format(2) }}
+{{ 20.25|number_format(2, ',') }}
+{{ 1020.25|number_format(2, ',') }}
+{{ 1020.25|number_format(2, ',', '.') }}
+--DATA--
+return array();
+--EXPECT--
+20
+20
+20.25
+20,25
+1,020,25
+1.020,25
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/number_format_default.test b/lib/twig/test/Twig/Tests/Fixtures/filters/number_format_default.test
new file mode 100755
index 0000000..c6903cc
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/number_format_default.test
@@ -0,0 +1,21 @@
+--TEST--
+"number_format" filter with defaults.
+--TEMPLATE--
+{{ 20|number_format }}
+{{ 20.25|number_format }}
+{{ 20.25|number_format(1) }}
+{{ 20.25|number_format(2, ',') }}
+{{ 1020.25|number_format }}
+{{ 1020.25|number_format(2, ',') }}
+{{ 1020.25|number_format(2, ',', '.') }}
+--DATA--
+$twig->getExtension('core')->setNumberFormat(2, '!', '=');
+return array();
+--EXPECT--
+20!00
+20!25
+20!3
+20,25
+1=020!25
+1=020,25
+1.020,25
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/replace.test b/lib/twig/test/Twig/Tests/Fixtures/filters/replace.test
new file mode 100755
index 0000000..4021660
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/replace.test
@@ -0,0 +1,8 @@
+--TEST--
+"replace" filter
+--TEMPLATE--
+{{ "I like %this% and %that%."|replace({'%this%': "foo", '%that%': "bar"}) }}
+--DATA--
+return array()
+--EXPECT--
+I like foo and bar.
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/reverse.test b/lib/twig/test/Twig/Tests/Fixtures/filters/reverse.test
new file mode 100755
index 0000000..3c5f410
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/reverse.test
@@ -0,0 +1,12 @@
+--TEST--
+"reverse" filter
+--TEMPLATE--
+{{ [1, 2, 3, 4]|reverse|join('') }}
+{{ '1234évènement'|reverse }}
+{{ arr|reverse|join('') }}
+--DATA--
+return array('arr' => new ArrayObject(array(1, 2, 3, 4)))
+--EXPECT--
+4321
+tnemenèvé4321
+4321
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/slice.test b/lib/twig/test/Twig/Tests/Fixtures/filters/slice.test
new file mode 100755
index 0000000..bb32dfb
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/slice.test
@@ -0,0 +1,40 @@
+--TEST--
+"slice" filter
+--TEMPLATE--
+{{ [1, 2, 3, 4][1:2]|join('') }}
+{{ {a: 1, b: 2, c: 3, d: 4}[1:2]|join('') }}
+{{ [1, 2, 3, 4][start:length]|join('') }}
+{{ [1, 2, 3, 4]|slice(1, 2)|join('') }}
+{{ [1, 2, 3, 4]|slice(1, 2)|keys|join('') }}
+{{ [1, 2, 3, 4]|slice(1, 2, true)|keys|join('') }}
+{{ {a: 1, b: 2, c: 3, d: 4}|slice(1, 2)|join('') }}
+{{ {a: 1, b: 2, c: 3, d: 4}|slice(1, 2)|keys|join('') }}
+{{ '1234'|slice(1, 2) }}
+{{ '1234'[1:2] }}
+{{ arr|slice(1, 2)|join('') }}
+{{ arr[1:2]|join('') }}
+
+{{ [1, 2, 3, 4]|slice(1)|join('') }}
+{{ [1, 2, 3, 4][1:]|join('') }}
+{{ '1234'|slice(1) }}
+{{ '1234'[1:] }}
+--DATA--
+return array('start' => 1, 'length' => 2, 'arr' => new ArrayObject(array(1, 2, 3, 4)))
+--EXPECT--
+23
+23
+23
+23
+01
+12
+23
+bc
+23
+23
+23
+23
+
+234
+234
+234
+234
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/sort.test b/lib/twig/test/Twig/Tests/Fixtures/filters/sort.test
new file mode 100755
index 0000000..21d575f
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/sort.test
@@ -0,0 +1,10 @@
+--TEST--
+"sort" filter
+--TEMPLATE--
+{{ array1|sort|join }}
+{{ array2|sort|join }}
+--DATA--
+return array('array1' => array(4, 1), 'array2' => array('foo', 'bar'))
+--EXPECT--
+14
+barfoo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/special_chars.test b/lib/twig/test/Twig/Tests/Fixtures/filters/special_chars.test
new file mode 100755
index 0000000..cc91900
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/special_chars.test
@@ -0,0 +1,8 @@
+--TEST--
+"☃" custom filter
+--TEMPLATE--
+{{ 'foo'|☃ }}
+--DATA--
+return array()
+--EXPECT--
+☃foo☃
diff --git a/lib/twig/test/Twig/Tests/Fixtures/filters/trim.test b/lib/twig/test/Twig/Tests/Fixtures/filters/trim.test
new file mode 100755
index 0000000..3192062
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/filters/trim.test
@@ -0,0 +1,12 @@
+--TEST--
+"trim" filter
+--TEMPLATE--
+{{ " I like Twig. "|trim }}
+{{ text|trim }}
+{{ " foo/"|trim("/") }}
+--DATA--
+return array('text' => " If you have some HTML it will be escaped. ")
+--EXPECT--
+I like Twig.
+If you have some <strong>HTML</strong> it will be escaped.
+ foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/functions/attribute.test b/lib/twig/test/Twig/Tests/Fixtures/functions/attribute.test
new file mode 100755
index 0000000..ba7d5e8
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/functions/attribute.test
@@ -0,0 +1,12 @@
+--TEST--
+"attribute" function
+--TEMPLATE--
+{{ attribute(obj, method) }}
+{{ attribute(array, item) }}
+{{ attribute(obj, "bar", ["a", "b"]) }}
+--DATA--
+return array('obj' => new Foo(), 'method' => 'foo', 'array' => array('foo' => 'bar'), 'item' => 'foo')
+--EXPECT--
+foo
+bar
+bar_a-b
diff --git a/lib/twig/test/Twig/Tests/Fixtures/functions/constant.test b/lib/twig/test/Twig/Tests/Fixtures/functions/constant.test
new file mode 100755
index 0000000..6d4b374
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/functions/constant.test
@@ -0,0 +1,12 @@
+--TEST--
+"constant" function
+--TEMPLATE--
+{% if constant('DATE_W3C') == expect %}
+true
+{% else %}
+false
+{% endif %}
+--DATA--
+return array('expect' => DATE_W3C);
+--EXPECT--
+true
diff --git a/lib/twig/test/Twig/Tests/Fixtures/functions/cycle.test b/lib/twig/test/Twig/Tests/Fixtures/functions/cycle.test
new file mode 100755
index 0000000..522a63b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/functions/cycle.test
@@ -0,0 +1,16 @@
+--TEST--
+"cycle" function
+--TEMPLATE--
+{% for i in 0..6 %}
+{{ cycle(array1, i) }}-{{ cycle(array2, i) }}
+{% endfor %}
+--DATA--
+return array('array1' => array('odd', 'even'), 'array2' => array('apple', 'orange', 'citrus'))
+--EXPECT--
+odd-apple
+even-orange
+odd-citrus
+even-apple
+odd-orange
+even-citrus
+odd-apple
diff --git a/lib/twig/test/Twig/Tests/Fixtures/functions/date.test b/lib/twig/test/Twig/Tests/Fixtures/functions/date.test
new file mode 100755
index 0000000..caeee7a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/functions/date.test
@@ -0,0 +1,25 @@
+--TEST--
+"date" function
+--TEMPLATE--
+{{ date() == date('now') ? 'OK' : 'KO' }}
+{{ date() > date('-1day') ? 'OK' : 'KO' }}
+{{ date(date1) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+{{ date(date2) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+{{ date(date3) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+{{ date(date4) == date('2010-10-04 13:45') ? 'OK' : 'KO' }}
+--DATA--
+date_default_timezone_set('UTC');
+return array(
+ 'date1' => mktime(13, 45, 0, 10, 4, 2010),
+ 'date2' => new DateTime('2010-10-04 13:45'),
+ 'date3' => '2010-10-04 13:45',
+ 'date4' => 1286199900,
+ 'date5' => -86410,
+)
+--EXPECT--
+OK
+OK
+OK
+OK
+OK
+OK
diff --git a/lib/twig/test/Twig/Tests/Fixtures/functions/dump.test b/lib/twig/test/Twig/Tests/Fixtures/functions/dump.test
new file mode 100755
index 0000000..1b3c453
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/functions/dump.test
@@ -0,0 +1,22 @@
+--TEST--
+"dump" function
+--TEMPLATE--
+{{ dump() }}
+{{ dump('foo') }}
+{{ dump('foo', 'bar') }}
+--DATA--
+return array('foo' => 'foo', 'bar' => 'bar')
+--CONFIG--
+return array('debug' => true, 'autoescape' => false);
+--EXPECT--
+array(2) {
+ ["foo"]=>
+ string(3) "foo"
+ ["bar"]=>
+ string(3) "bar"
+}
+
+string(3) "foo"
+
+string(3) "foo"
+string(3) "bar"
diff --git a/lib/twig/test/Twig/Tests/Fixtures/functions/dynamic_function.test b/lib/twig/test/Twig/Tests/Fixtures/functions/dynamic_function.test
new file mode 100755
index 0000000..913fbc9
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/functions/dynamic_function.test
@@ -0,0 +1,10 @@
+--TEST--
+dynamic function
+--TEMPLATE--
+{{ foo_path('bar') }}
+{{ a_foo_b_bar('bar') }}
+--DATA--
+return array()
+--EXPECT--
+foo/bar
+a/b/bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/functions/special_chars.test b/lib/twig/test/Twig/Tests/Fixtures/functions/special_chars.test
new file mode 100755
index 0000000..f602b0d
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/functions/special_chars.test
@@ -0,0 +1,8 @@
+--TEST--
+"☃" custom function
+--TEMPLATE--
+{{ ☃('foo') }}
+--DATA--
+return array()
+--EXPECT--
+☃foo☃
diff --git a/lib/twig/test/Twig/Tests/Fixtures/macros/simple.test b/lib/twig/test/Twig/Tests/Fixtures/macros/simple.test
new file mode 100755
index 0000000..6a366cd
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/macros/simple.test
@@ -0,0 +1,22 @@
+--TEST--
+macro
+--TEMPLATE--
+{% import _self as test %}
+{% from _self import test %}
+
+{% macro test(a, b) -%}
+ {{ a|default('a') }}
+ {{- b|default('b') }}
+{%- endmacro %}
+
+{{ test.test() }}
+{{ test() }}
+{{ test.test(1, "c") }}
+{{ test(1, "c") }}
+--DATA--
+return array();
+--EXPECT--
+a b
+a b
+1 c
+1 c
diff --git a/lib/twig/test/Twig/Tests/Fixtures/macros/with_filters.test b/lib/twig/test/Twig/Tests/Fixtures/macros/with_filters.test
new file mode 100755
index 0000000..685626f
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/macros/with_filters.test
@@ -0,0 +1,14 @@
+--TEST--
+macro with a filter
+--TEMPLATE--
+{% import _self as test %}
+
+{% macro test() %}
+ {% filter escape %}foo {% endfilter %}
+{% endmacro %}
+
+{{ test.test() }}
+--DATA--
+return array();
+--EXPECT--
+foo<br />
diff --git a/lib/twig/test/Twig/Tests/Fixtures/regression/empty_token.test b/lib/twig/test/Twig/Tests/Fixtures/regression/empty_token.test
new file mode 100755
index 0000000..65f6cd2
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/regression/empty_token.test
@@ -0,0 +1,8 @@
+--TEST--
+Twig outputs 0 nodes correctly
+--TEMPLATE--
+{{ foo }}0{{ foo }}
+--DATA--
+return array('foo' => 'foo')
+--EXPECT--
+foo0foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/basic.test
new file mode 100755
index 0000000..62d8c3c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/basic.test
@@ -0,0 +1,22 @@
+--TEST--
+"autoescape" tag applies escaping on its children
+--TEMPLATE--
+{% autoescape true %}
+{{ var }}
+{% endautoescape %}
+{% autoescape false %}
+{{ var }}
+{% endautoescape %}
+{% autoescape true %}
+{{ var }}
+{% endautoescape %}
+{% autoescape false %}
+{{ var }}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
+
+<br />
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/blocks.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/blocks.test
new file mode 100755
index 0000000..b48f73e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/blocks.test
@@ -0,0 +1,12 @@
+--TEST--
+"autoescape" tag applies escaping on embedded blocks
+--TEMPLATE--
+{% autoescape true %}
+ {% block foo %}
+ {{ var }}
+ {% endblock %}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/double_escaping.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/double_escaping.test
new file mode 100755
index 0000000..fd62a84
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/double_escaping.test
@@ -0,0 +1,10 @@
+--TEST--
+"autoescape" tag does not double-escape
+--TEMPLATE--
+{% autoescape true %}
+{{ var|escape }}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/functions.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/functions.test
new file mode 100755
index 0000000..9a229d0
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/functions.test
@@ -0,0 +1,83 @@
+--TEST--
+"autoescape" tag applies escaping after calling functions
+--TEMPLATE--
+
+autoescape false
+{% autoescape false %}
+
+safe_br
+{{ safe_br() }}
+
+unsafe_br
+{{ unsafe_br() }}
+
+{% endautoescape %}
+
+autoescape true
+{% autoescape true %}
+
+safe_br
+{{ safe_br() }}
+
+unsafe_br
+{{ unsafe_br() }}
+
+unsafe_br()|raw
+{{ (unsafe_br())|raw }}
+
+safe_br()|escape
+{{ (safe_br())|escape }}
+
+safe_br()|raw
+{{ (safe_br())|raw }}
+
+unsafe_br()|escape
+{{ (unsafe_br())|escape }}
+
+{% endautoescape %}
+
+autoescape true js
+{% autoescape true js %}
+
+safe_br
+{{ safe_br() }}
+
+{% endautoescape %}
+--DATA--
+return array()
+--EXPECT--
+
+autoescape false
+
+safe_br
+
+
+unsafe_br
+
+
+
+autoescape true
+
+safe_br
+
+
+unsafe_br
+<br />
+
+unsafe_br()|raw
+
+
+safe_br()|escape
+<br />
+
+safe_br()|raw
+
+
+unsafe_br()|escape
+<br />
+
+
+autoescape true js
+
+safe_br
+\x3cbr \x2f\x3e
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/literal.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/literal.test
new file mode 100755
index 0000000..4c92d08
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/literal.test
@@ -0,0 +1,45 @@
+--TEST--
+"autoescape" tag does not apply escaping on literals
+--TEMPLATE--
+{% autoescape true %}
+
+1. Simple literal
+{{ " " }}
+
+2. Conditional expression with only literals
+{{ true ? " " : " " }}
+
+3. Conditonal expression with a variable
+{{ true ? " " : someVar }}
+
+4. Nested conditionals with only literals
+{{ true ? (true ? " " : " ") : "\n" }}
+
+5. Nested conditionals with a variable
+{{ true ? (true ? " " : someVar) : "\n" }}
+
+6. Nested conditionals with a variable marked safe
+{{ true ? (true ? " " : someVar|raw) : "\n" }}
+
+{% endautoescape %}
+--DATA--
+return array()
+--EXPECT--
+
+1. Simple literal
+
+
+2. Conditional expression with only literals
+
+
+3. Conditonal expression with a variable
+<br />
+
+4. Nested conditionals with only literals
+
+
+5. Nested conditionals with a variable
+<br />
+
+6. Nested conditionals with a variable marked safe
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/nested.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/nested.test
new file mode 100755
index 0000000..c911211
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/nested.test
@@ -0,0 +1,26 @@
+--TEST--
+"autoescape" tags can be nested at will
+--TEMPLATE--
+{{ var }}
+{% autoescape true %}
+ {{ var }}
+ {% autoescape false %}
+ {{ var }}
+ {% autoescape true %}
+ {{ var }}
+ {% endautoescape %}
+ {{ var }}
+ {% endautoescape %}
+ {{ var }}
+{% endautoescape %}
+{{ var }}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+<br />
+ <br />
+
+ <br />
+
+ <br />
+<br />
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/objects.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/objects.test
new file mode 100755
index 0000000..f6c03ed
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/objects.test
@@ -0,0 +1,26 @@
+--TEST--
+"autoescape" tag applies escaping to object method calls
+--TEMPLATE--
+{% autoescape true %}
+{{ user.name }}
+{{ user.name|lower }}
+{{ user }}
+{% endautoescape %}
+--DATA--
+class UserForAutoEscapeTest
+{
+ public function getName()
+ {
+ return 'Fabien ';
+ }
+
+ public function __toString()
+ {
+ return 'Fabien ';
+ }
+}
+return array('user' => new UserForAutoEscapeTest())
+--EXPECT--
+Fabien<br />
+fabien<br />
+Fabien<br />
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/raw.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/raw.test
new file mode 100755
index 0000000..86e55fd
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/raw.test
@@ -0,0 +1,10 @@
+--TEST--
+"autoescape" tag does not escape when raw is used as a filter
+--TEMPLATE--
+{% autoescape true %}
+{{ var|raw }}
+{% endautoescape %}
+--DATA--
+return array('var' => ' ')
+--EXPECT--
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/strategy.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/strategy.test
new file mode 100755
index 0000000..9ea4fd4
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/strategy.test
@@ -0,0 +1,11 @@
+--TEST--
+"autoescape" tag accepts an escaping strategy
+--TEMPLATE--
+{% autoescape true js %}{{ var }}{% endautoescape %}
+
+{% autoescape true html %}{{ var }}{% endautoescape %}
+--DATA--
+return array('var' => ' "')
+--EXPECT--
+\x3cbr \x2f\x3e\x22
+<br />"
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/type.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/type.test
new file mode 100755
index 0000000..17cec13
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/type.test
@@ -0,0 +1,69 @@
+--TEST--
+escape types
+--TEMPLATE--
+
+1. autoescape true |escape('js')
+
+{% autoescape true %}
+
+{% endautoescape %}
+
+2. autoescape true html |escape('js')
+
+{% autoescape true html %}
+
+{% endautoescape %}
+
+3. autoescape true js |escape('js')
+
+{% autoescape true js %}
+
+{% endautoescape %}
+
+4. no escape
+
+{% autoescape false %}
+
+{% endautoescape %}
+
+5. |escape('js')|escape('html')
+
+{% autoescape false %}
+
+{% endautoescape %}
+
+6. autoescape true html |escape('js')|escape('html')
+
+{% autoescape true html %}
+
+{% endautoescape %}
+
+--DATA--
+return array('msg' => "<>\n'\"")
+--EXPECT--
+
+1. autoescape true |escape('js')
+
+
+
+2. autoescape true html |escape('js')
+
+
+
+3. autoescape true js |escape('js')
+
+
+
+4. no escape
+
+
+
+5. |escape('js')|escape('html')
+
+
+
+6. autoescape true html |escape('js')|escape('html')
+
+
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters.test
new file mode 100755
index 0000000..d795b82
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters.test
@@ -0,0 +1,131 @@
+--TEST--
+"autoescape" tag applies escaping after calling filters
+--TEMPLATE--
+{% autoescape true %}
+
+(escape_and_nl2br is an escaper filter)
+
+1. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped )
+{{ var|escape_and_nl2br }}
+
+2. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped, |raw is redundant )
+{{ var|escape_and_nl2br|raw }}
+
+3. Explicit escape
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is explicitly escaped by |escape )
+{{ var|escape_and_nl2br|escape }}
+
+4. Escape non-escaper filter output
+( var is upper-cased by |upper,
+ the output is auto-escaped )
+{{ var|upper }}
+
+5. Escape if last filter is not an escaper
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is upper-cased by |upper,
+ the output is auto-escaped as |upper is not an escaper )
+{{ var|escape_and_nl2br|upper }}
+
+6. Don't escape escaper filter output
+( var is upper cased by upper,
+ the output is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped as |escape_and_nl2br is an escaper )
+{{ var|upper|escape_and_nl2br }}
+
+7. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ the output is auto-escaped )
+{{ "%s "|format(var) }}
+
+8. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ |raw is redundant,
+ the output is auto-escaped )
+{{ "%s "|raw|format(var) }}
+
+9. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end )
+{{ "%s "|format(var)|raw }}
+
+10. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end,
+ the |raw filter on var is redundant )
+{{ "%s "|format(var|raw)|raw }}
+
+{% endautoescape %}
+--DATA--
+return array('var' => "\nTwig")
+--EXPECT--
+
+(escape_and_nl2br is an escaper filter)
+
+1. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped )
+<Fabien>
+Twig
+
+2. Don't escape escaper filter output
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped, |raw is redundant )
+<Fabien>
+Twig
+
+3. Explicit escape
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is explicitly escaped by |escape )
+<Fabien><br />
+Twig
+
+4. Escape non-escaper filter output
+( var is upper-cased by |upper,
+ the output is auto-escaped )
+<FABIEN>
+TWIG
+
+5. Escape if last filter is not an escaper
+( var is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is upper-cased by |upper,
+ the output is auto-escaped as |upper is not an escaper )
+<FABIEN><BR />
+TWIG
+
+6. Don't escape escaper filter output
+( var is upper cased by upper,
+ the output is escaped by |escape_and_nl2br, line-breaks are added,
+ the output is not escaped as |escape_and_nl2br is an escaper )
+<FABIEN>
+TWIG
+
+7. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ the output is auto-escaped )
+<b><Fabien>
+Twig</b>
+
+8. Escape if last filter is not an escaper
+( the output of |format is "" ~ var ~ " ",
+ |raw is redundant,
+ the output is auto-escaped )
+<b><Fabien>
+Twig</b>
+
+9. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end )
+
+Twig
+
+10. Don't escape escaper filter output
+( the output of |format is "" ~ var ~ " ",
+ the output is not escaped due to |raw filter at the end,
+ the |raw filter on var is redundant )
+
+Twig
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters_arguments.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters_arguments.test
new file mode 100755
index 0000000..0ff1ad3
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_filters_arguments.test
@@ -0,0 +1,23 @@
+--TEST--
+"autoescape" tag do not applies escaping on filter arguments
+--TEMPLATE--
+{% autoescape true %}
+{{ var|nl2br(" ") }}
+{{ var|nl2br(" "|escape) }}
+{{ var|nl2br(sep) }}
+{{ var|nl2br(sep|raw) }}
+{{ var|nl2br(sep|escape) }}
+{% endautoescape %}
+--DATA--
+return array('var' => "\nTwig", 'sep' => ' ')
+--EXPECT--
+<Fabien>
+Twig
+<Fabien><br />
+Twig
+<Fabien>
+Twig
+<Fabien>
+Twig
+<Fabien><br />
+Twig
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_pre_escape_filters.test b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_pre_escape_filters.test
new file mode 100755
index 0000000..44d42e7
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/autoescape/with_pre_escape_filters.test
@@ -0,0 +1,68 @@
+--TEST--
+"autoescape" tag applies escaping after calling filters, and before calling pre_escape filters
+--TEMPLATE--
+{% autoescape true %}
+
+(nl2br is pre_escaped for "html" and declared safe for "html")
+
+1. Pre-escape and don't post-escape
+( var|escape|nl2br )
+{{ var|nl2br }}
+
+2. Don't double-pre-escape
+( var|escape|nl2br )
+{{ var|escape|nl2br }}
+
+3. Don't escape safe values
+( var|raw|nl2br )
+{{ var|raw|nl2br }}
+
+4. Don't escape safe values
+( var|escape|nl2br|nl2br )
+{{ var|nl2br|nl2br }}
+
+5. Re-escape values that are escaped for an other contexts
+( var|escape_something|escape|nl2br )
+{{ var|escape_something|nl2br }}
+
+6. Still escape when using filters not declared safe
+( var|escape|nl2br|upper|escape )
+{{ var|nl2br|upper }}
+
+{% endautoescape %}
+--DATA--
+return array('var' => "\nTwig")
+--EXPECT--
+
+(nl2br is pre_escaped for "html" and declared safe for "html")
+
+1. Pre-escape and don't post-escape
+( var|escape|nl2br )
+<Fabien>
+Twig
+
+2. Don't double-pre-escape
+( var|escape|nl2br )
+<Fabien>
+Twig
+
+3. Don't escape safe values
+( var|raw|nl2br )
+
+Twig
+
+4. Don't escape safe values
+( var|escape|nl2br|nl2br )
+<Fabien>
+Twig
+
+5. Re-escape values that are escaped for an other contexts
+( var|escape_something|escape|nl2br )
+<FABIEN>
+TWIG
+
+6. Still escape when using filters not declared safe
+( var|escape|nl2br|upper|escape )
+<FABIEN><BR />
+TWIG
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/block/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/block/basic.test
new file mode 100755
index 0000000..360dcf0
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/block/basic.test
@@ -0,0 +1,11 @@
+--TEST--
+"block" tag
+--TEMPLATE--
+{% block title1 %}FOO{% endblock %}
+{% block title2 foo|lower %}
+--TEMPLATE(foo.twig)--
+{% block content %}{% endblock %}
+--DATA--
+return array('foo' => 'bar')
+--EXPECT--
+FOObar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/block/special_chars.test b/lib/twig/test/Twig/Tests/Fixtures/tags/block/special_chars.test
new file mode 100755
index 0000000..441570c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/block/special_chars.test
@@ -0,0 +1,10 @@
+--TEST--
+"☃" special chars in a block name
+--TEMPLATE--
+{% block ☃ %}
+☃
+{% endblock ☃ %}
+--DATA--
+return array()
+--EXPECT--
+☃
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/filter/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/basic.test
new file mode 100755
index 0000000..82094f2
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/basic.test
@@ -0,0 +1,10 @@
+--TEST--
+"filter" tag applies a filter on its children
+--TEMPLATE--
+{% filter upper %}
+Some text with a {{ var }}
+{% endfilter %}
+--DATA--
+return array('var' => 'var')
+--EXPECT--
+SOME TEXT WITH A VAR
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/filter/json_encode.test b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/json_encode.test
new file mode 100755
index 0000000..3e7148b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/json_encode.test
@@ -0,0 +1,8 @@
+--TEST--
+"filter" tag applies a filter on its children
+--TEMPLATE--
+{% filter json_encode|raw %}test{% endfilter %}
+--DATA--
+return array()
+--EXPECT--
+"test"
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/filter/multiple.test b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/multiple.test
new file mode 100755
index 0000000..75512ef
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/multiple.test
@@ -0,0 +1,10 @@
+--TEST--
+"filter" tags accept multiple chained filters
+--TEMPLATE--
+{% filter lower|title %}
+ {{ var }}
+{% endfilter %}
+--DATA--
+return array('var' => 'VAR')
+--EXPECT--
+ Var
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/filter/nested.test b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/nested.test
new file mode 100755
index 0000000..7e4e4eb
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/nested.test
@@ -0,0 +1,16 @@
+--TEST--
+"filter" tags can be nested at will
+--TEMPLATE--
+{% filter lower|title %}
+ {{ var }}
+ {% filter upper %}
+ {{ var }}
+ {% endfilter %}
+ {{ var }}
+{% endfilter %}
+--DATA--
+return array('var' => 'var')
+--EXPECT--
+ Var
+ Var
+ Var
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/filter/with_for_tag.test b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/with_for_tag.test
new file mode 100755
index 0000000..22745ea
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/with_for_tag.test
@@ -0,0 +1,13 @@
+--TEST--
+"filter" tag applies the filter on "for" tags
+--TEMPLATE--
+{% filter upper %}
+{% for item in items %}
+{{ item }}
+{% endfor %}
+{% endfilter %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+A
+B
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/filter/with_if_tag.test b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/with_if_tag.test
new file mode 100755
index 0000000..afd95b2
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/filter/with_if_tag.test
@@ -0,0 +1,29 @@
+--TEST--
+"filter" tag applies the filter on "if" tags
+--TEMPLATE--
+{% filter upper %}
+{% if items %}
+{{ items|join(', ') }}
+{% endif %}
+
+{% if items.3 is defined %}
+FOO
+{% else %}
+{{ items.1 }}
+{% endif %}
+
+{% if items.3 is defined %}
+FOO
+{% elseif items.1 %}
+{{ items.0 }}
+{% endif %}
+
+{% endfilter %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+A, B
+
+B
+
+A
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/condition.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/condition.test
new file mode 100755
index 0000000..9e4eb9b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/condition.test
@@ -0,0 +1,14 @@
+--TEST--
+"for" tag takes a condition
+--TEMPLATE--
+{% for i in 1..5 if i is odd -%}
+ {{ loop.index }}.{{ i }}
+{% endfor %}
+--DATA--
+return array()
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+1.1
+2.3
+3.5
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/context.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/context.test
new file mode 100755
index 0000000..ddc6930
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/context.test
@@ -0,0 +1,18 @@
+--TEST--
+"for" tag keeps the context safe
+--TEMPLATE--
+{% for item in items %}
+ {% for item in items %}
+ * {{ item }}
+ {% endfor %}
+ * {{ item }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * a
+ * b
+ * a
+ * a
+ * b
+ * b
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/else.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/else.test
new file mode 100755
index 0000000..20ccc88
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/else.test
@@ -0,0 +1,23 @@
+--TEST--
+"for" tag can use an "else" clause
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+{% else %}
+ no item
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * a
+ * b
+--DATA--
+return array('items' => array())
+--EXPECT--
+ no item
+--DATA--
+return array()
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+ no item
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/inner_variables.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/inner_variables.test
new file mode 100755
index 0000000..49fb9ca
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/inner_variables.test
@@ -0,0 +1,17 @@
+--TEST--
+"for" tag does not reset inner variables
+--TEMPLATE--
+{% for i in 1..2 %}
+ {% for j in 0..2 %}
+ {{k}}{% set k = k+1 %} {{ loop.parent.loop.index }}
+ {% endfor %}
+{% endfor %}
+--DATA--
+return array('k' => 0)
+--EXPECT--
+ 0 1
+ 1 1
+ 2 1
+ 3 2
+ 4 2
+ 5 2
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/keys.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/keys.test
new file mode 100755
index 0000000..4e22cb4
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/keys.test
@@ -0,0 +1,11 @@
+--TEST--
+"for" tag can iterate over keys
+--TEMPLATE--
+{% for key in items|keys %}
+ * {{ key }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * 0
+ * 1
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/keys_and_values.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/keys_and_values.test
new file mode 100755
index 0000000..4c21168
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/keys_and_values.test
@@ -0,0 +1,11 @@
+--TEST--
+"for" tag can iterate over keys and values
+--TEMPLATE--
+{% for key, item in items %}
+ * {{ key }}/{{ item }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * 0/a
+ * 1/b
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/loop_context.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/loop_context.test
new file mode 100755
index 0000000..93bc76a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/loop_context.test
@@ -0,0 +1,19 @@
+--TEST--
+"for" tag adds a loop variable to the context
+--TEMPLATE--
+{% for item in items %}
+ * {{ loop.index }}/{{ loop.index0 }}
+ * {{ loop.revindex }}/{{ loop.revindex0 }}
+ * {{ loop.first }}/{{ loop.last }}/{{ loop.length }}
+
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * 1/0
+ * 2/1
+ * 1//2
+
+ * 2/1
+ * 1/0
+ * /1/2
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/loop_context_local.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/loop_context_local.test
new file mode 100755
index 0000000..58af2c3
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/loop_context_local.test
@@ -0,0 +1,10 @@
+--TEST--
+"for" tag adds a loop variable to the context locally
+--TEMPLATE--
+{% for item in items %}
+{% endfor %}
+{% if loop is not defined %}WORKS{% endif %}
+--DATA--
+return array('items' => array())
+--EXPECT--
+WORKS
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/nested_else.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/nested_else.test
new file mode 100755
index 0000000..f8b9f6b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/nested_else.test
@@ -0,0 +1,17 @@
+--TEST--
+"for" tag can use an "else" clause
+--TEMPLATE--
+{% for item in items %}
+ {% for item in items1 %}
+ * {{ item }}
+ {% else %}
+ no {{ item }}
+ {% endfor %}
+{% else %}
+ no item1
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'), 'items1' => array())
+--EXPECT--
+no a
+ no b
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/objects.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/objects.test
new file mode 100755
index 0000000..5034437
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/objects.test
@@ -0,0 +1,43 @@
+--TEST--
+"for" tag iterates over iterable objects
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+ * {{ loop.index }}/{{ loop.index0 }}
+ * {{ loop.first }}
+
+{% endfor %}
+
+{% for key, value in items %}
+ * {{ key }}/{{ value }}
+{% endfor %}
+
+{% for key in items|keys %}
+ * {{ key }}
+{% endfor %}
+--DATA--
+class ItemsIterator implements Iterator
+{
+ protected $values = array('foo' => 'bar', 'bar' => 'foo');
+ public function current() { return current($this->values); }
+ public function key() { return key($this->values); }
+ public function next() { return next($this->values); }
+ public function rewind() { return reset($this->values); }
+ public function valid() { return false !== current($this->values); }
+}
+return array('items' => new ItemsIterator())
+--EXPECT--
+ * bar
+ * 1/0
+ * 1
+
+ * foo
+ * 2/1
+ *
+
+
+ * foo/bar
+ * bar/foo
+
+ * foo
+ * bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/objects_countable.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/objects_countable.test
new file mode 100755
index 0000000..4a1ff61
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/objects_countable.test
@@ -0,0 +1,47 @@
+--TEST--
+"for" tag iterates over iterable and countable objects
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+ * {{ loop.index }}/{{ loop.index0 }}
+ * {{ loop.revindex }}/{{ loop.revindex0 }}
+ * {{ loop.first }}/{{ loop.last }}/{{ loop.length }}
+
+{% endfor %}
+
+{% for key, value in items %}
+ * {{ key }}/{{ value }}
+{% endfor %}
+
+{% for key in items|keys %}
+ * {{ key }}
+{% endfor %}
+--DATA--
+class ItemsIteratorCountable implements Iterator, Countable
+{
+ protected $values = array('foo' => 'bar', 'bar' => 'foo');
+ public function current() { return current($this->values); }
+ public function key() { return key($this->values); }
+ public function next() { return next($this->values); }
+ public function rewind() { return reset($this->values); }
+ public function valid() { return false !== current($this->values); }
+ public function count() { return count($this->values); }
+}
+return array('items' => new ItemsIteratorCountable())
+--EXPECT--
+ * bar
+ * 1/0
+ * 2/1
+ * 1//2
+
+ * foo
+ * 2/1
+ * 1/0
+ * /1/2
+
+
+ * foo/bar
+ * bar/foo
+
+ * foo
+ * bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/recursive.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/recursive.test
new file mode 100755
index 0000000..17b2e22
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/recursive.test
@@ -0,0 +1,18 @@
+--TEST--
+"for" tags can be nested
+--TEMPLATE--
+{% for key, item in items %}
+* {{ key }} ({{ loop.length }}):
+{% for value in item %}
+ * {{ value }} ({{ loop.length }})
+{% endfor %}
+{% endfor %}
+--DATA--
+return array('items' => array('a' => array('a1', 'a2', 'a3'), 'b' => array('b1')))
+--EXPECT--
+* a (2):
+ * a1 (3)
+ * a2 (3)
+ * a3 (3)
+* b (2):
+ * b1 (1)
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/for/values.test b/lib/twig/test/Twig/Tests/Fixtures/tags/for/values.test
new file mode 100755
index 0000000..82f2ae8
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/for/values.test
@@ -0,0 +1,11 @@
+--TEST--
+"for" tag iterates over item values
+--TEMPLATE--
+{% for item in items %}
+ * {{ item }}
+{% endfor %}
+--DATA--
+return array('items' => array('a', 'b'))
+--EXPECT--
+ * a
+ * b
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/from.test b/lib/twig/test/Twig/Tests/Fixtures/tags/from.test
new file mode 100755
index 0000000..5f5da0e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/from.test
@@ -0,0 +1,14 @@
+--TEST--
+global variables
+--TEMPLATE--
+{% include "included.twig" %}
+{% from "included.twig" import foobar %}
+{{ foobar() }}
+--TEMPLATE(included.twig)--
+{% macro foobar() %}
+called foobar
+{% endmacro %}
+--DATA--
+return array();
+--EXPECT--
+called foobar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/if/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/if/basic.test
new file mode 100755
index 0000000..c1c3d27
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/if/basic.test
@@ -0,0 +1,22 @@
+--TEST--
+"if" creates a condition
+--TEMPLATE--
+{% if a is defined %}
+ {{ a }}
+{% elseif b is defined %}
+ {{ b }}
+{% else %}
+ NOTHING
+{% endif %}
+--DATA--
+return array('a' => 'a')
+--EXPECT--
+ a
+--DATA--
+return array('b' => 'b')
+--EXPECT--
+ b
+--DATA--
+return array()
+--EXPECT--
+ NOTHING
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/if/expression.test b/lib/twig/test/Twig/Tests/Fixtures/tags/if/expression.test
new file mode 100755
index 0000000..edfb73d
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/if/expression.test
@@ -0,0 +1,22 @@
+--TEST--
+"if" takes an expression as a test
+--TEMPLATE--
+{% if a < 2 %}
+ A1
+{% elseif a > 10 %}
+ A2
+{% else %}
+ A3
+{% endif %}
+--DATA--
+return array('a' => 1)
+--EXPECT--
+ A1
+--DATA--
+return array('a' => 12)
+--EXPECT--
+ A2
+--DATA--
+return array('a' => 7)
+--EXPECT--
+ A3
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/include/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/include/basic.test
new file mode 100755
index 0000000..8fe1a6c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/include/basic.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+FOO
+{% include "foo.twig" %}
+
+BAR
+--TEMPLATE(foo.twig)--
+FOOBAR
+--DATA--
+return array()
+--EXPECT--
+FOO
+
+FOOBAR
+BAR
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/include/expression.test b/lib/twig/test/Twig/Tests/Fixtures/tags/include/expression.test
new file mode 100755
index 0000000..eaeeb11
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/include/expression.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" tag allows expressions for the template to include
+--TEMPLATE--
+FOO
+{% include foo %}
+
+BAR
+--TEMPLATE(foo.twig)--
+FOOBAR
+--DATA--
+return array('foo' => 'foo.twig')
+--EXPECT--
+FOO
+
+FOOBAR
+BAR
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/include/ignore_missing.test b/lib/twig/test/Twig/Tests/Fixtures/tags/include/ignore_missing.test
new file mode 100755
index 0000000..24aed06
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/include/ignore_missing.test
@@ -0,0 +1,10 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+{% include ["foo.twig", "bar.twig"] ignore missing %}
+{% include "foo.twig" ignore missing %}
+{% include "foo.twig" ignore missing with {} %}
+{% include "foo.twig" ignore missing with {} only %}
+--DATA--
+return array()
+--EXPECT--
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/include/only.test b/lib/twig/test/Twig/Tests/Fixtures/tags/include/only.test
new file mode 100755
index 0000000..22e3d0f
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/include/only.test
@@ -0,0 +1,16 @@
+--TEST--
+"include" tag accept variables and only
+--TEMPLATE--
+{% include "foo.twig" %}
+{% include "foo.twig" only %}
+{% include "foo.twig" with {'foo1': 'bar'} %}
+{% include "foo.twig" with {'foo1': 'bar'} only %}
+--TEMPLATE(foo.twig)--
+{% for k, v in _context %}{{ k }},{% endfor %}
+--DATA--
+return array('foo' => 'bar')
+--EXPECT--
+foo,_parent,
+_parent,
+foo,foo1,_parent,
+foo1,_parent,
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/include/template_instance.test b/lib/twig/test/Twig/Tests/Fixtures/tags/include/template_instance.test
new file mode 100755
index 0000000..6ba064a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/include/template_instance.test
@@ -0,0 +1,10 @@
+--TEST--
+"include" tag accepts Twig_Template instance
+--TEMPLATE--
+{% include foo %} FOO
+--TEMPLATE(foo.twig)--
+BAR
+--DATA--
+return array('foo' => $twig->loadTemplate('foo.twig'))
+--EXPECT--
+BAR FOO
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/include/templates_as_array.test b/lib/twig/test/Twig/Tests/Fixtures/tags/include/templates_as_array.test
new file mode 100755
index 0000000..ab670ee
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/include/templates_as_array.test
@@ -0,0 +1,12 @@
+--TEST--
+"include" tag
+--TEMPLATE--
+{% include ["foo.twig", "bar.twig"] %}
+{% include ["bar.twig", "foo.twig"] %}
+--TEMPLATE(foo.twig)--
+foo
+--DATA--
+return array()
+--EXPECT--
+foo
+foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/include/with_variables.test b/lib/twig/test/Twig/Tests/Fixtures/tags/include/with_variables.test
new file mode 100755
index 0000000..41384ac
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/include/with_variables.test
@@ -0,0 +1,12 @@
+--TEST--
+"include" tag accept variables
+--TEMPLATE--
+{% include "foo.twig" with {'foo': 'bar'} %}
+{% include "foo.twig" with vars %}
+--TEMPLATE(foo.twig)--
+{{ foo }}
+--DATA--
+return array('vars' => array('foo' => 'bar'))
+--EXPECT--
+bar
+bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/basic.test
new file mode 100755
index 0000000..0778a4b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/basic.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+
+{% block content %}
+FOO
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+FOO
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/conditional.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/conditional.test
new file mode 100755
index 0000000..8576e77
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/conditional.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends standalone ? foo : 'bar.twig' %}
+
+{% block content %}{{ parent() }}FOO{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}FOO{% endblock %}
+--TEMPLATE(bar.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array('foo' => 'foo.twig', 'standalone' => true)
+--EXPECT--
+FOOFOO
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/dynamic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/dynamic.test
new file mode 100755
index 0000000..ee06ddc
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/dynamic.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends foo %}
+
+{% block content %}
+FOO
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}{% endblock %}
+--DATA--
+return array('foo' => 'foo.twig')
+--EXPECT--
+FOO
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array.test
new file mode 100755
index 0000000..a1cb1ce
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/extends_as_array.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends ["foo.twig", "bar.twig"] %}
+--TEMPLATE(bar.twig)--
+{% block content %}
+foo
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple.test
new file mode 100755
index 0000000..dfc2b6c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/multiple.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "layout.twig" %}{% block content %}{{ parent() }}index {% endblock %}
+--TEMPLATE(layout.twig)--
+{% extends "base.twig" %}{% block content %}{{ parent() }}layout {% endblock %}
+--TEMPLATE(base.twig)--
+{% block content %}base {% endblock %}
+--DATA--
+return array()
+--EXPECT--
+base layout index
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_inheritance.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_inheritance.test
new file mode 100755
index 0000000..71e3cdf
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/nested_inheritance.test
@@ -0,0 +1,16 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "layout.twig" %}
+{% block inside %}INSIDE{% endblock inside %}
+--TEMPLATE(layout.twig)--
+{% extends "base.twig" %}
+{% block body %}
+ {% block inside '' %}
+{% endblock body %}
+--TEMPLATE(base.twig)--
+{% block body '' %}
+--DATA--
+return array()
+--EXPECT--
+INSIDE
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent.test
new file mode 100755
index 0000000..4f975db
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent.test
@@ -0,0 +1,12 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+
+{% block content %}{{ parent() }}FOO{{ parent() }}{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+BARFOOBAR
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_change.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_change.test
new file mode 100755
index 0000000..a8bc90c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_change.test
@@ -0,0 +1,16 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends foo ? 'foo.twig' : 'bar.twig' %}
+--TEMPLATE(foo.twig)--
+FOO
+--TEMPLATE(bar.twig)--
+BAR
+--DATA--
+return array('foo' => true)
+--EXPECT--
+FOO
+--DATA--
+return array('foo' => false)
+--EXPECT--
+BAR
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_in_a_block.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_in_a_block.test
new file mode 100755
index 0000000..c9e86b1
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_in_a_block.test
@@ -0,0 +1,8 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% block content %}
+ {% extends "foo.twig" %}
+{% endblock %}
+--EXCEPTION--
+Twig_Error_Syntax: Cannot extend from a block in "index.twig" at line 3
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_isolation.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_isolation.test
new file mode 100755
index 0000000..6281671
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_isolation.test
@@ -0,0 +1,20 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "base.twig" %}
+{% block content %}{% include "included.twig" %}{% endblock %}
+
+{% block footer %}Footer{% endblock %}
+--TEMPLATE(included.twig)--
+{% extends "base.twig" %}
+{% block content %}Included Content{% endblock %}
+--TEMPLATE(base.twig)--
+{% block content %}Default Content{% endblock %}
+
+{% block footer %}Default Footer{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+Included Content
+Default Footer
+Footer
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_nested.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_nested.test
new file mode 100755
index 0000000..71e7c20
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_nested.test
@@ -0,0 +1,28 @@
+--TEST--
+"extends" tag
+--TEMPLATE--
+{% extends "foo.twig" %}
+
+{% block content %}
+ {% block inside %}
+ INSIDE OVERRIDDEN
+ {% endblock %}
+
+ BEFORE
+ {{ parent() }}
+ AFTER
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}
+ BAR
+{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+
+INSIDE OVERRIDDEN
+
+ BEFORE
+ BAR
+
+ AFTER
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends.test
new file mode 100755
index 0000000..a9eaa4c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends.test
@@ -0,0 +1,8 @@
+--TEST--
+"parent" tag
+--TEMPLATE--
+{% block content %}
+ {{ parent() }}
+{% endblock %}
+--EXCEPTION--
+Twig_Error_Syntax: Calling "parent" on a template that does not extend nor "use" another template is forbidden in "index.twig" at line 3
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends_but_traits.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends_but_traits.test
new file mode 100755
index 0000000..63c7305
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/parent_without_extends_but_traits.test
@@ -0,0 +1,14 @@
+--TEST--
+"parent" tag
+--TEMPLATE--
+{% use 'foo.twig' %}
+
+{% block content %}
+ {{ parent() }}
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array()
+--EXPECT--
+BAR
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/template_instance.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/template_instance.test
new file mode 100755
index 0000000..d1876a5
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/template_instance.test
@@ -0,0 +1,14 @@
+--TEST--
+"extends" tag accepts Twig_Template instance
+--TEMPLATE--
+{% extends foo %}
+
+{% block content %}
+{{ parent() }}FOO
+{% endblock %}
+--TEMPLATE(foo.twig)--
+{% block content %}BAR{% endblock %}
+--DATA--
+return array('foo' => $twig->loadTemplate('foo.twig'))
+--EXPECT--
+BARFOO
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/use.test b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/use.test
new file mode 100755
index 0000000..8f9ece7
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/inheritance/use.test
@@ -0,0 +1,44 @@
+--TEST--
+"parent" function
+--TEMPLATE--
+{% extends "parent.twig" %}
+
+{% use "use1.twig" %}
+{% use "use2.twig" %}
+
+{% block content_parent %}
+ {{ parent() }}
+{% endblock %}
+
+{% block content_use1 %}
+ {{ parent() }}
+{% endblock %}
+
+{% block content_use2 %}
+ {{ parent() }}
+{% endblock %}
+
+{% block content %}
+ {{ block('content_use1_only') }}
+ {{ block('content_use2_only') }}
+{% endblock %}
+--TEMPLATE(parent.twig)--
+{% block content_parent 'content_parent' %}
+{% block content_use1 'content_parent' %}
+{% block content_use2 'content_parent' %}
+{% block content '' %}
+--TEMPLATE(use1.twig)--
+{% block content_use1 'content_use1' %}
+{% block content_use2 'content_use1' %}
+{% block content_use1_only 'content_use1_only' %}
+--TEMPLATE(use2.twig)--
+{% block content_use2 'content_use2' %}
+{% block content_use2_only 'content_use2_only' %}
+--DATA--
+return array()
+--EXPECT--
+ content_parent
+ content_use1
+ content_use2
+ content_use1_only
+ content_use2_only
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/macro/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/basic.test
new file mode 100755
index 0000000..ef59a57
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/basic.test
@@ -0,0 +1,15 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{{ _self.input('username') }}
+{{ _self.input('password', null, 'password', 1) }}
+
+{% macro input(name, value, type, size) %}
+
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+
+
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/macro/endmacro_name.test b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/endmacro_name.test
new file mode 100755
index 0000000..fa81189
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/endmacro_name.test
@@ -0,0 +1,14 @@
+--TEST--
+"macro" tag supports name for endmacro
+--TEMPLATE--
+{{ _self.foo() }}
+{{ _self.bar() }}
+
+{% macro foo() %}foo{% endmacro %}
+{% macro bar() %}bar{% endmacro bar %}
+--DATA--
+return array()
+--EXPECT--
+foo
+bar
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/macro/external.test b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/external.test
new file mode 100755
index 0000000..5cd3dae
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/external.test
@@ -0,0 +1,17 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% import 'forms.twig' as forms %}
+
+{{ forms.input('username') }}
+{{ forms.input('password', null, 'password', 1) }}
+--TEMPLATE(forms.twig)--
+{% macro input(name, value, type, size) %}
+
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+
+
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/macro/from.test b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/from.test
new file mode 100755
index 0000000..205f591
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/from.test
@@ -0,0 +1,18 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% from 'forms.twig' import foo %}
+{% from 'forms.twig' import foo as foobar, bar %}
+
+{{ foo('foo') }}
+{{ foobar('foo') }}
+{{ bar('foo') }}
+--TEMPLATE(forms.twig)--
+{% macro foo(name) %}foo{{ name }}{% endmacro %}
+{% macro bar(name) %}bar{{ name }}{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+foofoo
+foofoo
+barfoo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/macro/self_import.test b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/self_import.test
new file mode 100755
index 0000000..17756cb
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/self_import.test
@@ -0,0 +1,17 @@
+--TEST--
+"macro" tag
+--TEMPLATE--
+{% import _self as forms %}
+
+{{ forms.input('username') }}
+{{ forms.input('password', null, 'password', 1) }}
+
+{% macro input(name, value, type, size) %}
+
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+
+
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/macro/special_chars.test b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/special_chars.test
new file mode 100755
index 0000000..e61716e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/macro/special_chars.test
@@ -0,0 +1,12 @@
+--TEST--
+"☃" as a macro name
+--TEMPLATE--
+{{ _self.☃('foo') }}
+
+{% macro ☃(foo) %}
+ ☃{{ foo }}☃
+{% endmacro %}
+--DATA--
+return array()
+--EXPECT--
+☃foo☃
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/raw/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/raw/basic.test
new file mode 100755
index 0000000..0445e85
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/raw/basic.test
@@ -0,0 +1,10 @@
+--TEST--
+"raw" tag
+--TEMPLATE--
+{% raw %}
+{{ foo }}
+{% endraw %}
+--DATA--
+return array()
+--EXPECT--
+{{ foo }}
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/raw/whitespace_control.test b/lib/twig/test/Twig/Tests/Fixtures/tags/raw/whitespace_control.test
new file mode 100755
index 0000000..352bb18
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/raw/whitespace_control.test
@@ -0,0 +1,56 @@
+--TEST--
+"raw" tag
+--TEMPLATE--
+1***
+
+{%- raw %}
+ {{ 'bla' }}
+{% endraw %}
+
+1***
+2***
+
+{%- raw -%}
+ {{ 'bla' }}
+{% endraw %}
+
+2***
+3***
+
+{%- raw -%}
+ {{ 'bla' }}
+{% endraw -%}
+
+3***
+4***
+
+{%- raw -%}
+ {{ 'bla' }}
+{%- endraw %}
+
+4***
+5***
+
+{%- raw -%}
+ {{ 'bla' }}
+{%- endraw -%}
+
+5***
+--DATA--
+return array()
+--EXPECT--
+1***
+ {{ 'bla' }}
+
+
+1***
+2***{{ 'bla' }}
+
+
+2***
+3***{{ 'bla' }}
+3***
+4***{{ 'bla' }}
+
+4***
+5***{{ 'bla' }}5***
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/set/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/set/basic.test
new file mode 100755
index 0000000..a5a9f83
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/set/basic.test
@@ -0,0 +1,20 @@
+--TEST--
+"set" tag
+--TEMPLATE--
+{% set foo = 'foo' %}
+{% set bar = 'foo ' %}
+
+{{ foo }}
+{{ bar }}
+
+{% set foo, bar = 'foo', 'bar' %}
+
+{{ foo }}{{ bar }}
+--DATA--
+return array()
+--EXPECT--
+foo
+foo<br />
+
+
+foobar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/set/capture-empty.test b/lib/twig/test/Twig/Tests/Fixtures/tags/set/capture-empty.test
new file mode 100755
index 0000000..ec657f0
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/set/capture-empty.test
@@ -0,0 +1,9 @@
+--TEST--
+"set" tag block empty capture
+--TEMPLATE--
+{% set foo %}{% endset %}
+
+{% if foo %}FAIL{% endif %}
+--DATA--
+return array()
+--EXPECT--
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/set/capture.test b/lib/twig/test/Twig/Tests/Fixtures/tags/set/capture.test
new file mode 100755
index 0000000..f156a1a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/set/capture.test
@@ -0,0 +1,10 @@
+--TEST--
+"set" tag block capture
+--TEMPLATE--
+{% set foo %}f o o{% endset %}
+
+{{ foo }}
+--DATA--
+return array()
+--EXPECT--
+f o o
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/set/expression.test b/lib/twig/test/Twig/Tests/Fixtures/tags/set/expression.test
new file mode 100755
index 0000000..8ff434a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/set/expression.test
@@ -0,0 +1,12 @@
+--TEST--
+"set" tag
+--TEMPLATE--
+{% set foo, bar = 'foo' ~ 'bar', 'bar' ~ 'foo' %}
+
+{{ foo }}
+{{ bar }}
+--DATA--
+return array()
+--EXPECT--
+foobar
+barfoo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/spaceless/simple.test b/lib/twig/test/Twig/Tests/Fixtures/tags/spaceless/simple.test
new file mode 100755
index 0000000..dd06dec
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/spaceless/simple.test
@@ -0,0 +1,12 @@
+--TEST--
+"spaceless" tag removes whites between HTML tags
+--TEMPLATE--
+{% spaceless %}
+
+
+
+{% endspaceless %}
+--DATA--
+return array()
+--EXPECT--
+
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/special_chars.test b/lib/twig/test/Twig/Tests/Fixtures/tags/special_chars.test
new file mode 100755
index 0000000..d584d9e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/special_chars.test
@@ -0,0 +1,8 @@
+--TEST--
+"☃" custom tag
+--TEMPLATE--
+{% ☃ %}
+--DATA--
+return array()
+--EXPECT--
+☃
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/trim_block.test b/lib/twig/test/Twig/Tests/Fixtures/tags/trim_block.test
new file mode 100755
index 0000000..1d2273f
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/trim_block.test
@@ -0,0 +1,74 @@
+--TEST--
+Whitespace trimming on tags.
+--TEMPLATE--
+{{ 5 * '{#-'|length }}
+{{ '{{-'|length * 5 + '{%-'|length }}
+
+Trim on control tag:
+{% for i in range(1, 9) -%}
+ {{ i }}
+{%- endfor %}
+
+
+Trim on output tag:
+{% for i in range(1, 9) %}
+ {{- i -}}
+{% endfor %}
+
+
+Trim comments:
+
+{#- Invisible -#}
+
+After the comment.
+
+Trim leading space:
+{% if leading %}
+
+ {{- leading }}
+{% endif %}
+
+{%- if leading %}
+ {{- leading }}
+
+{%- endif %}
+
+
+Trim trailing space:
+{% if trailing -%}
+ {{ trailing -}}
+
+{% endif -%}
+
+Combined:
+
+{%- if both -%}
+
+
+{%- endif -%}
+
+end
+--DATA--
+return array('leading' => 'leading space', 'trailing' => 'trailing space', 'both' => 'both')
+--EXPECT--
+15
+18
+
+Trim on control tag:
+123456789
+
+Trim on output tag:
+123456789
+
+Trim comments:After the comment.
+
+Trim leading space:
+leading space
+leading space
+
+Trim trailing space:
+trailing spaceCombined:end
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/use/aliases.test b/lib/twig/test/Twig/Tests/Fixtures/tags/use/aliases.test
new file mode 100755
index 0000000..f887006
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/use/aliases.test
@@ -0,0 +1,12 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "blocks.twig" with content as foo %}
+
+{{ block('foo') }}
+--TEMPLATE(blocks.twig)--
+{% block content 'foo' %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/use/basic.test b/lib/twig/test/Twig/Tests/Fixtures/tags/use/basic.test
new file mode 100755
index 0000000..7364d76
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/use/basic.test
@@ -0,0 +1,12 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "blocks.twig" %}
+
+{{ block('content') }}
+--TEMPLATE(blocks.twig)--
+{% block content 'foo' %}
+--DATA--
+return array()
+--EXPECT--
+foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/use/deep.test b/lib/twig/test/Twig/Tests/Fixtures/tags/use/deep.test
new file mode 100755
index 0000000..b551a1e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/use/deep.test
@@ -0,0 +1,22 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" %}
+
+{{ block('content') }}
+{{ block('foo') }}
+{{ block('bar') }}
+--TEMPLATE(foo.twig)--
+{% use "bar.twig" %}
+
+{% block content 'foo' %}
+{% block foo 'foo' %}
+--TEMPLATE(bar.twig)--
+{% block content 'bar' %}
+{% block bar 'bar' %}
+--DATA--
+return array()
+--EXPECT--
+foo
+foo
+bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/use/deep_empty.test b/lib/twig/test/Twig/Tests/Fixtures/tags/use/deep_empty.test
new file mode 100755
index 0000000..05cca68
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/use/deep_empty.test
@@ -0,0 +1,10 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" %}
+--TEMPLATE(foo.twig)--
+{% use "bar.twig" %}
+--TEMPLATE(bar.twig)--
+--DATA--
+return array()
+--EXPECT--
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/use/multiple.test b/lib/twig/test/Twig/Tests/Fixtures/tags/use/multiple.test
new file mode 100755
index 0000000..198be0c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/use/multiple.test
@@ -0,0 +1,21 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" %}
+{% use "bar.twig" %}
+
+{{ block('content') }}
+{{ block('foo') }}
+{{ block('bar') }}
+--TEMPLATE(foo.twig)--
+{% block content 'foo' %}
+{% block foo 'foo' %}
+--TEMPLATE(bar.twig)--
+{% block content 'bar' %}
+{% block bar 'bar' %}
+--DATA--
+return array()
+--EXPECT--
+bar
+foo
+bar
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tags/use/multiple_aliases.test b/lib/twig/test/Twig/Tests/Fixtures/tags/use/multiple_aliases.test
new file mode 100755
index 0000000..8de871a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tags/use/multiple_aliases.test
@@ -0,0 +1,23 @@
+--TEST--
+"use" tag
+--TEMPLATE--
+{% use "foo.twig" with content as foo_content %}
+{% use "bar.twig" %}
+
+{{ block('content') }}
+{{ block('foo') }}
+{{ block('bar') }}
+{{ block('foo_content') }}
+--TEMPLATE(foo.twig)--
+{% block content 'foo' %}
+{% block foo 'foo' %}
+--TEMPLATE(bar.twig)--
+{% block content 'bar' %}
+{% block bar 'bar' %}
+--DATA--
+return array()
+--EXPECT--
+bar
+foo
+bar
+foo
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tests/array.test b/lib/twig/test/Twig/Tests/Fixtures/tests/array.test
new file mode 100755
index 0000000..1429d37
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tests/array.test
@@ -0,0 +1,24 @@
+--TEST--
+array index test
+--TEMPLATE--
+{% for key, value in days %}
+{{ key }}
+{% endfor %}
+--DATA--
+return array('days' => array(
+ 1 => array('money' => 9),
+ 2 => array('money' => 21),
+ 3 => array('money' => 38),
+ 4 => array('money' => 6),
+ 18 => array('money' => 6),
+ 19 => array('money' => 3),
+ 31 => array('money' => 11),
+));
+--EXPECT--
+1
+2
+3
+4
+18
+19
+31
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tests/constant.test b/lib/twig/test/Twig/Tests/Fixtures/tests/constant.test
new file mode 100755
index 0000000..fb3d288
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tests/constant.test
@@ -0,0 +1,12 @@
+--TEST--
+"const" test
+--TEMPLATE--
+{{ 8 is constant('E_NOTICE') ? 'ok' : 'no' }}
+{{ 'bar' is constant('Foo::BAR_NAME') ? 'ok' : 'no' }}
+{{ value is constant('Foo::BAR_NAME') ? 'ok' : 'no' }}
+--DATA--
+return array('value' => 'bar');
+--EXPECT--
+ok
+ok
+ok
\ No newline at end of file
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tests/defined.test b/lib/twig/test/Twig/Tests/Fixtures/tests/defined.test
new file mode 100755
index 0000000..2fbaa86
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tests/defined.test
@@ -0,0 +1,108 @@
+--TEST--
+"defined" test
+--TEMPLATE--
+{{ definedVar is defined ? 'ok' : 'ko' }}
+{{ definedVar is not defined ? 'ko' : 'ok' }}
+{{ undefinedVar is defined ? 'ko' : 'ok' }}
+{{ undefinedVar is not defined ? 'ok' : 'ko' }}
+{{ zeroVar is defined ? 'ok' : 'ko' }}
+{{ nullVar is defined ? 'ok' : 'ko' }}
+{{ nested.definedVar is defined ? 'ok' : 'ko' }}
+{{ nested['definedVar'] is defined ? 'ok' : 'ko' }}
+{{ nested.definedVar is not defined ? 'ko' : 'ok' }}
+{{ nested.undefinedVar is defined ? 'ko' : 'ok' }}
+{{ nested['undefinedVar'] is defined ? 'ko' : 'ok' }}
+{{ nested.undefinedVar is not defined ? 'ok' : 'ko' }}
+{{ nested.zeroVar is defined ? 'ok' : 'ko' }}
+{{ nested.nullVar is defined ? 'ok' : 'ko' }}
+{{ nested.definedArray.0 is defined ? 'ok' : 'ko' }}
+{{ nested['definedArray'][0] is defined ? 'ok' : 'ko' }}
+{{ object.foo is defined ? 'ok' : 'ko' }}
+{{ object.undefinedMethod is defined ? 'ko' : 'ok' }}
+{{ object.getFoo() is defined ? 'ok' : 'ko' }}
+{{ object.getFoo('a') is defined ? 'ok' : 'ko' }}
+{{ object.undefinedMethod() is defined ? 'ko' : 'ok' }}
+{{ object.undefinedMethod('a') is defined ? 'ko' : 'ok' }}
+{{ object.self.foo is defined ? 'ok' : 'ko' }}
+{{ object.self.undefinedMethod is defined ? 'ko' : 'ok' }}
+{{ object.undefinedMethod.self is defined ? 'ko' : 'ok' }}
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new Foo(),
+);
+--EXPECT--
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+--DATA--
+return array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'nested' => array(
+ 'definedVar' => 'defined',
+ 'zeroVar' => 0,
+ 'nullVar' => null,
+ 'definedArray' => array(0),
+ ),
+ 'object' => new Foo(),
+);
+--CONFIG--
+return array('strict_variables' => false)
+--EXPECT--
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
+ok
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tests/empty.test b/lib/twig/test/Twig/Tests/Fixtures/tests/empty.test
new file mode 100755
index 0000000..a776d03
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tests/empty.test
@@ -0,0 +1,45 @@
+--TEST--
+"empty" test
+--TEMPLATE--
+{{ foo is empty ? 'ok' : 'ko' }}
+{{ bar is empty ? 'ok' : 'ko' }}
+{{ foobar is empty ? 'ok' : 'ko' }}
+{{ array is empty ? 'ok' : 'ko' }}
+{{ zero is empty ? 'ok' : 'ko' }}
+{{ string is empty ? 'ok' : 'ko' }}
+{{ countable_empty is empty ? 'ok' : 'ko' }}
+{{ countable_not_empty is empty ? 'ok' : 'ko' }}
+{{ markup_empty is empty ? 'ok' : 'ko' }}
+{{ markup_not_empty is empty ? 'ok' : 'ko' }}
+--DATA--
+
+class CountableStub implements Countable
+{
+ private $items;
+
+ public function __construct(array $items)
+ {
+ $this->items = $items;
+ }
+
+ public function count()
+ {
+ return count($this->items);
+ }
+}
+return array(
+ 'foo' => '', 'bar' => null, 'foobar' => false, 'array' => array(), 'zero' => 0, 'string' => '0',
+ 'countable_empty' => new CountableStub(array()), 'countable_not_empty' => new CountableStub(array(1, 2)),
+ 'markup_empty' => new Twig_Markup('', 'UTF-8'), 'markup_not_empty' => new Twig_Markup('test', 'UTF-8'),
+);
+--EXPECT--
+ok
+ok
+ok
+ok
+ko
+ko
+ok
+ko
+ok
+ko
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tests/even.test b/lib/twig/test/Twig/Tests/Fixtures/tests/even.test
new file mode 100755
index 0000000..695b4c2
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tests/even.test
@@ -0,0 +1,14 @@
+--TEST--
+"even" test
+--TEMPLATE--
+{{ 1 is even ? 'ko' : 'ok' }}
+{{ 2 is even ? 'ok' : 'ko' }}
+{{ 1 is not even ? 'ok' : 'ko' }}
+{{ 2 is not even ? 'ko' : 'ok' }}
+--DATA--
+return array()
+--EXPECT--
+ok
+ok
+ok
+ok
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tests/in.test b/lib/twig/test/Twig/Tests/Fixtures/tests/in.test
new file mode 100755
index 0000000..45c72fd
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tests/in.test
@@ -0,0 +1,48 @@
+--TEST--
+Twig supports the in operator
+--TEMPLATE--
+{% if bar in foo %}
+TRUE
+{% endif %}
+{% if not (bar in foo) %}
+{% else %}
+TRUE
+{% endif %}
+{% if bar not in foo %}
+{% else %}
+TRUE
+{% endif %}
+{% if 'a' in bar %}
+TRUE
+{% endif %}
+{% if 'c' not in bar %}
+TRUE
+{% endif %}
+{% if '' not in bar %}
+TRUE
+{% endif %}
+{% if '' in '' %}
+TRUE
+{% endif %}
+{% if '0' not in '' %}
+TRUE
+{% endif %}
+{% if 'a' not in '0' %}
+TRUE
+{% endif %}
+{% if '0' in '0' %}
+TRUE
+{% endif %}
+--DATA--
+return array('bar' => 'bar', 'foo' => array('bar' => 'bar'))
+--EXPECT--
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
+TRUE
diff --git a/lib/twig/test/Twig/Tests/Fixtures/tests/odd.test b/lib/twig/test/Twig/Tests/Fixtures/tests/odd.test
new file mode 100755
index 0000000..1b8311e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Fixtures/tests/odd.test
@@ -0,0 +1,10 @@
+--TEST--
+"odd" test
+--TEMPLATE--
+{{ 1 is odd ? 'ok' : 'ko' }}
+{{ 2 is odd ? 'ko' : 'ok' }}
+--DATA--
+return array()
+--EXPECT--
+ok
+ok
\ No newline at end of file
diff --git a/lib/twig/test/Twig/Tests/LexerTest.php b/lib/twig/test/Twig/Tests/LexerTest.php
new file mode 100755
index 0000000..ce87898
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/LexerTest.php
@@ -0,0 +1,249 @@
+tokenize($template);
+
+ $stream->expect(Twig_Token::BLOCK_START_TYPE);
+ $this->assertSame('☃', $stream->expect(Twig_Token::NAME_TYPE)->getValue());
+ }
+
+ public function testNameLabelForFunction()
+ {
+ $template = '{{ ☃() }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $this->assertSame('☃', $stream->expect(Twig_Token::NAME_TYPE)->getValue());
+ }
+
+ public function testBracketsNesting()
+ {
+ $template = '{{ {"a":{"b":"c"}} }}';
+
+ $this->assertEquals(2, $this->countToken($template, Twig_Token::PUNCTUATION_TYPE, '{'));
+ $this->assertEquals(2, $this->countToken($template, Twig_Token::PUNCTUATION_TYPE, '}'));
+ }
+
+ protected function countToken($template, $type, $value = null)
+ {
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ $count = 0;
+ $tokens = array();
+ while (!$stream->isEOF()) {
+ $token = $stream->next();
+ if ($type === $token->getType()) {
+ if (null === $value || $value === $token->getValue()) {
+ ++$count;
+ }
+ }
+ }
+
+ return $count;
+ }
+
+ public function testLineDirective()
+ {
+ $template = "foo\n"
+ . "bar\n"
+ . "{% line 10 %}\n"
+ . "{{\n"
+ . "baz\n"
+ . "}}\n";
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ // foo\nbar\n
+ $this->assertSame(1, $stream->expect(Twig_Token::TEXT_TYPE)->getLine());
+ // \n (after {% line %})
+ $this->assertSame(10, $stream->expect(Twig_Token::TEXT_TYPE)->getLine());
+ // {{
+ $this->assertSame(11, $stream->expect(Twig_Token::VAR_START_TYPE)->getLine());
+ // baz
+ $this->assertSame(12, $stream->expect(Twig_Token::NAME_TYPE)->getLine());
+ }
+
+ public function testLineDirectiveInline()
+ {
+ $template = "foo\n"
+ . "bar{% line 10 %}{{\n"
+ . "baz\n"
+ . "}}\n";
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ // foo\nbar
+ $this->assertSame(1, $stream->expect(Twig_Token::TEXT_TYPE)->getLine());
+ // {{
+ $this->assertSame(10, $stream->expect(Twig_Token::VAR_START_TYPE)->getLine());
+ // baz
+ $this->assertSame(11, $stream->expect(Twig_Token::NAME_TYPE)->getLine());
+ }
+
+ public function testLongComments()
+ {
+ $template = '{# '.str_repeat('*', 100000).' #}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testLongRaw()
+ {
+ $template = '{% raw %}'.str_repeat('*', 100000).'{% endraw %}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testLongVar()
+ {
+ $template = '{{ '.str_repeat('x', 100000).' }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testLongBlock()
+ {
+ $template = '{% '.str_repeat('x', 100000).' %}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+
+ // should not throw an exception
+ }
+
+ public function testBigNumbers()
+ {
+ $template = '{{ 922337203685477580700 }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $node = $stream->next();
+ $node = $stream->next();
+ $this->assertEquals(922337203685477580700, $node->getValue());
+ }
+
+ public function testString()
+ {
+ $template = 'foo {{ "bar #{ baz + 1 }" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::TEXT_TYPE, 'foo ');
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar ');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'baz');
+ $stream->expect(Twig_Token::OPERATOR_TYPE, '+');
+ $stream->expect(Twig_Token::NUMBER_TYPE, '1');
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ public function testStringWithEscapedInterpolation()
+ {
+ $template = '{{ "bar \#{baz+1}" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar #{baz+1}');
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ public function testStringWithHash()
+ {
+ $template = '{{ "bar # baz" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar # baz');
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unclosed """
+ */
+ public function testStringWithUnterminatedInterpolation()
+ {
+ $template = '{{ "bar #{x" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ }
+
+ public function testStringWithNestedInterpolations()
+ {
+ $template = '{{ "bar #{ "foo#{bar}" }" }}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar ');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'foo');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'bar');
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::VAR_END_TYPE);
+ }
+
+ public function testStringWithNestedInterpolationsInBlock()
+ {
+ $template = '{% foo "bar #{ "foo#{bar}" }" %}';
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::BLOCK_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'foo');
+ $stream->expect(Twig_Token::STRING_TYPE, 'bar ');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::STRING_TYPE, 'foo');
+ $stream->expect(Twig_Token::INTERPOLATION_START_TYPE);
+ $stream->expect(Twig_Token::NAME_TYPE, 'bar');
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::INTERPOLATION_END_TYPE);
+ $stream->expect(Twig_Token::BLOCK_END_TYPE);
+ }
+
+ public function testOperatorEndingWithALetterAtTheEndOfALine()
+ {
+ $template = "{{ 1 and\n0}}";
+
+ $lexer = new Twig_Lexer(new Twig_Environment());
+ $stream = $lexer->tokenize($template);
+ $stream->expect(Twig_Token::VAR_START_TYPE);
+ $stream->expect(Twig_Token::NUMBER_TYPE, 1);
+ $stream->expect(Twig_Token::OPERATOR_TYPE, 'and');
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Loader/ArrayTest.php b/lib/twig/test/Twig/Tests/Loader/ArrayTest.php
new file mode 100755
index 0000000..1369a6b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Loader/ArrayTest.php
@@ -0,0 +1,97 @@
+ 'bar'));
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetSourceWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Array(array());
+
+ $loader->getSource('foo');
+ }
+
+ public function testGetCacheKey()
+ {
+ $loader = new Twig_Loader_Array(array('foo' => 'bar'));
+
+ $this->assertEquals('bar', $loader->getCacheKey('foo'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetCacheKeyWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Array(array());
+
+ $loader->getCacheKey('foo');
+ }
+
+ public function testSetTemplate()
+ {
+ $loader = new Twig_Loader_Array(array());
+ $loader->setTemplate('foo', 'bar');
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ }
+
+ public function testIsFresh()
+ {
+ $loader = new Twig_Loader_Array(array('foo' => 'bar'));
+ $this->assertTrue($loader->isFresh('foo', time()));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testIsFreshWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Array(array());
+
+ $loader->isFresh('foo', time());
+ }
+
+ public function testTemplateReference()
+ {
+ $name = new Twig_Test_Loader_TemplateReference('foo');
+ $loader = new Twig_Loader_Array(array('foo' => 'bar'));
+
+ $loader->getCacheKey($name);
+ $loader->getSource($name);
+ $loader->isFresh($name, time());
+ $loader->setTemplate($name, 'foobar');
+ }
+}
+
+class Twig_Test_Loader_TemplateReference
+{
+ private $name;
+
+ public function __construct($name)
+ {
+ $this->name = $name;
+ }
+
+ public function __toString()
+ {
+ return $this->name;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Loader/ChainTest.php b/lib/twig/test/Twig/Tests/Loader/ChainTest.php
new file mode 100755
index 0000000..580ae10
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Loader/ChainTest.php
@@ -0,0 +1,63 @@
+ 'bar')),
+ new Twig_Loader_Array(array('foo' => 'foobar', 'bar' => 'foo')),
+ ));
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ $this->assertEquals('foo', $loader->getSource('bar'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetSourceWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Chain(array());
+
+ $loader->getSource('foo');
+ }
+
+ public function testGetCacheKey()
+ {
+ $loader = new Twig_Loader_Chain(array(
+ new Twig_Loader_Array(array('foo' => 'bar')),
+ new Twig_Loader_Array(array('foo' => 'foobar', 'bar' => 'foo')),
+ ));
+
+ $this->assertEquals('bar', $loader->getCacheKey('foo'));
+ $this->assertEquals('foo', $loader->getCacheKey('bar'));
+ }
+
+ /**
+ * @expectedException Twig_Error_Loader
+ */
+ public function testGetCacheKeyWhenTemplateDoesNotExist()
+ {
+ $loader = new Twig_Loader_Chain(array());
+
+ $loader->getCacheKey('foo');
+ }
+
+ public function testAddLoader()
+ {
+ $loader = new Twig_Loader_Chain();
+ $loader->addLoader(new Twig_Loader_Array(array('foo' => 'bar')));
+
+ $this->assertEquals('bar', $loader->getSource('foo'));
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Loader/FilesystemTest.php b/lib/twig/test/Twig/Tests/Loader/FilesystemTest.php
new file mode 100755
index 0000000..22ae5aa
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Loader/FilesystemTest.php
@@ -0,0 +1,52 @@
+getCacheKey($template);
+ $this->fail();
+ } catch (Twig_Error_Loader $e) {
+ $this->assertNotContains('Unable to find template', $e->getMessage());
+ }
+ }
+
+ public function getSecurityTests()
+ {
+ return array(
+ array("AutoloaderTest\0.php"),
+ array('..\\AutoloaderTest.php'),
+ array('..\\\\\\AutoloaderTest.php'),
+ array('../AutoloaderTest.php'),
+ array('..////AutoloaderTest.php'),
+ array('./../AutoloaderTest.php'),
+ array('.\\..\\AutoloaderTest.php'),
+ array('././././././../AutoloaderTest.php'),
+ array('.\\./.\\./.\\./../AutoloaderTest.php'),
+ array('foo/../../AutoloaderTest.php'),
+ array('foo\\..\\..\\AutoloaderTest.php'),
+ array('foo/../bar/../../AutoloaderTest.php'),
+ array('foo/bar/../../../AutoloaderTest.php'),
+ array('filters/../../AutoloaderTest.php'),
+ array('filters//..//..//AutoloaderTest.php'),
+ array('filters\\..\\..\\AutoloaderTest.php'),
+ array('filters\\\\..\\\\..\\\\AutoloaderTest.php'),
+ array('filters\\//../\\/\\..\\AutoloaderTest.php'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/AutoEscapeTest.php b/lib/twig/test/Twig/Tests/Node/AutoEscapeTest.php
new file mode 100755
index 0000000..ebfcb48
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/AutoEscapeTest.php
@@ -0,0 +1,46 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals(true, $node->getAttribute('value'));
+ }
+
+ /**
+ * @covers Twig_Node_AutoEscape::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node(array(new Twig_Node_Text('foo', 0)));
+ $node = new Twig_Node_AutoEscape(true, $body, 0);
+
+ return array(
+ array($node, 'echo "foo";'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/BlockReferenceTest.php b/lib/twig/test/Twig/Tests/Node/BlockReferenceTest.php
new file mode 100755
index 0000000..f1c5ab1
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/BlockReferenceTest.php
@@ -0,0 +1,41 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ /**
+ * @covers Twig_Node_BlockReference::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ return array(
+ array(new Twig_Node_BlockReference('foo', 0), '$this->displayBlock(\'foo\', $context, $blocks);'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/BlockTest.php b/lib/twig/test/Twig/Tests/Node/BlockTest.php
new file mode 100755
index 0000000..6bc5e79
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/BlockTest.php
@@ -0,0 +1,52 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ /**
+ * @covers Twig_Node_Block::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node_Text('foo', 0);
+ $node = new Twig_Node_Block('foo', $body, 0);
+
+ return array(
+ array($node, <<assertEquals($expr, $node->getNode('expr'));
+ }
+
+ /**
+ * @covers Twig_Node_Do::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo', 0);
+ $node = new Twig_Node_Do($expr, 0);
+ $tests[] = array($node, '"foo";');
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/ArrayTest.php b/lib/twig/test/Twig/Tests/Node/Expression/ArrayTest.php
new file mode 100755
index 0000000..06b30e9
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/ArrayTest.php
@@ -0,0 +1,51 @@
+assertEquals($foo, $node->getNode(1));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Array::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $elements = array(
+ new Twig_Node_Expression_Constant('foo', 0),
+ new Twig_Node_Expression_Constant('bar', 0),
+
+ new Twig_Node_Expression_Constant('bar', 0),
+ new Twig_Node_Expression_Constant('foo', 0),
+ );
+ $node = new Twig_Node_Expression_Array($elements, 0);
+
+ return array(
+ array($node, 'array("foo" => "bar", "bar" => "foo")'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/AssignNameTest.php b/lib/twig/test/Twig/Tests/Node/Expression/AssignNameTest.php
new file mode 100755
index 0000000..fc92b0d
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/AssignNameTest.php
@@ -0,0 +1,43 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_AssignName::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_AssignName('foo', 0);
+
+ return array(
+ array($node, '$context["foo"]'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/AddTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/AddTest.php
new file mode 100755
index 0000000..80d318f
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/AddTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_Add::compile
+ * @covers Twig_Node_Expression_Binary_Add::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_Add($left, $right, 0);
+
+ return array(
+ array($node, '(1 + 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/AndTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/AndTest.php
new file mode 100755
index 0000000..a6ed4f2
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/AndTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_And::compile
+ * @covers Twig_Node_Expression_Binary_And::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_And($left, $right, 0);
+
+ return array(
+ array($node, '(1 && 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/ConcatTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/ConcatTest.php
new file mode 100755
index 0000000..a04edc9
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/ConcatTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_Concat::compile
+ * @covers Twig_Node_Expression_Binary_Concat::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_Concat($left, $right, 0);
+
+ return array(
+ array($node, '(1 . 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/DivTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/DivTest.php
new file mode 100755
index 0000000..42002fc
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/DivTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_Div::compile
+ * @covers Twig_Node_Expression_Binary_Div::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_Div($left, $right, 0);
+
+ return array(
+ array($node, '(1 / 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/FloorDivTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/FloorDivTest.php
new file mode 100755
index 0000000..94ff2f6
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/FloorDivTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_FloorDiv::compile
+ * @covers Twig_Node_Expression_Binary_FloorDiv::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_FloorDiv($left, $right, 0);
+
+ return array(
+ array($node, 'intval(floor((1 / 2)))'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/ModTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/ModTest.php
new file mode 100755
index 0000000..67612a5
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/ModTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_Mod::compile
+ * @covers Twig_Node_Expression_Binary_Mod::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_Mod($left, $right, 0);
+
+ return array(
+ array($node, '(1 % 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/MulTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/MulTest.php
new file mode 100755
index 0000000..c817d02
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/MulTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_Mul::compile
+ * @covers Twig_Node_Expression_Binary_Mul::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_Mul($left, $right, 0);
+
+ return array(
+ array($node, '(1 * 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/OrTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/OrTest.php
new file mode 100755
index 0000000..d8e2f8d
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/OrTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_Or::compile
+ * @covers Twig_Node_Expression_Binary_Or::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_Or($left, $right, 0);
+
+ return array(
+ array($node, '(1 || 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Binary/SubTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Binary/SubTest.php
new file mode 100755
index 0000000..6583d09
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Binary/SubTest.php
@@ -0,0 +1,49 @@
+assertEquals($left, $node->getNode('left'));
+ $this->assertEquals($right, $node->getNode('right'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Binary_Sub::compile
+ * @covers Twig_Node_Expression_Binary_Sub::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $left = new Twig_Node_Expression_Constant(1, 0);
+ $right = new Twig_Node_Expression_Constant(2, 0);
+ $node = new Twig_Node_Expression_Binary_Sub($left, $right, 0);
+
+ return array(
+ array($node, '(1 - 2)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/ConditionalTest.php b/lib/twig/test/Twig/Tests/Node/Expression/ConditionalTest.php
new file mode 100755
index 0000000..4a05e4e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/ConditionalTest.php
@@ -0,0 +1,52 @@
+assertEquals($expr1, $node->getNode('expr1'));
+ $this->assertEquals($expr2, $node->getNode('expr2'));
+ $this->assertEquals($expr3, $node->getNode('expr3'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Conditional::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr1 = new Twig_Node_Expression_Constant(1, 0);
+ $expr2 = new Twig_Node_Expression_Constant(2, 0);
+ $expr3 = new Twig_Node_Expression_Constant(3, 0);
+ $node = new Twig_Node_Expression_Conditional($expr1, $expr2, $expr3, 0);
+ $tests[] = array($node, '((1) ? (2) : (3))');
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/ConstantTest.php b/lib/twig/test/Twig/Tests/Node/Expression/ConstantTest.php
new file mode 100755
index 0000000..0cf3867
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/ConstantTest.php
@@ -0,0 +1,44 @@
+assertEquals('foo', $node->getAttribute('value'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Constant::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $node = new Twig_Node_Expression_Constant('foo', 0);
+ $tests[] = array($node, '"foo"');
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/FilterTest.php b/lib/twig/test/Twig/Tests/Node/Expression/FilterTest.php
new file mode 100755
index 0000000..2c52482
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/FilterTest.php
@@ -0,0 +1,85 @@
+assertEquals($expr, $node->getNode('node'));
+ $this->assertEquals($name, $node->getNode('filter'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Filter::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+
+ $expr = new Twig_Node_Expression_Constant('foo', 0);
+ $node = $this->createFilter($expr, 'foobar', array(new Twig_Node_Expression_Constant('bar', 0), new Twig_Node_Expression_Constant('foobar', 0)));
+
+ try {
+ $node->compile($this->getCompiler());
+ $this->fail();
+ } catch (Exception $e) {
+ $this->assertEquals('Twig_Error_Syntax', get_class($e));
+ }
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo', 0);
+ $node = $this->createFilter($expr, 'upper');
+ $node = $this->createFilter($node, 'lower', array(new Twig_Node_Expression_Constant('bar', 0), new Twig_Node_Expression_Constant('foobar', 0)));
+
+ if (function_exists('mb_get_info')) {
+ $tests[] = array($node, 'twig_lower_filter($this->env, twig_upper_filter($this->env, "foo"), "bar", "foobar")');
+ } else {
+ $tests[] = array($node, 'strtolower(strtoupper("foo"), "bar", "foobar")');
+ }
+
+ return $tests;
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Filter::compile
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage The filter "uppe" does not exist. Did you mean "upper" at line 0
+ */
+ public function testUnknownFilter()
+ {
+ $node = $this->createFilter(new Twig_Node_Expression_Constant('foo', 0), 'uppe');
+ $node->compile($this->getCompiler());
+ }
+
+ protected function createFilter($node, $name, array $arguments = array())
+ {
+ $name = new Twig_Node_Expression_Constant($name, 0);
+ $arguments = new Twig_Node($arguments);
+
+ return new Twig_Node_Expression_Filter($node, $name, $arguments, 0);
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/FunctionTest.php b/lib/twig/test/Twig/Tests/Node/Expression/FunctionTest.php
new file mode 100755
index 0000000..68c5c61
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/FunctionTest.php
@@ -0,0 +1,90 @@
+assertEquals($name, $node->getAttribute('name'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Function::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Filter::compile
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage The function "cycl" does not exist. Did you mean "cycle" at line 0
+ */
+ public function testUnknownFunction()
+ {
+ $node = $this->createFunction('cycl', array());
+ $node->compile($this->getCompiler());
+ }
+
+ public function getTests()
+ {
+ $environment = new Twig_Environment();
+ $environment->addFunction('foo', new Twig_Function_Function('foo', array()));
+ $environment->addFunction('bar', new Twig_Function_Function('bar', array('needs_environment' => true)));
+ $environment->addFunction('foofoo', new Twig_Function_Function('foofoo', array('needs_context' => true)));
+ $environment->addFunction('foobar', new Twig_Function_Function('foobar', array('needs_environment' => true, 'needs_context' => true)));
+
+ $tests = array();
+
+ $node = $this->createFunction('foo');
+ $tests[] = array($node, 'foo()', $environment);
+
+ $node = $this->createFunction('foo', array(new Twig_Node_Expression_Constant('bar', 0), new Twig_Node_Expression_Constant('foobar', 0)));
+ $tests[] = array($node, 'foo("bar", "foobar")', $environment);
+
+ $node = $this->createFunction('bar');
+ $tests[] = array($node, 'bar($this->env)', $environment);
+
+ $node = $this->createFunction('bar', array(new Twig_Node_Expression_Constant('bar', 0)));
+ $tests[] = array($node, 'bar($this->env, "bar")', $environment);
+
+ $node = $this->createFunction('foofoo');
+ $tests[] = array($node, 'foofoo($context)', $environment);
+
+ $node = $this->createFunction('foofoo', array(new Twig_Node_Expression_Constant('bar', 0)));
+ $tests[] = array($node, 'foofoo($context, "bar")', $environment);
+
+ $node = $this->createFunction('foobar');
+ $tests[] = array($node, 'foobar($this->env, $context)', $environment);
+
+ $node = $this->createFunction('foobar', array(new Twig_Node_Expression_Constant('bar', 0)));
+ $tests[] = array($node, 'foobar($this->env, $context, "bar")', $environment);
+
+ return $tests;
+ }
+
+ protected function createFunction($name, array $arguments = array())
+ {
+ return new Twig_Node_Expression_Function($name, new Twig_Node($arguments), 0);
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/GetAttrTest.php b/lib/twig/test/Twig/Tests/Node/Expression/GetAttrTest.php
new file mode 100755
index 0000000..6df143d
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/GetAttrTest.php
@@ -0,0 +1,64 @@
+addElement(new Twig_Node_Expression_Name('foo', 0));
+ $args->addElement(new Twig_Node_Expression_Constant('bar', 0));
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_TemplateInterface::ARRAY_CALL, 0);
+
+ $this->assertEquals($expr, $node->getNode('node'));
+ $this->assertEquals($attr, $node->getNode('attribute'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ $this->assertEquals(Twig_TemplateInterface::ARRAY_CALL, $node->getAttribute('type'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_GetAttr::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Name('foo', 0);
+ $attr = new Twig_Node_Expression_Constant('bar', 0);
+ $args = new Twig_Node_Expression_Array(array(), 0);
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_TemplateInterface::ANY_CALL, 0);
+ $tests[] = array($node, sprintf('%s%s, "bar")', $this->getAttributeGetter(), $this->getVariableGetter('foo')));
+
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_TemplateInterface::ARRAY_CALL, 0);
+ $tests[] = array($node, sprintf('%s%s, "bar", array(), "array")', $this->getAttributeGetter(), $this->getVariableGetter('foo')));
+
+ $args = new Twig_Node_Expression_Array(array(), 0);
+ $args->addElement(new Twig_Node_Expression_Name('foo', 0));
+ $args->addElement(new Twig_Node_Expression_Constant('bar', 0));
+ $node = new Twig_Node_Expression_GetAttr($expr, $attr, $args, Twig_TemplateInterface::METHOD_CALL, 0);
+ $tests[] = array($node, sprintf('%s%s, "bar", array(0 => %s, 1 => "bar"), "method")', $this->getAttributeGetter(), $this->getVariableGetter('foo'), $this->getVariableGetter('foo')));
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/NameTest.php b/lib/twig/test/Twig/Tests/Node/Expression/NameTest.php
new file mode 100755
index 0000000..e77b432
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/NameTest.php
@@ -0,0 +1,51 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Name::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Name('foo', 0);
+ $self = new Twig_Node_Expression_Name('_self', 0);
+ $context = new Twig_Node_Expression_Name('_context', 0);
+
+ $env = new Twig_Environment(null, array('strict_variables' => true));
+ $env1 = new Twig_Environment(null, array('strict_variables' => false));
+
+ return array(
+ array($node, '$this->getContext($context, "foo")', $env),
+ array($node, $this->getVariableGetter('foo'), $env1),
+ array($self, '$this'),
+ array($context, '$context'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/ParentTest.php b/lib/twig/test/Twig/Tests/Node/Expression/ParentTest.php
new file mode 100755
index 0000000..7efbe03
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/ParentTest.php
@@ -0,0 +1,42 @@
+assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Parent::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+ $tests[] = array(new Twig_Node_Expression_Parent('foo', 0), '$this->renderParentBlock("foo", $context, $blocks)');
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/TestTest.php b/lib/twig/test/Twig/Tests/Node/Expression/TestTest.php
new file mode 100755
index 0000000..08668c0
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/TestTest.php
@@ -0,0 +1,67 @@
+assertEquals($expr, $node->getNode('node'));
+ $this->assertEquals($args, $node->getNode('arguments'));
+ $this->assertEquals($name, $node->getAttribute('name'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Test::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo', 0);
+ $node = new Twig_Node_Expression_Test_Null($expr, 'null', new Twig_Node(array()), 0);
+
+ $tests[] = array($node, '(null === "foo")');
+
+ return $tests;
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Filter::compile
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage The test "nul" does not exist. Did you mean "null" at line 0
+ */
+ public function testUnknownTest()
+ {
+ $node = $this->createTest(new Twig_Node_Expression_Constant('foo', 0), 'nul');
+ $node->compile($this->getCompiler());
+ }
+
+ protected function createTest($node, $name, array $arguments = array())
+ {
+ return new Twig_Node_Expression_Test($node, $name, new Twig_Node($arguments), 0);
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Unary/NegTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Unary/NegTest.php
new file mode 100755
index 0000000..218de6e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Unary/NegTest.php
@@ -0,0 +1,46 @@
+assertEquals($expr, $node->getNode('node'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Unary_Neg::compile
+ * @covers Twig_Node_Expression_Unary_Neg::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Constant(1, 0);
+ $node = new Twig_Node_Expression_Unary_Neg($node, 0);
+
+ return array(
+ array($node, '(-1)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Unary/NotTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Unary/NotTest.php
new file mode 100755
index 0000000..ed6349c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Unary/NotTest.php
@@ -0,0 +1,46 @@
+assertEquals($expr, $node->getNode('node'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Unary_Not::compile
+ * @covers Twig_Node_Expression_Unary_Not::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Constant(1, 0);
+ $node = new Twig_Node_Expression_Unary_Not($node, 0);
+
+ return array(
+ array($node, '(!1)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/Expression/Unary/PosTest.php b/lib/twig/test/Twig/Tests/Node/Expression/Unary/PosTest.php
new file mode 100755
index 0000000..6a414bc
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/Expression/Unary/PosTest.php
@@ -0,0 +1,46 @@
+assertEquals($expr, $node->getNode('node'));
+ }
+
+ /**
+ * @covers Twig_Node_Expression_Unary_Pos::compile
+ * @covers Twig_Node_Expression_Unary_Pos::operator
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $node = new Twig_Node_Expression_Constant(1, 0);
+ $node = new Twig_Node_Expression_Unary_Pos($node, 0);
+
+ return array(
+ array($node, '(+1)'),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/ForTest.php b/lib/twig/test/Twig/Tests/Node/ForTest.php
new file mode 100755
index 0000000..ef3be82
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/ForTest.php
@@ -0,0 +1,201 @@
+setAttribute('with_loop', false);
+
+ $this->assertEquals($keyTarget, $node->getNode('key_target'));
+ $this->assertEquals($valueTarget, $node->getNode('value_target'));
+ $this->assertEquals($seq, $node->getNode('seq'));
+ $this->assertTrue($node->getAttribute('ifexpr'));
+ $this->assertEquals('Twig_Node_If', get_class($node->getNode('body')));
+ $this->assertEquals($body, $node->getNode('body')->getNode('tests')->getNode(1)->getNode(0));
+ $this->assertEquals(null, $node->getNode('else'));
+
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0);
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 0);
+ $node->setAttribute('with_loop', false);
+ $this->assertEquals($else, $node->getNode('else'));
+ }
+
+ /**
+ * @covers Twig_Node_For::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $keyTarget = new Twig_Node_Expression_AssignName('key', 0);
+ $valueTarget = new Twig_Node_Expression_AssignName('item', 0);
+ $seq = new Twig_Node_Expression_Name('items', 0);
+ $ifexpr = null;
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0)), array(), 0);
+ $else = null;
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 0);
+ $node->setAttribute('with_loop', false);
+
+ $tests[] = array($node, <<getVariableGetter('items')});
+foreach (\$context['_seq'] as \$context["key"] => \$context["item"]) {
+ echo {$this->getVariableGetter('foo')};
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['key'], \$context['item'], \$context['_parent'], \$context['loop']);
+\$context = array_merge(\$_parent, array_intersect_key(\$context, \$_parent));
+EOF
+ );
+
+ $keyTarget = new Twig_Node_Expression_AssignName('k', 0);
+ $valueTarget = new Twig_Node_Expression_AssignName('v', 0);
+ $seq = new Twig_Node_Expression_Name('values', 0);
+ $ifexpr = null;
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0)), array(), 0);
+ $else = null;
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 0);
+ $node->setAttribute('with_loop', true);
+
+ $tests[] = array($node, <<getVariableGetter('values')});
+\$context['loop'] = array(
+ 'parent' => \$context['_parent'],
+ 'index0' => 0,
+ 'index' => 1,
+ 'first' => true,
+);
+if (is_array(\$context['_seq']) || (is_object(\$context['_seq']) && \$context['_seq'] instanceof Countable)) {
+ \$length = count(\$context['_seq']);
+ \$context['loop']['revindex0'] = \$length - 1;
+ \$context['loop']['revindex'] = \$length;
+ \$context['loop']['length'] = \$length;
+ \$context['loop']['last'] = 1 === \$length;
+}
+foreach (\$context['_seq'] as \$context["k"] => \$context["v"]) {
+ echo {$this->getVariableGetter('foo')};
+ ++\$context['loop']['index0'];
+ ++\$context['loop']['index'];
+ \$context['loop']['first'] = false;
+ if (isset(\$context['loop']['length'])) {
+ --\$context['loop']['revindex0'];
+ --\$context['loop']['revindex'];
+ \$context['loop']['last'] = 0 === \$context['loop']['revindex0'];
+ }
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['k'], \$context['v'], \$context['_parent'], \$context['loop']);
+\$context = array_merge(\$_parent, array_intersect_key(\$context, \$_parent));
+EOF
+ );
+
+ $keyTarget = new Twig_Node_Expression_AssignName('k', 0);
+ $valueTarget = new Twig_Node_Expression_AssignName('v', 0);
+ $seq = new Twig_Node_Expression_Name('values', 0);
+ $ifexpr = new Twig_Node_Expression_Constant(true, 0);
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0)), array(), 0);
+ $else = null;
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 0);
+ $node->setAttribute('with_loop', true);
+
+ $tests[] = array($node, <<getVariableGetter('values')});
+\$context['loop'] = array(
+ 'parent' => \$context['_parent'],
+ 'index0' => 0,
+ 'index' => 1,
+ 'first' => true,
+);
+foreach (\$context['_seq'] as \$context["k"] => \$context["v"]) {
+ if (true) {
+ echo {$this->getVariableGetter('foo')};
+ ++\$context['loop']['index0'];
+ ++\$context['loop']['index'];
+ \$context['loop']['first'] = false;
+ }
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['k'], \$context['v'], \$context['_parent'], \$context['loop']);
+\$context = array_merge(\$_parent, array_intersect_key(\$context, \$_parent));
+EOF
+ );
+
+ $keyTarget = new Twig_Node_Expression_AssignName('k', 0);
+ $valueTarget = new Twig_Node_Expression_AssignName('v', 0);
+ $seq = new Twig_Node_Expression_Name('values', 0);
+ $ifexpr = null;
+ $body = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0)), array(), 0);
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0);
+ $node = new Twig_Node_For($keyTarget, $valueTarget, $seq, $ifexpr, $body, $else, 0);
+ $node->setAttribute('with_loop', true);
+
+ $tests[] = array($node, <<getVariableGetter('values')});
+\$context['_iterated'] = false;
+\$context['loop'] = array(
+ 'parent' => \$context['_parent'],
+ 'index0' => 0,
+ 'index' => 1,
+ 'first' => true,
+);
+if (is_array(\$context['_seq']) || (is_object(\$context['_seq']) && \$context['_seq'] instanceof Countable)) {
+ \$length = count(\$context['_seq']);
+ \$context['loop']['revindex0'] = \$length - 1;
+ \$context['loop']['revindex'] = \$length;
+ \$context['loop']['length'] = \$length;
+ \$context['loop']['last'] = 1 === \$length;
+}
+foreach (\$context['_seq'] as \$context["k"] => \$context["v"]) {
+ echo {$this->getVariableGetter('foo')};
+ \$context['_iterated'] = true;
+ ++\$context['loop']['index0'];
+ ++\$context['loop']['index'];
+ \$context['loop']['first'] = false;
+ if (isset(\$context['loop']['length'])) {
+ --\$context['loop']['revindex0'];
+ --\$context['loop']['revindex'];
+ \$context['loop']['last'] = 0 === \$context['loop']['revindex0'];
+ }
+}
+if (!\$context['_iterated']) {
+ echo {$this->getVariableGetter('foo')};
+}
+\$_parent = \$context['_parent'];
+unset(\$context['_seq'], \$context['_iterated'], \$context['k'], \$context['v'], \$context['_parent'], \$context['loop']);
+\$context = array_merge(\$_parent, array_intersect_key(\$context, \$_parent));
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/IfTest.php b/lib/twig/test/Twig/Tests/Node/IfTest.php
new file mode 100755
index 0000000..04b92e7
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/IfTest.php
@@ -0,0 +1,99 @@
+assertEquals($t, $node->getNode('tests'));
+ $this->assertEquals(null, $node->getNode('else'));
+
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('bar', 0), 0);
+ $node = new Twig_Node_If($t, $else, 0);
+ $this->assertEquals($else, $node->getNode('else'));
+ }
+
+ /**
+ * @covers Twig_Node_If::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $t = new Twig_Node(array(
+ new Twig_Node_Expression_Constant(true, 0),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0),
+ ), array(), 0);
+ $else = null;
+ $node = new Twig_Node_If($t, $else, 0);
+
+ $tests[] = array($node, <<getVariableGetter('foo')};
+}
+EOF
+ );
+
+ $t = new Twig_Node(array(
+ new Twig_Node_Expression_Constant(true, 0),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0),
+ new Twig_Node_Expression_Constant(false, 0),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('bar', 0), 0),
+ ), array(), 0);
+ $else = null;
+ $node = new Twig_Node_If($t, $else, 0);
+
+ $tests[] = array($node, <<getVariableGetter('foo')};
+} elseif (false) {
+ echo {$this->getVariableGetter('bar')};
+}
+EOF
+ );
+
+ $t = new Twig_Node(array(
+ new Twig_Node_Expression_Constant(true, 0),
+ new Twig_Node_Print(new Twig_Node_Expression_Name('foo', 0), 0),
+ ), array(), 0);
+ $else = new Twig_Node_Print(new Twig_Node_Expression_Name('bar', 0), 0);
+ $node = new Twig_Node_If($t, $else, 0);
+
+ $tests[] = array($node, <<getVariableGetter('foo')};
+} else {
+ echo {$this->getVariableGetter('bar')};
+}
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/ImportTest.php b/lib/twig/test/Twig/Tests/Node/ImportTest.php
new file mode 100755
index 0000000..6a89195
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/ImportTest.php
@@ -0,0 +1,50 @@
+assertEquals($macro, $node->getNode('expr'));
+ $this->assertEquals($var, $node->getNode('var'));
+ }
+
+ /**
+ * @covers Twig_Node_Import::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $macro = new Twig_Node_Expression_Constant('foo.twig', 0);
+ $var = new Twig_Node_Expression_AssignName('macro', 0);
+ $node = new Twig_Node_Import($macro, $var, 0);
+
+ $tests[] = array($node, '$context["macro"] = $this->env->loadTemplate("foo.twig");');
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/IncludeTest.php b/lib/twig/test/Twig/Tests/Node/IncludeTest.php
new file mode 100755
index 0000000..d068392
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/IncludeTest.php
@@ -0,0 +1,84 @@
+assertEquals(null, $node->getNode('variables'));
+ $this->assertEquals($expr, $node->getNode('expr'));
+ $this->assertFalse($node->getAttribute('only'));
+
+ $vars = new Twig_Node_Expression_Array(array(new Twig_Node_Expression_Constant('foo', 0), new Twig_Node_Expression_Constant(true, 0)), 0);
+ $node = new Twig_Node_Include($expr, $vars, true, false, 0);
+ $this->assertEquals($vars, $node->getNode('variables'));
+ $this->assertTrue($node->getAttribute('only'));
+ }
+
+ /**
+ * @covers Twig_Node_Include::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $expr = new Twig_Node_Expression_Constant('foo.twig', 0);
+ $node = new Twig_Node_Include($expr, null, false, false, 0);
+ $tests[] = array($node, '$this->env->loadTemplate("foo.twig")->display($context);');
+
+ $expr = new Twig_Node_Expression_Conditional(
+ new Twig_Node_Expression_Constant(true, 0),
+ new Twig_Node_Expression_Constant('foo', 0),
+ new Twig_Node_Expression_Constant('foo', 0),
+ 0
+ );
+ $node = new Twig_Node_Include($expr, null, false, false, 0);
+ $tests[] = array($node, <<env->resolveTemplate(((true) ? ("foo") : ("foo")));
+\$template->display(\$context);
+EOF
+ );
+
+ $expr = new Twig_Node_Expression_Constant('foo.twig', 0);
+ $vars = new Twig_Node_Expression_Array(array(new Twig_Node_Expression_Constant('foo', 0), new Twig_Node_Expression_Constant(true, 0)), 0);
+ $node = new Twig_Node_Include($expr, $vars, false, false, 0);
+ $tests[] = array($node, '$this->env->loadTemplate("foo.twig")->display(array_merge($context, array("foo" => true)));');
+
+ $node = new Twig_Node_Include($expr, $vars, true, false, 0);
+ $tests[] = array($node, '$this->env->loadTemplate("foo.twig")->display(array("foo" => true));');
+
+ $node = new Twig_Node_Include($expr, $vars, true, true, 0);
+ $tests[] = array($node, <<env->loadTemplate("foo.twig")->display(array("foo" => true));
+} catch (Twig_Error_Loader \$e) {
+ // ignore missing template
+}
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/MacroTest.php b/lib/twig/test/Twig/Tests/Node/MacroTest.php
new file mode 100755
index 0000000..ddb67d1
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/MacroTest.php
@@ -0,0 +1,70 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals($arguments, $node->getNode('arguments'));
+ $this->assertEquals('foo', $node->getAttribute('name'));
+ }
+
+ /**
+ * @covers Twig_Node_Macro::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node_Text('foo', 0);
+ $arguments = new Twig_Node(array(new Twig_Node_Expression_Name('foo', 0)), array(), 0);
+ $node = new Twig_Node_Macro('foo', $body, $arguments, 0);
+
+ return array(
+ array($node, <<env->getGlobals(), array(
+ "foo" => \$foo,
+ ));
+
+ \$blocks = array();
+
+ ob_start();
+ try {
+ echo "foo";
+ } catch(Exception \$e) {
+ ob_end_clean();
+
+ throw \$e;
+ }
+
+ return ob_get_clean();
+}
+EOF
+ ),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/ModuleTest.php b/lib/twig/test/Twig/Tests/Node/ModuleTest.php
new file mode 100755
index 0000000..4b2b2e9
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/ModuleTest.php
@@ -0,0 +1,176 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals($blocks, $node->getNode('blocks'));
+ $this->assertEquals($macros, $node->getNode('macros'));
+ $this->assertEquals($parent, $node->getNode('parent'));
+ $this->assertEquals($filename, $node->getAttribute('filename'));
+ }
+
+ /**
+ * @covers Twig_Node_Module::compile
+ * @covers Twig_Node_Module::compileTemplate
+ * @covers Twig_Node_Module::compileMacros
+ * @covers Twig_Node_Module::compileClassHeader
+ * @covers Twig_Node_Module::compileDisplayHeader
+ * @covers Twig_Node_Module::compileDisplayBody
+ * @covers Twig_Node_Module::compileDisplayFooter
+ * @covers Twig_Node_Module::compileClassFooter
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $twig = new Twig_Environment(new Twig_Loader_String());
+
+ $tests = array();
+
+ $body = new Twig_Node_Text('foo', 0);
+ $extends = null;
+ $blocks = new Twig_Node();
+ $macros = new Twig_Node();
+ $traits = new Twig_Node();
+ $filename = 'foo.twig';
+
+ $node = new Twig_Node_Module($body, $extends, $blocks, $macros, $traits, $filename);
+ $tests[] = array($node, <<env->loadTemplate("foo.twig");
+ \$this->parent->display(\$context, array_merge(\$this->blocks, \$blocks));
+ }
+
+ public function getTemplateName()
+ {
+ return "foo.twig";
+ }
+
+ public function isTraitable()
+ {
+ return false;
+ }
+
+ public function getDebugInfo()
+ {
+ return array ();
+ }
+}
+EOF
+ , $twig);
+
+ $body = new Twig_Node();
+ $extends = new Twig_Node_Expression_Conditional(
+ new Twig_Node_Expression_Constant(true, 0),
+ new Twig_Node_Expression_Constant('foo', 0),
+ new Twig_Node_Expression_Constant('foo', 0),
+ 0
+ );
+
+ $node = new Twig_Node_Module($body, $extends, $blocks, $macros, $traits, $filename);
+ $tests[] = array($node, <<env->resolveTemplate(((true) ? ("foo") : ("foo")));
+ }
+
+ protected function doDisplay(array \$context, array \$blocks = array())
+ {
+ \$this->getParent(\$context)->display(\$context, array_merge(\$this->blocks, \$blocks));
+ }
+
+ public function getTemplateName()
+ {
+ return "foo.twig";
+ }
+
+ public function isTraitable()
+ {
+ return false;
+ }
+
+ public function getDebugInfo()
+ {
+ return array ();
+ }
+}
+EOF
+ , $twig);
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/PrintTest.php b/lib/twig/test/Twig/Tests/Node/PrintTest.php
new file mode 100755
index 0000000..168663c
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/PrintTest.php
@@ -0,0 +1,43 @@
+assertEquals($expr, $node->getNode('expr'));
+ }
+
+ /**
+ * @covers Twig_Node_Print::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+ $tests[] = array(new Twig_Node_Print(new Twig_Node_Expression_Constant('foo', 0), 0), 'echo "foo";');
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/SandboxTest.php b/lib/twig/test/Twig/Tests/Node/SandboxTest.php
new file mode 100755
index 0000000..1610873
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/SandboxTest.php
@@ -0,0 +1,57 @@
+assertEquals($body, $node->getNode('body'));
+ }
+
+ /**
+ * @covers Twig_Node_Sandbox::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $body = new Twig_Node_Text('foo', 0);
+ $node = new Twig_Node_Sandbox($body, 0);
+
+ $tests[] = array($node, <<env->getExtension('sandbox');
+if (!\$alreadySandboxed = \$sandbox->isSandboxed()) {
+ \$sandbox->enableSandbox();
+}
+echo "foo";
+if (!\$alreadySandboxed) {
+ \$sandbox->disableSandbox();
+}
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/SandboxedModuleTest.php b/lib/twig/test/Twig/Tests/Node/SandboxedModuleTest.php
new file mode 100755
index 0000000..f86442b
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/SandboxedModuleTest.php
@@ -0,0 +1,152 @@
+assertEquals($body, $node->getNode('body'));
+ $this->assertEquals($blocks, $node->getNode('blocks'));
+ $this->assertEquals($macros, $node->getNode('macros'));
+ $this->assertEquals($parent, $node->getNode('parent'));
+ $this->assertEquals($filename, $node->getAttribute('filename'));
+ }
+
+ /**
+ * @covers Twig_Node_SandboxedModule::compile
+ * @covers Twig_Node_SandboxedModule::compileDisplayBody
+ * @covers Twig_Node_SandboxedModule::compileDisplayFooter
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $twig = new Twig_Environment(new Twig_Loader_String());
+
+ $tests = array();
+
+ $body = new Twig_Node_Text('foo', 0);
+ $extends = null;
+ $blocks = new Twig_Node();
+ $macros = new Twig_Node();
+ $traits = new Twig_Node();
+ $filename = 'foo.twig';
+
+ $node = new Twig_Node_Module($body, $extends, $blocks, $macros, $traits, $filename);
+ $node = new Twig_Node_SandboxedModule($node, array('for'), array('upper'), array('cycle'));
+
+ $tests[] = array($node, <<checkSecurity();
+ echo "foo";
+ }
+
+ protected function checkSecurity() {
+ \$this->env->getExtension('sandbox')->checkSecurity(
+ array('upper'),
+ array('for'),
+ array('cycle')
+ );
+ }
+
+ public function getTemplateName()
+ {
+ return "foo.twig";
+ }
+
+ public function getDebugInfo()
+ {
+ return array ();
+ }
+}
+EOF
+ , $twig);
+
+ $body = new Twig_Node();
+ $extends = new Twig_Node_Expression_Constant('layout.twig', 0);
+ $blocks = new Twig_Node();
+ $macros = new Twig_Node();
+ $traits = new Twig_Node();
+ $filename = 'foo.twig';
+
+ $node = new Twig_Node_Module($body, $extends, $blocks, $macros, $traits, $filename);
+ $node = new Twig_Node_SandboxedModule($node, array('for'), array('upper'), array('cycle'));
+
+ $tests[] = array($node, <<checkSecurity();
+ \$this->parent->display(\$context, array_merge(\$this->blocks, \$blocks));
+ }
+
+ protected function checkSecurity() {
+ \$this->env->getExtension('sandbox')->checkSecurity(
+ array('upper'),
+ array('for'),
+ array('cycle')
+ );
+ }
+
+ public function getTemplateName()
+ {
+ return "foo.twig";
+ }
+
+ public function isTraitable()
+ {
+ return false;
+ }
+
+ public function getDebugInfo()
+ {
+ return array ();
+ }
+}
+EOF
+ , $twig);
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/SandboxedPrintTest.php b/lib/twig/test/Twig/Tests/Node/SandboxedPrintTest.php
new file mode 100755
index 0000000..85adddf
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/SandboxedPrintTest.php
@@ -0,0 +1,46 @@
+assertEquals($expr, $node->getNode('expr'));
+ }
+
+ /**
+ * @covers Twig_Node_SandboxedPrint::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $tests[] = array(new Twig_Node_SandboxedPrint(new Twig_Node_Expression_Constant('foo', 0), 0), <<env->getExtension('sandbox')->ensureToStringAllowed("foo");
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/SetTest.php b/lib/twig/test/Twig/Tests/Node/SetTest.php
new file mode 100755
index 0000000..6319fb6
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/SetTest.php
@@ -0,0 +1,73 @@
+assertEquals($names, $node->getNode('names'));
+ $this->assertEquals($values, $node->getNode('values'));
+ $this->assertEquals(false, $node->getAttribute('capture'));
+ }
+
+ /**
+ * @covers Twig_Node_Set::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+
+ $names = new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 0)), array(), 0);
+ $values = new Twig_Node(array(new Twig_Node_Expression_Constant('foo', 0)), array(), 0);
+ $node = new Twig_Node_Set(false, $names, $values, 0);
+ $tests[] = array($node, '$context["foo"] = "foo";');
+
+ $names = new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 0)), array(), 0);
+ $values = new Twig_Node(array(new Twig_Node_Print(new Twig_Node_Expression_Constant('foo', 0), 0)), array(), 0);
+ $node = new Twig_Node_Set(true, $names, $values, 0);
+ $tests[] = array($node, <<env->getCharset());
+EOF
+ );
+
+ $names = new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 0)), array(), 0);
+ $values = new Twig_Node_Text('foo', 0);
+ $node = new Twig_Node_Set(true, $names, $values, 0);
+ $tests[] = array($node, '$context["foo"] = (\'\' === $tmp = "foo") ? \'\' : new Twig_Markup($tmp, $this->env->getCharset());');
+
+ $names = new Twig_Node(array(new Twig_Node_Expression_AssignName('foo', 0), new Twig_Node_Expression_AssignName('bar', 0)), array(), 0);
+ $values = new Twig_Node(array(new Twig_Node_Expression_Constant('foo', 0), new Twig_Node_Expression_Name('bar', 0)), array(), 0);
+ $node = new Twig_Node_Set(false, $names, $values, 0);
+ $tests[] = array($node, <<getVariableGetter('bar')});
+EOF
+ );
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/SpacelessTest.php b/lib/twig/test/Twig/Tests/Node/SpacelessTest.php
new file mode 100755
index 0000000..55892f4
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/SpacelessTest.php
@@ -0,0 +1,50 @@
+ foo
', 0)));
+ $node = new Twig_Node_Spaceless($body, 0);
+
+ $this->assertEquals($body, $node->getNode('body'));
+ }
+
+ /**
+ * @covers Twig_Node_Spaceless::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $body = new Twig_Node(array(new Twig_Node_Text('', 0)));
+ $node = new Twig_Node_Spaceless($body, 0);
+
+ return array(
+ array($node, << foo
";
+echo trim(preg_replace('/>\s+', '><', ob_get_clean()));
+EOF
+ ),
+ );
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/TestCase.php b/lib/twig/test/Twig/Tests/Node/TestCase.php
new file mode 100755
index 0000000..f142529
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/TestCase.php
@@ -0,0 +1,58 @@
+assertNodeCompilation($source, $node, $environment);
+ }
+
+ public function assertNodeCompilation($source, Twig_Node $node, Twig_Environment $environment = null)
+ {
+ $compiler = $this->getCompiler($environment);
+ $compiler->compile($node);
+
+ $this->assertEquals($source, trim($compiler->getSource()));
+ }
+
+ protected function getCompiler(Twig_Environment $environment = null)
+ {
+ return new Twig_Compiler(null === $environment ? $this->getEnvironment() : $environment);
+ }
+
+ protected function getEnvironment()
+ {
+ return new Twig_Environment();
+ }
+
+ protected function getVariableGetter($name)
+ {
+ if (version_compare(phpversion(), '5.4.0RC1', '>=')) {
+ return sprintf('(isset($context["%s"]) ? $context["%s"] : null)', $name, $name);
+ }
+
+ return sprintf('$this->getContext($context, "%s")', $name);
+ }
+
+ protected function getAttributeGetter()
+ {
+ if (function_exists('twig_template_get_attributes')) {
+ return 'twig_template_get_attributes($this, ';
+ }
+
+ return '$this->getAttribute(';
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/Node/TextTest.php b/lib/twig/test/Twig/Tests/Node/TextTest.php
new file mode 100755
index 0000000..87e0337
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/Node/TextTest.php
@@ -0,0 +1,42 @@
+assertEquals('foo', $node->getAttribute('data'));
+ }
+
+ /**
+ * @covers Twig_Node_Text::compile
+ * @dataProvider getTests
+ */
+ public function testCompile($node, $source, $environment = null)
+ {
+ parent::testCompile($node, $source, $environment);
+ }
+
+ public function getTests()
+ {
+ $tests = array();
+ $tests[] = array(new Twig_Node_Text('foo', 0), 'echo "foo";');
+
+ return $tests;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/NodeVisitor/OptimizerTest.php b/lib/twig/test/Twig/Tests/NodeVisitor/OptimizerTest.php
new file mode 100755
index 0000000..a55d98e
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/NodeVisitor/OptimizerTest.php
@@ -0,0 +1,118 @@
+ false, 'autoescape' => false));
+ $env->addExtension(new Twig_Extension_Optimizer());
+
+ $stream = $env->parse($env->tokenize('{{ block("foo") }}', 'index'));
+
+ $node = $stream->getNode('body')->getNode(0);
+
+ $this->assertEquals('Twig_Node_Expression_BlockReference', get_class($node));
+ $this->assertTrue($node->getAttribute('output'));
+ }
+
+ public function testRenderParentBlockOptimizer()
+ {
+ $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false, 'autoescape' => false));
+ $env->addExtension(new Twig_Extension_Optimizer());
+
+ $stream = $env->parse($env->tokenize('{% extends "foo" %}{% block content %}{{ parent() }}{% endblock %}', 'index'));
+
+ $node = $stream->getNode('blocks')->getNode('content')->getNode(0)->getNode('body');
+
+ $this->assertEquals('Twig_Node_Expression_Parent', get_class($node));
+ $this->assertTrue($node->getAttribute('output'));
+ }
+
+ public function testRenderVariableBlockOptimizer()
+ {
+ if (version_compare(phpversion(), '5.4.0RC1', '>=')) {
+ return;
+ }
+
+ $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false, 'autoescape' => false));
+ $env->addExtension(new Twig_Extension_Optimizer());
+ $stream = $env->parse($env->tokenize('{{ block(name|lower) }}', 'index'));
+
+ $node = $stream->getNode('body')->getNode(0)->getNode(1);
+
+ $this->assertEquals('Twig_Node_Expression_BlockReference', get_class($node));
+ $this->assertTrue($node->getAttribute('output'));
+ }
+
+ /**
+ * @dataProvider getTestsForForOptimizer
+ */
+ public function testForOptimizer($template, $expected)
+ {
+ $env = new Twig_Environment(new Twig_Loader_String(), array('cache' => false));
+ $env->addExtension(new Twig_Extension_Optimizer());
+
+ $stream = $env->parse($env->tokenize($template, 'index'));
+
+ foreach ($expected as $target => $withLoop) {
+ $this->assertTrue($this->checkForConfiguration($stream, $target, $withLoop), sprintf('variable %s is %soptimized', $target, $withLoop ? 'not ' : ''));
+ }
+ }
+
+ public function getTestsForForOptimizer()
+ {
+ return array(
+ array('{% for i in foo %}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{{ loop.index }}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{% for j in foo %}{% endfor %}{% endfor %}', array('i' => false, 'j' => false)),
+
+ array('{% for i in foo %}{% include "foo" %}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{% include "foo" only %}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{% include "foo" with { "foo": "bar" } only %}{% endfor %}', array('i' => false)),
+
+ array('{% for i in foo %}{% include "foo" with { "foo": loop.index } only %}{% endfor %}', array('i' => true)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ loop.index }}{% endfor %}{% endfor %}', array('i' => false, 'j' => true)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ loop.parent.loop.index }}{% endfor %}{% endfor %}', array('i' => true, 'j' => true)),
+
+ array('{% for i in foo %}{% set l = loop %}{% for j in foo %}{{ l.index }}{% endfor %}{% endfor %}', array('i' => true, 'j' => false)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ foo.parent.loop.index }}{% endfor %}{% endfor %}', array('i' => false, 'j' => false)),
+
+ array('{% for i in foo %}{% for j in foo %}{{ loop["parent"].loop.index }}{% endfor %}{% endfor %}', array('i' => true, 'j' => true)),
+ );
+ }
+
+ public function checkForConfiguration(Twig_NodeInterface $node = null, $target, $withLoop)
+ {
+ if (null === $node) {
+ return;
+ }
+
+ foreach ($node as $n) {
+ if ($n instanceof Twig_Node_For) {
+ if ($target === $n->getNode('value_target')->getAttribute('name')) {
+ return $withLoop == $n->getAttribute('with_loop');
+ }
+ }
+
+ $ret = $this->checkForConfiguration($n, $target, $withLoop);
+ if (null !== $ret) {
+ return $ret;
+ }
+ }
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/ParserTest.php b/lib/twig/test/Twig/Tests/ParserTest.php
new file mode 100755
index 0000000..76f257a
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/ParserTest.php
@@ -0,0 +1,160 @@
+setMacro('display', $this->getMock('Twig_Node_Macro', array(), array(), '', null));
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage Unknown tag name "foo". Did you mean "for" at line 0
+ */
+ public function testUnkownTag()
+ {
+ $stream = new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, '', 0),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'foo', 0),
+ new Twig_Token(Twig_Token::BLOCK_END_TYPE, '', 0),
+ new Twig_Token(Twig_Token::EOF_TYPE, '', 0),
+ ));
+ $parser = new Twig_Parser(new Twig_Environment());
+ $parser->parse($stream);
+ }
+
+ /**
+ * @dataProvider getFilterBodyNodesData
+ */
+ public function testFilterBodyNodes($input, $expected)
+ {
+ $parser = $this->getParserForFilterBodyNodes();
+
+ $this->assertEquals($expected, $parser->filterBodyNodes($input));
+ }
+
+ public function getFilterBodyNodesData()
+ {
+ return array(
+ array(
+ new Twig_Node(array(new Twig_Node_Text(' ', 0))),
+ new Twig_Node(array()),
+ ),
+ array(
+ $input = new Twig_Node(array(new Twig_Node_Set(false, new Twig_Node(), new Twig_Node(), 0))),
+ $input,
+ ),
+ array(
+ $input = new Twig_Node(array(new Twig_Node_Set(true, new Twig_Node(), new Twig_Node(array(new Twig_Node(array(new Twig_Node_Text('foo', 0))))), 0))),
+ $input,
+ ),
+ );
+ }
+
+ /**
+ * @dataProvider getFilterBodyNodesDataThrowsException
+ * @expectedException Twig_Error_Syntax
+ */
+ public function testFilterBodyNodesThrowsException($input)
+ {
+ $parser = $this->getParserForFilterBodyNodes();
+
+ $parser->filterBodyNodes($input);
+ }
+
+ public function getFilterBodyNodesDataThrowsException()
+ {
+ return array(
+ array(new Twig_Node_Text('foo', 0)),
+ array(new Twig_Node(array(new Twig_Node(array(new Twig_Node_Text('foo', 0)))))),
+ );
+ }
+
+ /**
+ * @expectedException Twig_Error_Syntax
+ * @expectedExceptionMessage A template that extends another one cannot have a body but a byte order mark (BOM) has been detected; it must be removed at line 0.
+ */
+ public function testFilterBodyNodesWithBOM()
+ {
+ $parser = $this->getParserForFilterBodyNodes();
+ $parser->filterBodyNodes(new Twig_Node_Text(chr(0xEF).chr(0xBB).chr(0xBF), 0));
+ }
+
+ public function testParseIsReentrant()
+ {
+ $twig = new Twig_Environment(null, array(
+ 'autoescape' => false,
+ 'optimizations' => 0,
+ ));
+ $twig->addTokenParser(new TestTokenParser());
+
+ $parser = new Twig_Parser($twig);
+
+ $parser->parse(new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, '', 0),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'test', 0),
+ new Twig_Token(Twig_Token::BLOCK_END_TYPE, '', 0),
+ new Twig_Token(Twig_Token::VAR_START_TYPE, '', 0),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'foo', 0),
+ new Twig_Token(Twig_Token::VAR_END_TYPE, '', 0),
+ new Twig_Token(Twig_Token::EOF_TYPE, '', 0),
+ )));
+
+ $this->assertEquals(null, $parser->getParent());
+ }
+
+ protected function getParserForFilterBodyNodes()
+ {
+ $parser = new TestParser(new Twig_Environment());
+ $parser->setParent(new Twig_Node());
+ $parser->stream = $this->getMockBuilder('Twig_TokenStream')->disableOriginalConstructor()->getMock();
+
+ return $parser;
+ }
+}
+
+class TestParser extends Twig_Parser
+{
+ public $stream;
+
+ public function filterBodyNodes(Twig_NodeInterface $node)
+ {
+ return parent::filterBodyNodes($node);
+ }
+}
+
+class TestTokenParser extends Twig_TokenParser
+{
+ public function parse(Twig_Token $token)
+ {
+ // simulate the parsing of another template right in the middle of the parsing of the current template
+ $this->parser->parse(new Twig_TokenStream(array(
+ new Twig_Token(Twig_Token::BLOCK_START_TYPE, '', 0),
+ new Twig_Token(Twig_Token::NAME_TYPE, 'extends', 0),
+ new Twig_Token(Twig_Token::STRING_TYPE, 'base', 0),
+ new Twig_Token(Twig_Token::BLOCK_END_TYPE, '', 0),
+ new Twig_Token(Twig_Token::EOF_TYPE, '', 0),
+ )));
+
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node(array());
+ }
+
+ public function getTag()
+ {
+ return 'test';
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/TemplateTest.php b/lib/twig/test/Twig/Tests/TemplateTest.php
new file mode 100755
index 0000000..a4e658f
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/TemplateTest.php
@@ -0,0 +1,363 @@
+assertEquals($value, $template->getAttribute($object, $item, $arguments, $type));
+ }
+
+ /**
+ * @dataProvider getGetAttributeTests
+ */
+ public function testGetAttributeStrict($defined, $value, $object, $item, $arguments, $type, $useExt = false, $exceptionMessage = null)
+ {
+ $template = new Twig_TemplateTest(
+ new Twig_Environment(null, array('strict_variables' => true)),
+ $useExt
+ );
+
+ if ($defined) {
+ $this->assertEquals($value, $template->getAttribute($object, $item, $arguments, $type));
+ } else {
+ try {
+ $this->assertEquals($value, $template->getAttribute($object, $item, $arguments, $type));
+
+ throw new Exception('Expected Twig_Error_Runtime exception.');
+ } catch (Twig_Error_Runtime $e) {
+ if (null !== $exceptionMessage) {
+ $this->assertSame($exceptionMessage, $e->getMessage());
+ }
+ }
+ }
+ }
+
+ /**
+ * @dataProvider getGetAttributeTests
+ */
+ public function testGetAttributeDefined($defined, $value, $object, $item, $arguments, $type, $useExt = false)
+ {
+ $template = new Twig_TemplateTest(
+ new Twig_Environment(),
+ $useExt
+ );
+
+ $this->assertEquals($defined, $template->getAttribute($object, $item, $arguments, $type, true));
+ }
+
+ /**
+ * @dataProvider getGetAttributeTests
+ */
+ public function testGetAttributeDefinedStrict($defined, $value, $object, $item, $arguments, $type, $useExt = false)
+ {
+ $template = new Twig_TemplateTest(
+ new Twig_Environment(null, array('strict_variables' => true)),
+ $useExt
+ );
+
+ $this->assertEquals($defined, $template->getAttribute($object, $item, $arguments, $type, true));
+ }
+
+ public function getGetAttributeTests()
+ {
+ $array = array(
+ 'defined' => 'defined',
+ 'zero' => 0,
+ 'null' => null,
+ '1' => 1,
+ );
+
+ $objectArray = new Twig_TemplateArrayAccessObject();
+ $stdObject = (object) $array;
+ $magicPropertyObject = new Twig_TemplateMagicPropertyObject();
+ $propertyObject = new Twig_TemplatePropertyObject();
+ $propertyObject1 = new Twig_TemplatePropertyObjectAndIterator();
+ $methodObject = new Twig_TemplateMethodObject();
+ $magicMethodObject = new Twig_TemplateMagicMethodObject();
+
+ $anyType = Twig_TemplateInterface::ANY_CALL;
+ $methodType = Twig_TemplateInterface::METHOD_CALL;
+ $arrayType = Twig_TemplateInterface::ARRAY_CALL;
+
+ $basicTests = array(
+ // array(defined, value, property to fetch)
+ array(true, 'defined', 'defined'),
+ array(false, null, 'undefined'),
+ array(false, null, 'protected'),
+ array(true, 0, 'zero'),
+ array(true, 1, 1),
+ array(true, 1, 1.0),
+ array(true, null, 'null'),
+ );
+ $testObjects = array(
+ // array(object, type of fetch)
+ array($array, $arrayType),
+ array($objectArray, $arrayType),
+ array($stdObject, $anyType),
+ array($magicPropertyObject, $anyType),
+ array($methodObject, $methodType),
+ array($methodObject, $anyType),
+ array($propertyObject, $anyType),
+ array($propertyObject1, $anyType),
+ );
+
+ $tests = array();
+ foreach ($testObjects as $testObject) {
+ foreach ($basicTests as $test) {
+ // properties cannot be numbers
+ if (($testObject[0] instanceof stdClass || $testObject[0] instanceof Twig_TemplatePropertyObject) && is_numeric($test[2])) {
+ continue;
+ }
+
+ $tests[] = array($test[0], $test[1], $testObject[0], $test[2], array(), $testObject[1]);
+ }
+ }
+
+ // additional method tests
+ $tests = array_merge($tests, array(
+ array(true, 'defined', $methodObject, 'defined', array(), $methodType),
+ array(true, 'defined', $methodObject, 'DEFINED', array(), $methodType),
+ array(true, 'defined', $methodObject, 'getDefined', array(), $methodType),
+ array(true, 'defined', $methodObject, 'GETDEFINED', array(), $methodType),
+ array(true, 'static', $methodObject, 'static', array(), $methodType),
+ array(true, 'static', $methodObject, 'getStatic', array(), $methodType),
+
+ array(true, '__call_undefined', $magicMethodObject, 'undefined', array(), $methodType),
+ array(true, '__call_UNDEFINED', $magicMethodObject, 'UNDEFINED', array(), $methodType),
+ ));
+
+ // add the same tests for the any type
+ foreach ($tests as $test) {
+ if ($anyType !== $test[5]) {
+ $test[5] = $anyType;
+ $tests[] = $test;
+ }
+ }
+
+ $methodAndPropObject = new Twig_TemplateMethodAndPropObject;
+
+ // additional method tests
+ $tests = array_merge($tests, array(
+ array(true, 'a', $methodAndPropObject, 'a', array(), $anyType),
+ array(true, 'a', $methodAndPropObject, 'a', array(), $methodType),
+ array(false, null, $methodAndPropObject, 'a', array(), $arrayType),
+
+ array(true, 'b_prop', $methodAndPropObject, 'b', array(), $anyType),
+ array(true, 'b', $methodAndPropObject, 'B', array(), $anyType),
+ array(true, 'b', $methodAndPropObject, 'b', array(), $methodType),
+ array(true, 'b', $methodAndPropObject, 'B', array(), $methodType),
+ array(false, null, $methodAndPropObject, 'b', array(), $arrayType),
+
+ array(false, null, $methodAndPropObject, 'c', array(), $anyType),
+ array(false, null, $methodAndPropObject, 'c', array(), $methodType),
+ array(false, null, $methodAndPropObject, 'c', array(), $arrayType),
+
+ ));
+
+ // tests when input is not an array or object
+ $tests = array_merge($tests, array(
+ array(false, null, 42, 'a', array(), $anyType, false, 'Item "a" for "42" does not exist'),
+ array(false, null, "string", 'a', array(), $anyType, false, 'Item "a" for "string" does not exist'),
+ array(false, null, array(), 'a', array(), $anyType, false, 'Item "a" for "Array" does not exist'),
+ ));
+
+ // add twig_template_get_attributes tests
+
+ if (function_exists('twig_template_get_attributes')) {
+ foreach(array_slice($tests, 0) as $test) {
+ $test = array_pad($test, 7, null);
+ $test[6] = true;
+ $tests[] = $test;
+ }
+ }
+
+ return $tests;
+ }
+
+ public function useExtGetAttribute()
+ {
+ return false;
+ }
+}
+
+class Twig_TemplateTest extends Twig_Template
+{
+ protected $useExtGetAttribute = false;
+
+ public function __construct(Twig_Environment $env, $useExtGetAttribute = false)
+ {
+ parent::__construct($env);
+ $this->useExtGetAttribute = $useExtGetAttribute;
+ Twig_Template::clearCache();
+ }
+
+ public function getTemplateName()
+ {
+ }
+
+ public function getDebugInfo()
+ {
+ return array();
+ }
+
+ protected function doGetParent(array $context)
+ {
+ }
+
+ protected function doDisplay(array $context, array $blocks = array())
+ {
+ }
+
+ public function getAttribute($object, $item, array $arguments = array(), $type = Twig_TemplateInterface::ANY_CALL, $isDefinedTest = false, $ignoreStrictCheck = false)
+ {
+ if ($this->useExtGetAttribute) {
+ return twig_template_get_attributes($this, $object, $item, $arguments, $type, $isDefinedTest, $ignoreStrictCheck);
+ } else {
+ return parent::getAttribute($object, $item, $arguments, $type, $isDefinedTest, $ignoreStrictCheck);
+ }
+ }
+}
+
+class Twig_TemplateArrayAccessObject implements ArrayAccess
+{
+ protected $protected = 'protected';
+
+ public $attributes = array(
+ 'defined' => 'defined',
+ 'zero' => 0,
+ 'null' => null,
+ '1' => 1,
+ );
+
+ public function offsetExists($name)
+ {
+ return array_key_exists($name, $this->attributes);
+ }
+
+ public function offsetGet($name)
+ {
+ return array_key_exists($name, $this->attributes) ? $this->attributes[$name] : null;
+ }
+
+ public function offsetSet($name, $value)
+ {
+ }
+
+ public function offsetUnset($name)
+ {
+ }
+}
+
+class Twig_TemplateMagicPropertyObject
+{
+ public $defined = 'defined';
+
+ public $attributes = array(
+ 'zero' => 0,
+ 'null' => null,
+ '1' => 1,
+ );
+
+ protected $protected = 'protected';
+
+ public function __isset($name)
+ {
+ return array_key_exists($name, $this->attributes);
+ }
+
+ public function __get($name)
+ {
+ return array_key_exists($name, $this->attributes) ? $this->attributes[$name] : null;
+ }
+}
+
+class Twig_TemplatePropertyObject
+{
+ public $defined = 'defined';
+ public $zero = 0;
+ public $null = null;
+
+ protected $protected = 'protected';
+}
+
+class Twig_TemplatePropertyObjectAndIterator extends Twig_TemplatePropertyObject implements IteratorAggregate
+{
+ public function getIterator()
+ {
+ return new ArrayIterator(array('foo', 'bar'));
+ }
+}
+
+class Twig_TemplateMethodObject
+{
+ public function getDefined()
+ {
+ return 'defined';
+ }
+
+ public function get1()
+ {
+ return 1;
+ }
+
+ public function getZero()
+ {
+ return 0;
+ }
+
+ public function getNull()
+ {
+ return null;
+ }
+
+ protected function getProtected()
+ {
+ return 'protected';
+ }
+
+ static public function getStatic()
+ {
+ return 'static';
+ }
+}
+
+class Twig_TemplateMethodAndPropObject
+{
+ private $a = 'a_prop';
+ public function getA() {
+ return 'a';
+ }
+
+ public $b = 'b_prop';
+ public function getB() {
+ return 'b';
+ }
+
+ private $c = 'c_prop';
+ private function getC() {
+ return 'c';
+ }
+}
+
+class Twig_TemplateMagicMethodObject
+{
+ public function __call($method, $arguments) {
+ return '__call_'.$method;
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/TokenStreamTest.php b/lib/twig/test/Twig/Tests/TokenStreamTest.php
new file mode 100755
index 0000000..794a037
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/TokenStreamTest.php
@@ -0,0 +1,41 @@
+isEOF()) {
+ $token = $stream->next();
+
+ $repr[] = $token->getValue();
+ }
+ $this->assertEquals('1, 2, 3, 4, 5, 6, 7', implode(', ', $repr), '->next() advances the pointer and returns the current token');
+ }
+}
diff --git a/lib/twig/test/Twig/Tests/integrationTest.php b/lib/twig/test/Twig/Tests/integrationTest.php
new file mode 100755
index 0000000..2045097
--- /dev/null
+++ b/lib/twig/test/Twig/Tests/integrationTest.php
@@ -0,0 +1,294 @@
+getRealpath());
+
+ if (preg_match('/
+ --TEST--\s*(.*?)\s*(?:--CONDITION--\s*(.*))?\s*((?:--TEMPLATE(?:\(.*?\))?--(?:.*))+)\s*--EXCEPTION--\s*(.*)/sx', $test, $match)) {
+ $message = $match[1];
+ $condition = $match[2];
+ $templates = $this->parseTemplates($match[3]);
+ $exception = $match[4];
+ $outputs = array();
+ } elseif (preg_match('/--TEST--\s*(.*?)\s*(?:--CONDITION--\s*(.*))?\s*((?:--TEMPLATE(?:\(.*?\))?--(?:.*?))+)--DATA--.*?--EXPECT--.*/s', $test, $match)) {
+ $message = $match[1];
+ $condition = $match[2];
+ $templates = $this->parseTemplates($match[3]);
+ $exception = false;
+ preg_match_all('/--DATA--(.*?)(?:--CONFIG--(.*?))?--EXPECT--(.*?)(?=\-\-DATA\-\-|$)/s', $test, $outputs, PREG_SET_ORDER);
+ } else {
+ throw new InvalidArgumentException(sprintf('Test "%s" is not valid.', str_replace($fixturesDir.'/', '', $file)));
+ }
+
+ $tests[] = array(str_replace($fixturesDir.'/', '', $file), $message, $condition, $templates, $exception, $outputs);
+ }
+
+ return $tests;
+ }
+
+ /**
+ * @dataProvider getTests
+ */
+ public function testIntegration($file, $message, $condition, $templates, $exception, $outputs)
+ {
+ if ($condition) {
+ eval('$ret = '.$condition.';');
+ if (!$ret) {
+ $this->markTestSkipped($condition);
+ }
+ }
+
+ $loader = new Twig_Loader_Array($templates);
+
+ foreach ($outputs as $match) {
+ $config = array_merge(array(
+ 'cache' => false,
+ 'strict_variables' => true,
+ ), $match[2] ? eval($match[2].';') : array());
+ $twig = new Twig_Environment($loader, $config);
+ $twig->addExtension(new TestExtension());
+ $twig->addExtension(new Twig_Extension_Debug());
+
+ try {
+ $template = $twig->loadTemplate('index.twig');
+ } catch (Exception $e) {
+ if (false !== $exception) {
+ $this->assertEquals(trim($exception), trim(sprintf('%s: %s', get_class($e), $e->getMessage())));
+
+ return;
+ }
+
+ if ($e instanceof Twig_Error_Syntax) {
+ $e->setTemplateFile($file);
+
+ throw $e;
+ }
+
+ throw new Twig_Error($e->getMessage().' (in '.$file.')');
+ }
+
+ try {
+ $output = trim($template->render(eval($match[1].';')), "\n ");
+ } catch (Exception $e) {
+ $output = trim(sprintf('%s: %s', get_class($e), $e->getMessage()));
+ }
+ $expected = trim($match[3], "\n ");
+
+ if ($expected != $output) {
+ echo 'Compiled template that failed:';
+
+ foreach (array_keys($templates) as $name) {
+ echo "Template: $name\n";
+ $source = $loader->getSource($name);
+ echo $twig->compile($twig->parse($twig->tokenize($source, $name)));
+ }
+ }
+ $this->assertEquals($expected, $output, $message.' (in '.$file.')');
+ }
+ }
+
+ protected function parseTemplates($test)
+ {
+ $templates = array();
+ preg_match_all('/--TEMPLATE(?:\((.*?)\))?--(.*?)(?=\-\-TEMPLATE|$)/s', $test, $matches, PREG_SET_ORDER);
+ foreach ($matches as $match) {
+ $templates[($match[1] ? $match[1] : 'index.twig')] = $match[2];
+ }
+
+ return $templates;
+ }
+}
+
+function test_foo($value = 'foo')
+{
+ return $value;
+}
+
+class Foo implements Iterator
+{
+ const BAR_NAME = 'bar';
+
+ public $position = 0;
+ public $array = array(1, 2);
+
+ public function bar($param1 = null, $param2 = null)
+ {
+ return 'bar'.($param1 ? '_'.$param1 : '').($param2 ? '-'.$param2 : '');
+ }
+
+ public function getFoo()
+ {
+ return 'foo';
+ }
+
+ public function getSelf()
+ {
+ return $this;
+ }
+
+ public function is()
+ {
+ return 'is';
+ }
+
+ public function in()
+ {
+ return 'in';
+ }
+
+ public function not()
+ {
+ return 'not';
+ }
+
+ public function strToLower($value)
+ {
+ return strtolower($value);
+ }
+
+ public function rewind()
+ {
+ $this->position = 0;
+ }
+
+ public function current()
+ {
+ return $this->array[$this->position];
+ }
+
+ public function key()
+ {
+ return 'a';
+ }
+
+ public function next()
+ {
+ ++$this->position;
+ }
+
+ public function valid()
+ {
+ return isset($this->array[$this->position]);
+ }
+}
+
+class TestTokenParser_☃ extends Twig_TokenParser
+{
+ public function parse(Twig_Token $token)
+ {
+ $this->parser->getStream()->expect(Twig_Token::BLOCK_END_TYPE);
+
+ return new Twig_Node_Print(new Twig_Node_Expression_Constant('☃', -1), -1);
+ }
+
+ public function getTag()
+ {
+ return '☃';
+ }
+}
+
+class TestExtension extends Twig_Extension
+{
+ public function getTokenParsers()
+ {
+ return array(
+ new TestTokenParser_☃(),
+ );
+ }
+
+ public function getFilters()
+ {
+ return array(
+ '☃' => new Twig_Filter_Method($this, '☃Filter'),
+ 'escape_and_nl2br' => new Twig_Filter_Method($this, 'escape_and_nl2br', array('needs_environment' => true, 'is_safe' => array('html'))),
+ 'nl2br' => new Twig_Filter_Method($this, 'nl2br', array('pre_escape' => 'html', 'is_safe' => array('html'))),
+ 'escape_something' => new Twig_Filter_Method($this, 'escape_something', array('is_safe' => array('something'))),
+ '*_path' => new Twig_Filter_Method($this, 'dynamic_path'),
+ '*_foo_*_bar' => new Twig_Filter_Method($this, 'dynamic_foo'),
+ );
+ }
+
+ public function getFunctions()
+ {
+ return array(
+ '☃' => new Twig_Function_Method($this, '☃Function'),
+ 'safe_br' => new Twig_Function_Method($this, 'br', array('is_safe' => array('html'))),
+ 'unsafe_br' => new Twig_Function_Method($this, 'br'),
+ '*_path' => new Twig_Function_Method($this, 'dynamic_path'),
+ '*_foo_*_bar' => new Twig_Function_Method($this, 'dynamic_foo'),
+ );
+ }
+
+ public function ☃Filter($value)
+ {
+ return "☃{$value}☃";
+ }
+
+ public function ☃Function($value)
+ {
+ return "☃{$value}☃";
+ }
+
+ /**
+ * nl2br which also escapes, for testing escaper filters
+ */
+ public function escape_and_nl2br($env, $value, $sep = ' ')
+ {
+ return $this->nl2br(twig_escape_filter($env, $value, 'html'), $sep);
+ }
+
+ /**
+ * nl2br only, for testing filters with pre_escape
+ */
+ public function nl2br($value, $sep = ' ')
+ {
+ // not secure if $value contains html tags (not only entities)
+ // don't use
+ return str_replace("\n", "$sep\n", $value);
+ }
+
+ public function dynamic_path($element, $item)
+ {
+ return $element.'/'.$item;
+ }
+
+ public function dynamic_foo($foo, $bar, $item)
+ {
+ return $foo.'/'.$bar.'/'.$item;
+ }
+
+ public function escape_something($value)
+ {
+ return strtoupper($value);
+ }
+
+ public function br()
+ {
+ return ' ';
+ }
+
+ public function getName()
+ {
+ return 'test';
+ }
+}
diff --git a/lib/twig/test/bootstrap.php b/lib/twig/test/bootstrap.php
new file mode 100755
index 0000000..36eb46a
--- /dev/null
+++ b/lib/twig/test/bootstrap.php
@@ -0,0 +1,13 @@
+"
+ ]
+ },
+ "find_state":
+ {
+ "case_sensitive": false,
+ "find_history":
+ [
+ "body",
+ "geor",
+ "zilla_post_type_labels",
+ "gallerys",
+ "portfolio",
+ ".post",
+ "webkit",
+ "input"
+ ],
+ "highlight": true,
+ "in_selection": false,
+ "preserve_case": false,
+ "regex": false,
+ "replace_history":
+ [
+ "galleries",
+ "gallery"
+ ],
+ "reverse": false,
+ "show_context": true,
+ "use_buffer2": true,
+ "whole_word": false,
+ "wrap": true
+ },
+ "groups":
+ [
+ {
+ "selected": 6,
+ "sheets":
+ [
+ {
+ "buffer": 0,
+ "file": "index.php",
+ "settings":
+ {
+ "buffer_size": 406,
+ "regions":
+ {
+ },
+ "selection":
+ [
+ [
+ 256,
+ 256
+ ]
+ ],
+ "settings":
+ {
+ "syntax": "Packages/HTML/HTML.tmLanguage"
+ },
+ "translation.x": 0.0,
+ "translation.y": 0.0,
+ "zoom_level": 1.0
+ },
+ "type": "text"
+ },
+ {
+ "buffer": 1,
+ "file": "config.php",
+ "settings":
+ {
+ "buffer_size": 436,
+ "regions":
+ {
+ },
+ "selection":
+ [
+ [
+ 432,
+ 432
+ ]
+ ],
+ "settings":
+ {
+ "syntax": "Packages/PHP/PHP.tmLanguage"
+ },
+ "translation.x": 0.0,
+ "translation.y": 0.0,
+ "zoom_level": 1.0
+ },
+ "type": "text"
+ },
+ {
+ "buffer": 2,
+ "file": "lib/pico.php",
+ "settings":
+ {
+ "buffer_size": 2945,
+ "regions":
+ {
+ },
+ "selection":
+ [
+ [
+ 1573,
+ 1573
+ ]
+ ],
+ "settings":
+ {
+ "syntax": "Packages/PHP/PHP.tmLanguage"
+ },
+ "translation.x": 0.0,
+ "translation.y": 0.0,
+ "zoom_level": 1.0
+ },
+ "type": "text"
+ },
+ {
+ "buffer": 3,
+ "file": "themes/default/index.html",
+ "settings":
+ {
+ "buffer_size": 777,
+ "regions":
+ {
+ },
+ "selection":
+ [
+ [
+ 339,
+ 339
+ ]
+ ],
+ "settings":
+ {
+ "syntax": "Packages/HTML/HTML.tmLanguage"
+ },
+ "translation.x": 0.0,
+ "translation.y": 0.0,
+ "zoom_level": 1.0
+ },
+ "type": "text"
+ },
+ {
+ "buffer": 4,
+ "file": "themes/default/style.css",
+ "settings":
+ {
+ "buffer_size": 2871,
+ "regions":
+ {
+ },
+ "selection":
+ [
+ [
+ 2348,
+ 2348
+ ]
+ ],
+ "settings":
+ {
+ "syntax": "Packages/CSS/CSS.tmLanguage"
+ },
+ "translation.x": 0.0,
+ "translation.y": 1406.0,
+ "zoom_level": 1.0
+ },
+ "type": "text"
+ },
+ {
+ "buffer": 5,
+ "file": "content/index.txt",
+ "settings":
+ {
+ "buffer_size": 179,
+ "regions":
+ {
+ },
+ "selection":
+ [
+ [
+ 87,
+ 87
+ ]
+ ],
+ "settings":
+ {
+ "syntax": "Packages/Text/Plain text.tmLanguage"
+ },
+ "translation.x": 0.0,
+ "translation.y": 0.0,
+ "zoom_level": 1.0
+ },
+ "type": "text"
+ },
+ {
+ "buffer": 6,
+ "file": "content/404.txt",
+ "settings":
+ {
+ "buffer_size": 112,
+ "regions":
+ {
+ },
+ "selection":
+ [
+ [
+ 48,
+ 48
+ ]
+ ],
+ "settings":
+ {
+ "syntax": "Packages/Text/Plain text.tmLanguage"
+ },
+ "translation.x": 0.0,
+ "translation.y": 0.0,
+ "zoom_level": 1.0
+ },
+ "type": "text"
+ }
+ ]
+ }
+ ],
+ "incremental_find":
+ {
+ "height": 0.0
+ },
+ "input":
+ {
+ "height": 31.0
+ },
+ "layout":
+ {
+ "cells":
+ [
+ [
+ 0,
+ 0,
+ 1,
+ 1
+ ]
+ ],
+ "cols":
+ [
+ 0.0,
+ 1.0
+ ],
+ "rows":
+ [
+ 0.0,
+ 1.0
+ ]
+ },
+ "menu_visible": true,
+ "replace":
+ {
+ "height": 64.0
+ },
+ "save_all_on_build": true,
+ "select_file":
+ {
+ "height": 0.0,
+ "selected_items":
+ [
+ ],
+ "width": 0.0
+ },
+ "select_project":
+ {
+ "height": 0.0,
+ "selected_items":
+ [
+ ],
+ "width": 0.0
+ },
+ "show_minimap": false,
+ "show_open_files": false,
+ "show_tabs": true,
+ "side_bar_visible": true,
+ "side_bar_width": 205.0,
+ "status_bar_visible": true
+}
diff --git a/themes/default/index.html b/themes/default/index.html
new file mode 100644
index 0000000..7669cb1
--- /dev/null
+++ b/themes/default/index.html
@@ -0,0 +1,23 @@
+
+
+
+
+
+ {% if meta.title %}{{ meta.title }} | {% endif %}{{ site_title }}
+ {% if meta.description %} {% endif %}
+ {% if meta.robots %} {% endif %}
+
+
+
+
+
+
+
+
+ {{ content }}
+
+
+
\ No newline at end of file
diff --git a/themes/default/scripts/modernizr-1.7.min.js b/themes/default/scripts/modernizr-1.7.min.js
new file mode 100644
index 0000000..6f54850
--- /dev/null
+++ b/themes/default/scripts/modernizr-1.7.min.js
@@ -0,0 +1,2 @@
+// Modernizr v1.7 www.modernizr.com
+window.Modernizr=function(a,b,c){function G(){e.input=function(a){for(var b=0,c=a.length;b7)},r.history=function(){return !!(a.history&&history.pushState)},r.draganddrop=function(){return x("dragstart")&&x("drop")},r.websockets=function(){return"WebSocket"in a},r.rgba=function(){A("background-color:rgba(150,255,150,.5)");return D(k.backgroundColor,"rgba")},r.hsla=function(){A("background-color:hsla(120,40%,100%,.5)");return D(k.backgroundColor,"rgba")||D(k.backgroundColor,"hsla")},r.multiplebgs=function(){A("background:url(//:),url(//:),red url(//:)");return(new RegExp("(url\\s*\\(.*?){3}")).test(k.background)},r.backgroundsize=function(){return F("backgroundSize")},r.borderimage=function(){return F("borderImage")},r.borderradius=function(){return F("borderRadius","",function(a){return D(a,"orderRadius")})},r.boxshadow=function(){return F("boxShadow")},r.textshadow=function(){return b.createElement("div").style.textShadow===""},r.opacity=function(){B("opacity:.55");return/^0.55$/.test(k.opacity)},r.cssanimations=function(){return F("animationName")},r.csscolumns=function(){return F("columnCount")},r.cssgradients=function(){var a="background-image:",b="gradient(linear,left top,right bottom,from(#9f9),to(white));",c="linear-gradient(left top,#9f9, white);";A((a+o.join(b+a)+o.join(c+a)).slice(0,-a.length));return D(k.backgroundImage,"gradient")},r.cssreflections=function(){return F("boxReflect")},r.csstransforms=function(){return!!E(["transformProperty","WebkitTransform","MozTransform","OTransform","msTransform"])},r.csstransforms3d=function(){var a=!!E(["perspectiveProperty","WebkitPerspective","MozPerspective","OPerspective","msPerspective"]);a&&"webkitPerspective"in g.style&&(a=w("@media ("+o.join("transform-3d),(")+"modernizr)"));return a},r.csstransitions=function(){return F("transitionProperty")},r.fontface=function(){var a,c,d=h||g,e=b.createElement("style"),f=b.implementation||{hasFeature:function(){return!1}};e.type="text/css",d.insertBefore(e,d.firstChild),a=e.sheet||e.styleSheet;var i=f.hasFeature("CSS2","")?function(b){if(!a||!b)return!1;var c=!1;try{a.insertRule(b,0),c=/src/i.test(a.cssRules[0].cssText),a.deleteRule(a.cssRules.length-1)}catch(d){}return c}:function(b){if(!a||!b)return!1;a.cssText=b;return a.cssText.length!==0&&/src/i.test(a.cssText)&&a.cssText.replace(/\r+|\n+/g,"").indexOf(b.split(" ")[0])===0};c=i('@font-face { font-family: "font"; src: url(data:,); }'),d.removeChild(e);return c},r.video=function(){var a=b.createElement("video"),c=!!a.canPlayType;if(c){c=new Boolean(c),c.ogg=a.canPlayType('video/ogg; codecs="theora"');var d='video/mp4; codecs="avc1.42E01E';c.h264=a.canPlayType(d+'"')||a.canPlayType(d+', mp4a.40.2"'),c.webm=a.canPlayType('video/webm; codecs="vp8, vorbis"')}return c},r.audio=function(){var a=b.createElement("audio"),c=!!a.canPlayType;c&&(c=new Boolean(c),c.ogg=a.canPlayType('audio/ogg; codecs="vorbis"'),c.mp3=a.canPlayType("audio/mpeg;"),c.wav=a.canPlayType('audio/wav; codecs="1"'),c.m4a=a.canPlayType("audio/x-m4a;")||a.canPlayType("audio/aac;"));return c},r.localstorage=function(){try{return!!localStorage.getItem}catch(a){return!1}},r.sessionstorage=function(){try{return!!sessionStorage.getItem}catch(a){return!1}},r.webWorkers=function(){return!!a.Worker},r.applicationcache=function(){return!!a.applicationCache},r.svg=function(){return!!b.createElementNS&&!!b.createElementNS(q.svg,"svg").createSVGRect},r.inlinesvg=function(){var a=b.createElement("div");a.innerHTML=" ";return(a.firstChild&&a.firstChild.namespaceURI)==q.svg},r.smil=function(){return!!b.createElementNS&&/SVG/.test(n.call(b.createElementNS(q.svg,"animate")))},r.svgclippaths=function(){return!!b.createElementNS&&/SVG/.test(n.call(b.createElementNS(q.svg,"clipPath")))};for(var H in r)z(r,H)&&(v=H.toLowerCase(),e[v]=r[H](),u.push((e[v]?"":"no-")+v));e.input||G(),e.crosswindowmessaging=e.postmessage,e.historymanagement=e.history,e.addTest=function(a,b){a=a.toLowerCase();if(!e[a]){b=!!b(),g.className+=" "+(b?"":"no-")+a,e[a]=b;return e}},A(""),j=l=null,f&&a.attachEvent&&function(){var a=b.createElement("div");a.innerHTML=" ";return a.childNodes.length!==1}()&&function(a,b){function p(a,b){var c=-1,d=a.length,e,f=[];while(++c