Ticket #7806: tplrf-r8970.diff

django/templatetags/i18n.py

@@ -1 +1 @@
-import re
-
-
-
-
+
+
-from django.utils import translation
-from django.utils.encoding import force_unicode
-
@@ -35 +34 @@
-
-class TranslateNode(Node):
-    def __init__(self, value, noop):
-Variable(value)
+value
-        self.noop = noop
-
-    def render(self, context):
@@ -141 +140 @@
-        raise TemplateSyntaxError, "'get_current_language_bidi' requires 'as variable' (got %r)" % args
-    return GetCurrentLanguageBidiNode(args[2])
-
-
+
+
+
-    """
-    This will mark a string for translation and will
-    translate the string for the current language.
@@ -171 +172 @@
-    the variable ``variable``. Make sure that the string
-    in there is something that is in the .po file.
-    """
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-    return TranslateNode(value, noop)
-
-def do_block_translate(parser, token):
@@ -255 +246 @@
-register.tag('get_available_languages', do_get_available_languages)
-register.tag('get_current_language', do_get_current_language)
-register.tag('get_current_language_bidi', do_get_current_language_bidi)
-do_translate
+uses_token_stream(do_translate)
-register.tag('blocktrans', do_block_translate)

django/templatetags/cache.py

@@ -1 @@
-, VariableDoesNotExist
- import resolve_variable
+DoesNotExist, TokenSyntaxError
+.compiler import uses_token_stream
-from django.core.cache import cache
-from django.utils.encoding import force_unicode
-from django.utils.http import urlquote
@@ -9 +9 @@
-class CacheNode(Node):
-    def __init__(self, nodelist, expire_time_var, fragment_name, vary_on):
-        self.nodelist = nodelist
-Variable(expire_time_var)
+expire_time_var
-        self.fragment_name = fragment_name
-        self.vary_on = vary_on
-
@@ -23 +23 @@
-        except (ValueError, TypeError):
-            raise TemplateSyntaxError('"cache" tag got a non-integer timeout value: %r' % expire_time)
-        # Build a unicode key for this fragment and all vary-on's.
-resolve_variable(var, 
+var.resolve_safe(
-        value = cache.get(cache_key)
-        if value is None:
-            value = self.nodelist.render(context)
-            cache.set(cache_key, value, expire_time)
-        return value
-
-token
+bits
-    """
-    This will cache the contents of a template fragment for a given amount
-    of time.
@@ -51 +51 @@
-
-    Each unique set of arguments will result in a unique cache entry.
-    """
-
-
-
-
-
-
+
+
+
+
+
+
+
-
-do_cache
+uses_token_stream(do_cache)

django/template/nodes.py

@@ +1 @@
+from django.utils.encoding import force_unicode
+from django.utils.safestring import SafeData, EscapeData, mark_safe, mark_for_escaping
+from django.utils.html import escape
+from django.template.expressions import LookupError
+from django.conf import settings
+
+class Node(object):
+    # Set this to True for nodes that must be first in the template (although
+    # they can be preceded by text nodes.
+    must_be_first = False
+
+    def render(self, context):
+        "Return the node rendered as a string"
+        pass
+        
+    def __repr__(self):
+        return "<%s>" % self.__class__.__name__
+
+    def __iter__(self):
+        yield self
+
+    def get_nodes_by_type(self, nodetype):
+        "Return a list of all nodes (within this node and its nodelist) of the given type"
+        nodes = []
+        if isinstance(self, nodetype):
+            nodes.append(self)
+        if hasattr(self, 'nodelist'):
+            nodes.extend(self.nodelist.get_nodes_by_type(nodetype))
+        return nodes
+
+class NodeList(list):
+    # Set to True the first time a non-TextNode is inserted by
+    # extend_nodelist().
+    contains_nontext = False
+
+    def render(self, context):
+        bits = []
+        for node in self:
+            if isinstance(node, Node):
+                bits.append(self.render_node(node, context))
+            else:
+                bits.append(node)
+        return mark_safe(''.join([force_unicode(b) for b in bits]))
+
+    def get_nodes_by_type(self, nodetype):
+        "Return a list of all nodes of the given type"
+        nodes = []
+        for node in self:
+            nodes.extend(node.get_nodes_by_type(nodetype))
+        return nodes
+
+    def render_node(self, node, context):
+        return node.render(context)
+
+class TextNode(Node):
+    def __init__(self, s):
+        self.s = s
+
+    def __repr__(self):
+        return "<Text Node: '%s'>" % self.s[:25]
+
+    def render(self, context):
+        return self.s
+
+class ExpressionNode(Node):
+    def __init__(self, expression):
+        self.expression = expression
+
+    def __repr__(self):
+        return "<Variable Node: %s>" % self.expression
+
+    def render(self, context):
+        try:
+            output = force_unicode(self.expression.resolve(context))
+        except LookupError:
+            if settings.TEMPLATE_STRING_IF_INVALID:
+                from django.template import invalid_var_format_string
+                if invalid_var_format_string is None:
+                    invalid_var_format_string = '%s' in settings.TEMPLATE_STRING_IF_INVALID
+                if invalid_var_format_string:
+                    return settings.TEMPLATE_STRING_IF_INVALID % self.expression
+                return settings.TEMPLATE_STRING_IF_INVALID
+            else:
+                return u''
+        except UnicodeDecodeError:
+            # Unicode conversion can fail sometimes for reasons out of our
+            # control (e.g. exception rendering). In that case, we fail quietly.
+            return u''        
+        if (context.autoescape and not isinstance(output, SafeData)) or isinstance(output, EscapeData):
+            output = escape(output)
+        return output

django/template/compiler.py

@@ +1 @@
+import re
+from inspect import getargspec
+from django.conf import settings
+from django.template.context import Context, RequestContext, ContextPopException
+from django.template.expressions import Expression, Literal, Lookup, FilterExpression
+from django.template.nodes import Node, NodeList, ExpressionNode, TextNode
+from django.utils.encoding import smart_unicode, smart_str
+from django.utils.functional import wraps
+from django.utils.safestring import mark_safe
+from django.utils.text import smart_split
+from django.utils.translation import ugettext
+
+__all__ = ('Template', 'TemplateSyntaxError', 'TokenSyntaxError', 'TokenStream')
+
+TOKEN_TEXT = 0
+TOKEN_VAR = 1
+TOKEN_BLOCK = 2
+TOKEN_COMMENT = 3
+
+# template syntax constants
+BLOCK_TAG_START = '{%'
+BLOCK_TAG_END = '%}'
+VARIABLE_TAG_START = '{{'
+VARIABLE_TAG_END = '}}'
+COMMENT_TAG_START = '{#'
+COMMENT_TAG_END = '#}'
+SINGLE_BRACE_START = '{'
+SINGLE_BRACE_END = '}'
+FILTER_SEPARATOR = '|'
+FILTER_ARGUMENT_SEPARATOR = ':'
+VARIABLE_ATTRIBUTE_SEPARATOR = '.'
+
+# what to report as the origin for templates that come from non-loader sources
+# (e.g. strings)
+UNKNOWN_SOURCE="<unknown source>"
+
+# match a variable or block tag and capture the entire tag, including start/end delimiters
+tag_re = re.compile('(%s.*?%s|%s.*?%s|%s.*?%s)' % (re.escape(BLOCK_TAG_START), re.escape(BLOCK_TAG_END),
+                                          re.escape(VARIABLE_TAG_START), re.escape(VARIABLE_TAG_END),
+                                          re.escape(COMMENT_TAG_START), re.escape(COMMENT_TAG_END)))
+
+class TemplateSyntaxError(Exception):
+    def __str__(self):
+        try:
+            import cStringIO as StringIO
+        except ImportError:
+            import StringIO
+        output = StringIO.StringIO()
+        output.write(Exception.__str__(self))
+        # Check if we wrapped an exception and print that too.
+        if hasattr(self, 'exc_info'):
+            import traceback
+            output.write('\n\nOriginal ')
+            e = self.exc_info
+            traceback.print_exception(e[0], e[1], e[2], 500, output)
+        return output.getvalue()
+
+class TemplateEncodingError(Exception):
+    pass
+
+class Origin(object):
+    def __init__(self, name):
+        self.name = name
+
+    def reload(self):
+        raise NotImplementedError
+
+    def __str__(self):
+        return self.name
+
+class StringOrigin(Origin):
+    def __init__(self, source):
+        super(StringOrigin, self).__init__(UNKNOWN_SOURCE)
+        self.source = source
+
+    def reload(self):
+        return self.source
+
+class Template(object):
+    def __init__(self, template_string, origin=None, name='<Unknown Template>'):
+        try:
+            template_string = smart_unicode(template_string)
+        except UnicodeDecodeError:
+            raise TemplateEncodingError("Templates can only be constructed from unicode or UTF-8 strings.")
+        if settings.TEMPLATE_DEBUG and origin is None:
+            origin = StringOrigin(template_string)
+        self.nodelist = compile_string(template_string, origin)
+        self.name = name
+
+    def __iter__(self):
+        for node in self.nodelist:
+            for subnode in node:
+                yield subnode
+
+    def render(self, context):
+        "Display stage -- can be called many times"
+        return self.nodelist.render(context)
+
+def compile_string(template_string, origin):
+    "Compiles template_string into NodeList ready for rendering"
+    if settings.TEMPLATE_DEBUG:
+        from debug import DebugLexer, DebugParser
+        lexer_class, parser_class = DebugLexer, DebugParser
+    else:
+        lexer_class, parser_class = Lexer, Parser
+    lexer = lexer_class(template_string, origin)
+    parser = parser_class(lexer.tokenize())
+    return parser.parse()
+
+class Token(object):
+    def __init__(self, token_type, contents):
+        # token_type must be TOKEN_TEXT, TOKEN_VAR, TOKEN_BLOCK or TOKEN_COMMENT.
+        self.token_type, self.contents = token_type, contents
+
+    def __str__(self):
+        return '<%s token: "%s...">' % \
+            ({TOKEN_TEXT: 'Text', TOKEN_VAR: 'Var', TOKEN_BLOCK: 'Block', TOKEN_COMMENT: 'Comment'}[self.token_type],
+            self.contents[:20].replace('\n', ''))
+
+    def split_contents(self):
+        split = []
+        bits = iter(smart_split(self.contents))
+        for bit in bits:
+            # Handle translation-marked template pieces
+            if bit.startswith('_("') or bit.startswith("_('"):
+                sentinal = bit[2] + ')'
+                trans_bit = [bit]
+                while not bit.endswith(sentinal):
+                    bit = bits.next()
+                    trans_bit.append(bit)
+                bit = ' '.join(trans_bit)
+            split.append(bit)
+        return split
+
+class Lexer(object):
+    def __init__(self, template_string, origin):
+        self.template_string = template_string
+        self.origin = origin
+
+    def tokenize(self):
+        "Return a list of tokens from a given template_string."
+        in_tag = False
+        result = []
+        for bit in tag_re.split(self.template_string):
+            if bit:
+                result.append(self.create_token(bit, in_tag))
+            in_tag = not in_tag
+        return result
+
+    def create_token(self, token_string, in_tag):
+        """
+        Convert the given token string into a new Token object and return it.
+        If in_tag is True, we are processing something that matched a tag,
+        otherwise it should be treated as a literal string.
+        """
+        if in_tag:
+            if token_string.startswith(VARIABLE_TAG_START):
+                token = Token(TOKEN_VAR, token_string[len(VARIABLE_TAG_START):-len(VARIABLE_TAG_END)].strip())
+            elif token_string.startswith(BLOCK_TAG_START):
+                token = Token(TOKEN_BLOCK, token_string[len(BLOCK_TAG_START):-len(BLOCK_TAG_END)].strip())
+            elif token_string.startswith(COMMENT_TAG_START):
+                token = Token(TOKEN_COMMENT, '')
+        else:
+            token = Token(TOKEN_TEXT, token_string)
+        return token
+
+class Parser(object):
+    def __init__(self, tokens):
+        self.tokens = tokens
+        self.tags = {}
+        self.filters = {}
+        from django.template.library import builtins
+        for lib in builtins:
+            self.add_library(lib)
+
+    def parse(self, parse_until=None):
+        if parse_until is None: parse_until = []
+        nodelist = self.create_nodelist()
+        while self.tokens:
+            token = self.next_token()
+            if token.token_type == TOKEN_TEXT:
+                self.extend_nodelist(nodelist, TextNode(token.contents), token)
+            elif token.token_type == TOKEN_VAR:
+                if not token.contents:
+                    self.empty_variable(token)
+                filter_expression = self.compile_filter(token.contents)
+                var_node = self.create_variable_node(filter_expression)
+                self.extend_nodelist(nodelist, var_node,token)
+            elif token.token_type == TOKEN_BLOCK:
+                if token.contents in parse_until:
+                    # put token back on token list so calling code knows why it terminated
+                    self.prepend_token(token)
+                    return nodelist
+                try:
+                    command = token.contents.split()[0]
+                except IndexError:
+                    self.empty_block_tag(token)
+                # execute callback function for this tag and append resulting node
+                self.enter_command(command, token)
+                try:
+                    compile_func = self.tags[command]
+                except KeyError:
+                    self.invalid_block_tag(token, command)
+                try:
+                    compiled_result = compile_func(self, token)
+                except TemplateSyntaxError, e:
+                    if not self.compile_function_error(token, e):
+                        raise
+                self.extend_nodelist(nodelist, compiled_result, token)
+                self.exit_command()
+        if parse_until:
+            self.unclosed_block_tag(parse_until)
+        return nodelist
+
+    def parse_nodelist(self, parse_until=None):
+        nodelist = self.parse(parse_until=parse_until)
+        self.delete_first_token()
+        return nodelist
+
+    def skip_past(self, endtag):
+        while self.tokens:
+            token = self.next_token()
+            if token.token_type == TOKEN_BLOCK and token.contents == endtag:
+                return
+        self.unclosed_block_tag([endtag])
+
+    def create_variable_node(self, expression):    
+        return ExpressionNode(expression)
+
+    def create_nodelist(self):
+        return NodeList()
+
+    def extend_nodelist(self, nodelist, node, token):
+        if node.must_be_first and nodelist:
+            try:
+                if nodelist.contains_nontext:
+                    raise AttributeError
+            except AttributeError:
+                raise TemplateSyntaxError("%r must be the first tag in the template." % node)
+        if isinstance(nodelist, NodeList) and not isinstance(node, TextNode):
+            nodelist.contains_nontext = True
+        nodelist.append(node)
+
+    def enter_command(self, command, token):
+        pass
+
+    def exit_command(self):
+        pass
+
+    def error(self, token, msg):
+        return TemplateSyntaxError(msg)
+
+    def empty_variable(self, token):
+        raise self.error(token, "Empty variable tag")
+
+    def empty_block_tag(self, token):
+        raise self.error(token, "Empty block tag")
+
+    def invalid_block_tag(self, token, command):
+        raise self.error(token, "Invalid block tag: '%s'" % command)
+
+    def unclosed_block_tag(self, parse_until):
+        raise self.error(None, "Unclosed tags: %s " %  ', '.join(parse_until))
+
+    def compile_function_error(self, token, e):
+        pass
+
+    def next_token(self):
+        return self.tokens.pop(0)
+
+    def prepend_token(self, token):
+        self.tokens.insert(0, token)
+
+    def delete_first_token(self):
+        del self.tokens[0]
+
+    def add_library(self, lib):
+        self.tags.update(lib.tags)
+        self.filters.update(lib.filters)
+
+    def token_stream(self, token):
+        return TokenStream(self, token)
+
+    def compile_filter(self, token):
+        stream = self.token_stream(token)
+        expr = stream.parse_expression(required=True)
+        if not stream.consumed():
+            raise TemplateSyntaxError("Invalid filter expression")
+        return expr
+
+    def find_filter(self, filter_name):
+        if filter_name in self.filters:
+            return self.filters[filter_name]
+        else:
+            raise TemplateSyntaxError("Invalid filter: '%s'" % filter_name)
+
+def filter_args_check(name, func, provided):
+    provided = list(provided)
+    plen = len(provided)
+    # Check to see if a decorator is providing the real function.
+    func = getattr(func, '_decorated_function', func)
+    args, varargs, varkw, defaults = getargspec(func)
+    
+    if plen + 1 == len(args) or (defaults and plen + 1 <= len(args) + len(defaults)):
+        return True
+    
+    # First argument is filter input.
+    args.pop(0)
+    if defaults:
+        nondefs = args[:-len(defaults)]
+    else:
+        nondefs = args
+    # Args without defaults must be provided.
+    try:
+        for arg in nondefs:
+            provided.pop(0)
+    except IndexError:
+        # Not enough
+        raise TemplateSyntaxError("%s requires %d arguments, %d provided" % (name, len(nondefs), plen))
+
+    # Defaults can be overridden.
+    defaults = defaults and list(defaults) or []
+    try:
+        for parg in provided:
+            defaults.pop(0)
+    except IndexError:
+        # Too many.
+        raise TemplateSyntaxError("%s requires %d arguments, %d provided" % (name, len(nondefs), plen))
+
+    return True
+
+EOT = '<EOT>'
+punctuation_chars = r':|=,;<>!?%&@"\'/()\[\]{}`*+-'
+bit_re = re.compile(r"""
+    (?P<string_literal>"(?:[^"\\]*(?:\\.[^"\\]*)*)"|'(?:[^'\\]*(?:\\.[^'\\]*)*)')
+    |(?P<numeric_literal>[+-]?\.?\d[\d\.e]*)
+    |(?P<char>[%s]) # punctuation
+    |(?P<name>[^\s%s]+) # keyword or variable
+""" % ((punctuation_chars,) * 2), re.VERBOSE)
+STRING_LITERAL = "string_literal" #1
+NUMERIC_LITERAL = "numeric_literal" #2
+CHAR = "char" #3
+NAME = "name" #4
+
+def unescape_string_literal(literal):
+    q = literal[0]
+    return literal.replace(r'\%s' % q, q).replace(r'\\', '')[1:-1]
+
+class TokenSyntaxError(Exception):
+    pass
+
+def token_stream_parser(func):
+    def wrapper(self, required=False, *args, **kwargs):
+        mark = self.offset
+        try:
+            return func(self, *args, **kwargs)
+        except TokenSyntaxError:
+            if required:
+                #FIXME: hack
+                self.expected("<%s>" % ' '.join(func.__name__.split('_')[1:]))
+            self.offset = mark
+            raise
+    return wraps(func)(wrapper)
+
+class TokenStream(object):
+    def __init__(self, parser, source):
+        self.parser = parser
+        self.source = source
+        self.offset = 0
+        self.name = None
+        self.token = None
+        if isinstance(source, Token):
+            bits = source.contents.split(None, 1)
+            self.source = len(bits) == 2 and bits[1] or ''
+            self.token = source
+            self.name = bits[0]
+        self.tokens = [(bit.lastgroup, bit.group(0)) for bit in bit_re.finditer(self.source)]
+
+    def consumed(self):
+        return self.offset == len(self.tokens)
+
+    def pop(self):
+        if self.offset == len(self.tokens):
+            raise TokenSyntaxError
+        next = self.tokens[self.offset]
+        self.offset += 1
+        return next
+
+    def pop_lexem(self, match):
+        if self.offset == len(self.tokens):
+            return False
+        tokentype, lexem = self.tokens[self.offset]
+        if lexem == match:
+            self.offset += 1
+            return True
+        return False
+
+    def pop_name(self):
+        if self.offset == len(self.tokens):
+            return None
+        tokentype, lexem = self.tokens[self.offset]
+        if tokentype == NAME:
+            self.offset += 1
+            return lexem
+        return None
+
+    def pushback(self):
+        self.offset -= 1
+
+    def syntax_error(self, msg):
+        if self.name:
+            msg = u"{%% %s %%} %s" % (self.name, msg)
+        raise TemplateSyntaxError(msg)        
+
+    def expected(self, what):
+        if self.consumed():
+            found = EOT
+        else:
+            found = "<%s> %s" % self.tokens[self.offset]
+        self.syntax_error("expected %s, found %s" % (what, smart_str(found, encoding='ascii', errors='backslashreplace')))
+
+    #@token_stream_parser
+    def parse_string(self, bare=False):
+        tokentype, lexem = self.pop()
+        if tokentype == STRING_LITERAL:
+            return unescape_string_literal(lexem)
+        if bare and tokentype == NAME:
+            return lexem
+        raise TokenSyntaxError
+    parse_string = token_stream_parser(parse_string)
+
+    #@token_stream_parser
+    def parse_int(self):
+        token_type, lexem = self.pop()
+        if token_type == NUMERIC_LITERAL:
+            try:
+                return int(lexem)
+            except ValueError:
+                pass
+        raise TokenSyntaxError
+    parse_int = token_stream_parser(parse_int)
+
+    #@token_stream_parser
+    def parse_value(self):
+        translate = False
+        if self.pop_lexem('_'):
+            if not self.pop_lexem('('):
+                raise TokenSyntaxError
+            translate = True
+
+        tokentype, lexem = self.pop()    
+        if tokentype == NAME:
+            if lexem.find(VARIABLE_ATTRIBUTE_SEPARATOR + '_') > -1 or lexem[0] == '_':
+                raise TemplateSyntaxError("Variables and attributes may not begin with underscores: '%s'" % lexem)
+            value = Lookup(tuple(lexem.split(VARIABLE_ATTRIBUTE_SEPARATOR)), var=lexem)
+        elif tokentype == STRING_LITERAL:
+            value = Literal(mark_safe(unescape_string_literal(lexem)))
+        elif tokentype == NUMERIC_LITERAL:
+            try:
+                value = float(lexem)
+            except ValueError:
+                raise TokenSyntaxError
+            if '.' not in lexem and 'e' not in lexem.lower():
+                value = int(value)
+            #FIXME: this causes a test failure: `ifequal-numeric07`
+            if lexem.endswith('.'):
+                raise TemplateSyntaxError, "Numeric literals may not end with '.': %s" % lexem
+            value = Literal(value)
+        elif tokentype == CHAR:
+            raise TokenSyntaxError
+
+        if translate:
+            if not self.pop_lexem(')'):
+                raise TokenSyntaxError
+            # Don't pass the empty string to gettext, because the empty 
+            # string translates to meta information
+            value = FilterExpression(value, [(lambda x: x and ugettext(x) or u'', ())])
+        return value
+    parse_value = token_stream_parser(parse_value)
+
+    #@token_stream_parser
+    def parse_filter(self):
+        if not self.pop_lexem('|'):
+            raise TokenSyntaxError
+        name = self.pop_name()
+        if not name:
+            raise TokenSyntaxError
+        args = []
+        if self.pop_lexem(':'):
+            args.append(self.parse_value())
+        func = self.parser.find_filter(name)
+        filter_args_check(name, func, args)
+        return func, args
+    parse_filter = token_stream_parser(parse_filter)
+
+    #@token_stream_parser
+    def parse_expression(self):
+        var = self.parse_value()
+        filters = []
+        try:
+            while True:
+                filters.append(self.parse_filter())
+        except TokenSyntaxError:
+            pass
+        if filters:
+            return FilterExpression(var, filters)
+        return var
+    parse_expression = token_stream_parser(parse_expression)
+
+    #@token_stream_parser
+    def parse_expression_list(self, minimum=0, maximum=None, count=None):
+        expressions = []
+        if count:
+            minimum = count
+            maximum = count
+        try:
+            while True:
+                if len(expressions) == maximum:
+                    break            
+                expressions.append(self.parse_expression())
+        except TokenSyntaxError:
+            pass
+        if len(expressions) < minimum:
+            self.expected("expression")
+        return expressions
+    parse_expression_list = token_stream_parser(parse_expression_list)
+
+
+def uses_token_stream(func):
+    def decorator(parser, token):
+        bits = parser.token_stream(token)
+        result = func(parser, bits)
+        if bits.offset != len(bits.tokens):
+            bits.expected(EOT)
+        return result    
+    return wraps(func)(decorator)
+

django/template/__init__.py

@@ -12 +12 @@
-Node objects.
-
-Each Node is responsible for creating some sort of output -- e.g. simple text
-Variable
+Expression
-logic (IfNode), results of looping (ForNode), or anything else. The core Node
-Variable
+Expression
-define their own custom node types.
-
-Each Node has a render() method, which takes a Context and returns a string of
@@ -48 +48 @@
->>> t.render(c)
-u'<html></html>'
-"""
-
-
-
+
-from django.template.context import Context, RequestContext, ContextPopException
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-
+
+
+
+
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-# template syntax constants
-FILTER_SEPARATOR = '|'
-FILTER_ARGUMENT_SEPARATOR = ':'
-VARIABLE_ATTRIBUTE_SEPARATOR = '.'
-BLOCK_TAG_START = '{%'
-BLOCK_TAG_END = '%}'
-VARIABLE_TAG_START = '{{'
-VARIABLE_TAG_END = '}}'
-COMMENT_TAG_START = '{#'
-COMMENT_TAG_END = '#}'
-SINGLE_BRACE_START = '{'
-SINGLE_BRACE_END = '}'
-
-ALLOWED_VARIABLE_CHARS = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.'
-
-# what to report as the origin for templates that come from non-loader sources
-# (e.g. strings)
-UNKNOWN_SOURCE="&lt;unknown source&gt;"
-
-# match a variable or block tag and capture the entire tag, including start/end delimiters
-tag_re = re.compile('(%s.*?%s|%s.*?%s|%s.*?%s)' % (re.escape(BLOCK_TAG_START), re.escape(BLOCK_TAG_END),
-                                          re.escape(VARIABLE_TAG_START), re.escape(VARIABLE_TAG_END),
-                                          re.escape(COMMENT_TAG_START), re.escape(COMMENT_TAG_END)))
-
-# global dictionary of libraries that have been loaded using get_library
-libraries = {}
-# global list of libraries to load by default for a new parser
-builtins = []
-
-# True if TEMPLATE_STRING_IF_INVALID contains a format string (%s). None means
-# uninitialised.
-invalid_var_format_string = None
-
-class TemplateSyntaxError(Exception):
-    def __str__(self):
-        try:
-            import cStringIO as StringIO
-        except ImportError:
-            import StringIO
-        output = StringIO.StringIO()
-        output.write(Exception.__str__(self))
-        # Check if we wrapped an exception and print that too.
-        if hasattr(self, 'exc_info'):
-            import traceback
-            output.write('\n\nOriginal ')
-            e = self.exc_info
-            traceback.print_exception(e[0], e[1], e[2], 500, output)
-        return output.getvalue()
-
-class TemplateDoesNotExist(Exception):
-    pass
-
-class TemplateEncodingError(Exception):
-    pass
-
-class VariableDoesNotExist(Exception):
-
-    def __init__(self, msg, params=()):
-        self.msg = msg
-        self.params = params
-
-    def __str__(self):
-        return unicode(self).encode('utf-8')
-
-    def __unicode__(self):
-        return self.msg % tuple([force_unicode(p, errors='replace') for p in self.params])
-
-class InvalidTemplateLibrary(Exception):
-    pass
-
-class Origin(object):
-    def __init__(self, name):
-        self.name = name
-
-    def reload(self):
-        raise NotImplementedError
-
-    def __str__(self):
-        return self.name
-
-class StringOrigin(Origin):
-    def __init__(self, source):
-        super(StringOrigin, self).__init__(UNKNOWN_SOURCE)
-        self.source = source
-
-    def reload(self):
-        return self.source
-
-class Template(object):
-    def __init__(self, template_string, origin=None, name='<Unknown Template>'):
-        try:
-            template_string = smart_unicode(template_string)
-        except UnicodeDecodeError:
-            raise TemplateEncodingError("Templates can only be constructed from unicode or UTF-8 strings.")
-        if settings.TEMPLATE_DEBUG and origin is None:
-            origin = StringOrigin(template_string)
-        self.nodelist = compile_string(template_string, origin)
-        self.name = name
-
-    def __iter__(self):
-        for node in self.nodelist:
-            for subnode in node:
-                yield subnode
-
-    def render(self, context):
-        "Display stage -- can be called many times"
-        return self.nodelist.render(context)
-
-def compile_string(template_string, origin):
-    "Compiles template_string into NodeList ready for rendering"
-    if settings.TEMPLATE_DEBUG:
-        from debug import DebugLexer, DebugParser
-        lexer_class, parser_class = DebugLexer, DebugParser
-    else:
-        lexer_class, parser_class = Lexer, Parser
-    lexer = lexer_class(template_string, origin)
-    parser = parser_class(lexer.tokenize())
-    return parser.parse()
-
-class Token(object):
-    def __init__(self, token_type, contents):
-        # token_type must be TOKEN_TEXT, TOKEN_VAR, TOKEN_BLOCK or TOKEN_COMMENT.
-        self.token_type, self.contents = token_type, contents
-
-    def __str__(self):
-        return '<%s token: "%s...">' % \
-            ({TOKEN_TEXT: 'Text', TOKEN_VAR: 'Var', TOKEN_BLOCK: 'Block', TOKEN_COMMENT: 'Comment'}[self.token_type],
-            self.contents[:20].replace('\n', ''))
-
-    def split_contents(self):
-        split = []
-        bits = iter(smart_split(self.contents))
-        for bit in bits:
-            # Handle translation-marked template pieces
-            if bit.startswith('_("') or bit.startswith("_('"):
-                sentinal = bit[2] + ')'
-                trans_bit = [bit]
-                while not bit.endswith(sentinal):
-                    bit = bits.next()
-                    trans_bit.append(bit)
-                bit = ' '.join(trans_bit)
-            split.append(bit)
-        return split
-
-class Lexer(object):
-    def __init__(self, template_string, origin):
-        self.template_string = template_string
-        self.origin = origin
-
-    def tokenize(self):
-        "Return a list of tokens from a given template_string."
-        in_tag = False
-        result = []
-        for bit in tag_re.split(self.template_string):
-            if bit:
-                result.append(self.create_token(bit, in_tag))
-            in_tag = not in_tag
-        return result
-
-    def create_token(self, token_string, in_tag):
-        """
-        Convert the given token string into a new Token object and return it.
-        If in_tag is True, we are processing something that matched a tag,
-        otherwise it should be treated as a literal string.
-        """
-        if in_tag:
-            if token_string.startswith(VARIABLE_TAG_START):
-                token = Token(TOKEN_VAR, token_string[len(VARIABLE_TAG_START):-len(VARIABLE_TAG_END)].strip())
-            elif token_string.startswith(BLOCK_TAG_START):
-                token = Token(TOKEN_BLOCK, token_string[len(BLOCK_TAG_START):-len(BLOCK_TAG_END)].strip())
-            elif token_string.startswith(COMMENT_TAG_START):
-                token = Token(TOKEN_COMMENT, '')
-        else:
-            token = Token(TOKEN_TEXT, token_string)
-        return token
-
-class Parser(object):
-    def __init__(self, tokens):
-        self.tokens = tokens
-        self.tags = {}
-        self.filters = {}
-        for lib in builtins:
-            self.add_library(lib)
-
-    def parse(self, parse_until=None):
-        if parse_until is None: parse_until = []
-        nodelist = self.create_nodelist()
-        while self.tokens:
-            token = self.next_token()
-            if token.token_type == TOKEN_TEXT:
-                self.extend_nodelist(nodelist, TextNode(token.contents), token)
-            elif token.token_type == TOKEN_VAR:
-                if not token.contents:
-                    self.empty_variable(token)
-                filter_expression = self.compile_filter(token.contents)
-                var_node = self.create_variable_node(filter_expression)
-                self.extend_nodelist(nodelist, var_node,token)
-            elif token.token_type == TOKEN_BLOCK:
-                if token.contents in parse_until:
-                    # put token back on token list so calling code knows why it terminated
-                    self.prepend_token(token)
-                    return nodelist
-                try:
-                    command = token.contents.split()[0]
-                except IndexError:
-                    self.empty_block_tag(token)
-                # execute callback function for this tag and append resulting node
-                self.enter_command(command, token)
-                try:
-                    compile_func = self.tags[command]
-                except KeyError:
-                    self.invalid_block_tag(token, command)
-                try:
-                    compiled_result = compile_func(self, token)
-                except TemplateSyntaxError, e:
-                    if not self.compile_function_error(token, e):
-                        raise
-                self.extend_nodelist(nodelist, compiled_result, token)
-                self.exit_command()
-        if parse_until:
-            self.unclosed_block_tag(parse_until)
-        return nodelist
-
-    def skip_past(self, endtag):
-        while self.tokens:
-            token = self.next_token()
-            if token.token_type == TOKEN_BLOCK and token.contents == endtag:
-                return
-        self.unclosed_block_tag([endtag])
-
-    def create_variable_node(self, filter_expression):
-        return VariableNode(filter_expression)
-
-    def create_nodelist(self):
-        return NodeList()
-
-    def extend_nodelist(self, nodelist, node, token):
-        if node.must_be_first and nodelist:
-            try:
-                if nodelist.contains_nontext:
-                    raise AttributeError
-            except AttributeError:
-                raise TemplateSyntaxError("%r must be the first tag in the template." % node)
-        if isinstance(nodelist, NodeList) and not isinstance(node, TextNode):
-            nodelist.contains_nontext = True
-        nodelist.append(node)
-
-    def enter_command(self, command, token):
-        pass
-
-    def exit_command(self):
-        pass
-
-    def error(self, token, msg):
-        return TemplateSyntaxError(msg)
-
-    def empty_variable(self, token):
-        raise self.error(token, "Empty variable tag")
-
-    def empty_block_tag(self, token):
-        raise self.error(token, "Empty block tag")
-
-    def invalid_block_tag(self, token, command):
-        raise self.error(token, "Invalid block tag: '%s'" % command)
-
-    def unclosed_block_tag(self, parse_until):
-        raise self.error(None, "Unclosed tags: %s " %  ', '.join(parse_until))
-
-    def compile_function_error(self, token, e):
-        pass
-
-    def next_token(self):
-        return self.tokens.pop(0)
-
-    def prepend_token(self, token):
-        self.tokens.insert(0, token)
-
-    def delete_first_token(self):
-        del self.tokens[0]
-
-    def add_library(self, lib):
-        self.tags.update(lib.tags)
-        self.filters.update(lib.filters)
-
-    def compile_filter(self, token):
-        "Convenient wrapper for FilterExpression"
-        return FilterExpression(token, self)
-
-    def find_filter(self, filter_name):
-        if filter_name in self.filters:
-            return self.filters[filter_name]
-        else:
-            raise TemplateSyntaxError("Invalid filter: '%s'" % filter_name)
-
-class TokenParser(object):
-    """
-    Subclass this and implement the top() method to parse a template line. When
-    instantiating the parser, pass in the line from the Django template parser.
-
-    The parser's "tagname" instance-variable stores the name of the tag that
-    the filter was called with.
-    """
-    def __init__(self, subject):
-        self.subject = subject
-        self.pointer = 0
-        self.backout = []
-        self.tagname = self.tag()
-
-    def top(self):
-        "Overload this method to do the actual parsing and return the result."
-        raise NotImplementedError()
-
-    def more(self):
-        "Returns True if there is more stuff in the tag."
-        return self.pointer < len(self.subject)
-
-    def back(self):
-        "Undoes the last microparser. Use this for lookahead and backtracking."
-        if not len(self.backout):
-            raise TemplateSyntaxError("back called without some previous parsing")
-        self.pointer = self.backout.pop()
-
-    def tag(self):
-        "A microparser that just returns the next tag from the line."
-        subject = self.subject
-        i = self.pointer
-        if i >= len(subject):
-            raise TemplateSyntaxError("expected another tag, found end of string: %s" % subject)
-        p = i
-        while i < len(subject) and subject[i] not in (' ', '\t'):
-            i += 1
-        s = subject[p:i]
-        while i < len(subject) and subject[i] in (' ', '\t'):
-            i += 1
-        self.backout.append(self.pointer)
-        self.pointer = i
-        return s
-
-    def value(self):
-        "A microparser that parses for a value: some string constant or variable name."
-        subject = self.subject
-        i = self.pointer
-        if i >= len(subject):
-            raise TemplateSyntaxError("Searching for value. Expected another value but found end of string: %s" % subject)
-        if subject[i] in ('"', "'"):
-            p = i
-            i += 1
-            while i < len(subject) and subject[i] != subject[p]:
-                i += 1
-            if i >= len(subject):
-                raise TemplateSyntaxError("Searching for value. Unexpected end of string in column %d: %s" % (i, subject))
-            i += 1
-            res = subject[p:i]
-            while i < len(subject) and subject[i] in (' ', '\t'):
-                i += 1
-            self.backout.append(self.pointer)
-            self.pointer = i
-            return res
-        else:
-            p = i
-            while i < len(subject) and subject[i] not in (' ', '\t'):
-                if subject[i] in ('"', "'"):
-                    c = subject[i]
-                    i += 1
-                    while i < len(subject) and subject[i] != c:
-                        i += 1
-                    if i >= len(subject):
-                        raise TemplateSyntaxError("Searching for value. Unexpected end of string in column %d: %s" % (i, subject))
-                i += 1
-            s = subject[p:i]
-            while i < len(subject) and subject[i] in (' ', '\t'):
-                i += 1
-            self.backout.append(self.pointer)
-            self.pointer = i
-            return s
-
-filter_raw_string = r"""
-^%(i18n_open)s"(?P<i18n_constant>%(str)s)"%(i18n_close)s|
-^"(?P<constant>%(str)s)"|
-^(?P<var>[%(var_chars)s]+)|
- (?:%(filter_sep)s
-     (?P<filter_name>\w+)
-         (?:%(arg_sep)s
-             (?:
-              %(i18n_open)s"(?P<i18n_arg>%(str)s)"%(i18n_close)s|
-              "(?P<constant_arg>%(str)s)"|
-              (?P<var_arg>[%(var_chars)s]+)
-             )
-         )?
- )""" % {
-    'str': r"""[^"\\]*(?:\\.[^"\\]*)*""",
-    'var_chars': "\w\." ,
-    'filter_sep': re.escape(FILTER_SEPARATOR),
-    'arg_sep': re.escape(FILTER_ARGUMENT_SEPARATOR),
-    'i18n_open' : re.escape("_("),
-    'i18n_close' : re.escape(")"),
-  }
-
-filter_raw_string = filter_raw_string.replace("\n", "").replace(" ", "")
-filter_re = re.compile(filter_raw_string, re.UNICODE)
-
-class FilterExpression(object):
-    """
-    Parses a variable token and its optional filters (all as a single string),
-    and return a list of tuples of the filter name and arguments.
-    Sample:
-        >>> token = 'variable|default:"Default value"|date:"Y-m-d"'
-        >>> p = Parser('')
-        >>> fe = FilterExpression(token, p)
-        >>> len(fe.filters)
-        2
-        >>> fe.var
-        <Variable: 'variable'>
-
-    This class should never be instantiated outside of the
-    get_filters_from_token helper function.
-    """
-    def __init__(self, token, parser):
-        self.token = token
-        matches = filter_re.finditer(token)
-        var = None
-        filters = []
-        upto = 0
-        for match in matches:
-            start = match.start()
-            if upto != start:
-                raise TemplateSyntaxError("Could not parse some characters: %s|%s|%s"  % \
-                                           (token[:upto], token[upto:start], token[start:]))
-            if var == None:
-                var, constant, i18n_constant = match.group("var", "constant", "i18n_constant")
-                if i18n_constant is not None:
-                    # Don't pass the empty string to gettext, because the empty
-                    # string translates to meta information.
-                    if i18n_constant == "":
-                        var = '""'
-                    else:
-                        var = '"%s"' %  _(i18n_constant.replace(r'\"', '"'))
-                elif constant is not None:
-                    var = '"%s"' % constant.replace(r'\"', '"')
-                upto = match.end()
-                if var == None:
-                    raise TemplateSyntaxError("Could not find variable at start of %s" % token)
-                elif var.find(VARIABLE_ATTRIBUTE_SEPARATOR + '_') > -1 or var[0] == '_':
-                    raise TemplateSyntaxError("Variables and attributes may not begin with underscores: '%s'" % var)
-            else:
-                filter_name = match.group("filter_name")
-                args = []
-                constant_arg, i18n_arg, var_arg = match.group("constant_arg", "i18n_arg", "var_arg")
-                if i18n_arg:
-                    args.append((False, _(i18n_arg.replace(r'\"', '"'))))
-                elif constant_arg is not None:
-                    args.append((False, constant_arg.replace(r'\"', '"')))
-                elif var_arg:
-                    args.append((True, Variable(var_arg)))
-                filter_func = parser.find_filter(filter_name)
-                self.args_check(filter_name,filter_func, args)
-                filters.append( (filter_func,args))
-                upto = match.end()
-        if upto != len(token):
-            raise TemplateSyntaxError("Could not parse the remainder: '%s' from '%s'" % (token[upto:], token))
-        self.filters = filters
-        self.var = Variable(var)
-
-    def resolve(self, context, ignore_failures=False):
-        try:
-            obj = self.var.resolve(context)
-        except VariableDoesNotExist:
-            if ignore_failures:
-                obj = None
-            else:
-                if settings.TEMPLATE_STRING_IF_INVALID:
-                    global invalid_var_format_string
-                    if invalid_var_format_string is None:
-                        invalid_var_format_string = '%s' in settings.TEMPLATE_STRING_IF_INVALID
-                    if invalid_var_format_string:
-                        return settings.TEMPLATE_STRING_IF_INVALID % self.var
-                    return settings.TEMPLATE_STRING_IF_INVALID
-                else:
-                    obj = settings.TEMPLATE_STRING_IF_INVALID
-        for func, args in self.filters:
-            arg_vals = []
-            for lookup, arg in args:
-                if not lookup:
-                    arg_vals.append(mark_safe(arg))
-                else:
-                    arg_vals.append(arg.resolve(context))
-            if getattr(func, 'needs_autoescape', False):
-                new_obj = func(obj, autoescape=context.autoescape, *arg_vals)
-            else:
-                new_obj = func(obj, *arg_vals)
-            if getattr(func, 'is_safe', False) and isinstance(obj, SafeData):
-                obj = mark_safe(new_obj)
-            elif isinstance(obj, EscapeData):
-                obj = mark_for_escaping(new_obj)
-            else:
-                obj = new_obj
-        return obj
-
-    def args_check(name, func, provided):
-        provided = list(provided)
-        plen = len(provided)
-        # Check to see if a decorator is providing the real function.
-        func = getattr(func, '_decorated_function', func)
-        args, varargs, varkw, defaults = getargspec(func)
-        # First argument is filter input.
-        args.pop(0)
-        if defaults:
-            nondefs = args[:-len(defaults)]
-        else:
-            nondefs = args
-        # Args without defaults must be provided.
-        try:
-            for arg in nondefs:
-                provided.pop(0)
-        except IndexError:
-            # Not enough
-            raise TemplateSyntaxError("%s requires %d arguments, %d provided" % (name, len(nondefs), plen))
-
-        # Defaults can be overridden.
-        defaults = defaults and list(defaults) or []
-        try:
-            for parg in provided:
-                defaults.pop(0)
-        except IndexError:
-            # Too many.
-            raise TemplateSyntaxError("%s requires %d arguments, %d provided" % (name, len(nondefs), plen))
-
-        return True
-    args_check = staticmethod(args_check)
-
-    def __str__(self):
-        return self.token
-
-def resolve_variable(path, context):
-    """
-    Returns the resolved variable, which may contain attribute syntax, within
-    the given context.
-
-    Deprecated; use the Variable class instead.
-    """
-    return Variable(path).resolve(context)
-
-class Variable(object):
-    """
-    A template variable, resolvable against a given context. The variable may be
-    a hard-coded string (if it begins and ends with single or double quote
-    marks)::
-
-        >>> c = {'article': {'section':u'News'}}
-        >>> Variable('article.section').resolve(c)
-        u'News'
-        >>> Variable('article').resolve(c)
-        {'section': u'News'}
-        >>> class AClass: pass
-        >>> c = AClass()
-        >>> c.article = AClass()
-        >>> c.article.section = u'News'
-        >>> Variable('article.section').resolve(c)
-        u'News'
-
-    (The example assumes VARIABLE_ATTRIBUTE_SEPARATOR is '.')
-    """
-
-    def __init__(self, var):
-        self.var = var
-        self.literal = None
-        self.lookups = None
-        self.translate = False
-
-        try:
-            # First try to treat this variable as a number.
-            #
-            # Note that this could cause an OverflowError here that we're not
-            # catching. Since this should only happen at compile time, that's
-            # probably OK.
-            self.literal = float(var)
-
-            # So it's a float... is it an int? If the original value contained a
-            # dot or an "e" then it was a float, not an int.
-            if '.' not in var and 'e' not in var.lower():
-                self.literal = int(self.literal)
-
-            # "2." is invalid
-            if var.endswith('.'):
-                raise ValueError
-
-        except ValueError:
-            # A ValueError means that the variable isn't a number.
-            if var.startswith('_(') and var.endswith(')'):
-                # The result of the lookup should be translated at rendering
-                # time.
-                self.translate = True
-                var = var[2:-1]
-            # If it's wrapped with quotes (single or double), then
-            # we're also dealing with a literal.
-            if var[0] in "\"'" and var[0] == var[-1]:
-                self.literal = mark_safe(var[1:-1])
-            else:
-                # Otherwise we'll set self.lookups so that resolve() knows we're
-                # dealing with a bonafide variable
-                self.lookups = tuple(var.split(VARIABLE_ATTRIBUTE_SEPARATOR))
-
-    def resolve(self, context):
-        """Resolve this variable against a given context."""
-        if self.lookups is not None:
-            # We're dealing with a variable that needs to be resolved
-            value = self._resolve_lookup(context)
-        else:
-            # We're dealing with a literal, so it's already been "resolved"
-            value = self.literal
-        if self.translate:
-            return _(value)
-        return value
-
-    def __repr__(self):
-        return "<%s: %r>" % (self.__class__.__name__, self.var)
-
-    def __str__(self):
-        return self.var
-
-    def _resolve_lookup(self, context):
-        """
-        Performs resolution of a real variable (i.e. not a literal) against the
-        given context.
-
-        As indicated by the method's name, this method is an implementation
-        detail and shouldn't be called by external code. Use Variable.resolve()
-        instead.
-        """
-        current = context
-        for bit in self.lookups:
-            try: # dictionary lookup
-                current = current[bit]
-            except (TypeError, AttributeError, KeyError):
-                try: # attribute lookup
-                    current = getattr(current, bit)
-                    if callable(current):
-                        if getattr(current, 'alters_data', False):
-                            current = settings.TEMPLATE_STRING_IF_INVALID
-                        else:
-                            try: # method call (assuming no args required)
-                                current = current()
-                            except TypeError: # arguments *were* required
-                                # GOTCHA: This will also catch any TypeError
-                                # raised in the function itself.
-                                current = settings.TEMPLATE_STRING_IF_INVALID # invalid method call
-                            except Exception, e:
-                                if getattr(e, 'silent_variable_failure', False):
-                                    current = settings.TEMPLATE_STRING_IF_INVALID
-                                else:
-                                    raise
-                except (TypeError, AttributeError):
-                    try: # list-index lookup
-                        current = current[int(bit)]
-                    except (IndexError, # list index out of range
-                            ValueError, # invalid literal for int()
-                            KeyError,   # current is a dict without `int(bit)` key
-                            TypeError,  # unsubscriptable object
-                            ):
-                        raise VariableDoesNotExist("Failed lookup for key [%s] in %r", (bit, current)) # missing attribute
-                except Exception, e:
-                    if getattr(e, 'silent_variable_failure', False):
-                        current = settings.TEMPLATE_STRING_IF_INVALID
-                    else:
-                        raise
-
-        return current
-
-class Node(object):
-    # Set this to True for nodes that must be first in the template (although
-    # they can be preceded by text nodes.
-    must_be_first = False
-
-    def render(self, context):
-        "Return the node rendered as a string"
-        pass
-
-    def __iter__(self):
-        yield self
-
-    def get_nodes_by_type(self, nodetype):
-        "Return a list of all nodes (within this node and its nodelist) of the given type"
-        nodes = []
-        if isinstance(self, nodetype):
-            nodes.append(self)
-        if hasattr(self, 'nodelist'):
-            nodes.extend(self.nodelist.get_nodes_by_type(nodetype))
-        return nodes
-
-class NodeList(list):
-    # Set to True the first time a non-TextNode is inserted by
-    # extend_nodelist().
-    contains_nontext = False
-
-    def render(self, context):
-        bits = []
-        for node in self:
-            if isinstance(node, Node):
-                bits.append(self.render_node(node, context))
-            else:
-                bits.append(node)
-        return mark_safe(''.join([force_unicode(b) for b in bits]))
-
-    def get_nodes_by_type(self, nodetype):
-        "Return a list of all nodes of the given type"
-        nodes = []
-        for node in self:
-            nodes.extend(node.get_nodes_by_type(nodetype))
-        return nodes
-
-    def render_node(self, node, context):
-        return node.render(context)
-
-class TextNode(Node):
-    def __init__(self, s):
-        self.s = s
-
-    def __repr__(self):
-        return "<Text Node: '%s'>" % self.s[:25]
-
-    def render(self, context):
-        return self.s
-
-class VariableNode(Node):
-    def __init__(self, filter_expression):
-        self.filter_expression = filter_expression
-
-    def __repr__(self):
-        return "<Variable Node: %s>" % self.filter_expression
-
-    def render(self, context):
-        try:
-            output = force_unicode(self.filter_expression.resolve(context))
-        except UnicodeDecodeError:
-            # Unicode conversion can fail sometimes for reasons out of our
-            # control (e.g. exception rendering). In that case, we fail quietly.
-            return ''
-        if (context.autoescape and not isinstance(output, SafeData)) or isinstance(output, EscapeData):
-            return force_unicode(escape(output))
-        else:
-            return force_unicode(output)
-
-def generic_tag_compiler(params, defaults, name, node_class, parser, token):
-    "Returns a template.Node subclass."
-    bits = token.split_contents()[1:]
-    bmax = len(params)
-    def_len = defaults and len(defaults) or 0
-    bmin = bmax - def_len
-    if(len(bits) < bmin or len(bits) > bmax):
-        if bmin == bmax:
-            message = "%s takes %s arguments" % (name, bmin)
-        else:
-            message = "%s takes between %s and %s arguments" % (name, bmin, bmax)
-        raise TemplateSyntaxError(message)
-    return node_class(bits)
-
-class Library(object):
-    def __init__(self):
-        self.filters = {}
-        self.tags = {}
-
-    def tag(self, name=None, compile_function=None):
-        if name == None and compile_function == None:
-            # @register.tag()
-            return self.tag_function
-        elif name != None and compile_function == None:
-            if(callable(name)):
-                # @register.tag
-                return self.tag_function(name)
-            else:
-                # @register.tag('somename') or @register.tag(name='somename')
-                def dec(func):
-                    return self.tag(name, func)
-                return dec
-        elif name != None and compile_function != None:
-            # register.tag('somename', somefunc)
-            self.tags[name] = compile_function
-            return compile_function
-        else:
-            raise InvalidTemplateLibrary("Unsupported arguments to Library.tag: (%r, %r)", (name, compile_function))
-
-    def tag_function(self,func):
-        self.tags[getattr(func, "_decorated_function", func).__name__] = func
-        return func
-
-    def filter(self, name=None, filter_func=None):
-        if name == None and filter_func == None:
-            # @register.filter()
-            return self.filter_function
-        elif filter_func == None:
-            if(callable(name)):
-                # @register.filter
-                return self.filter_function(name)
-            else:
-                # @register.filter('somename') or @register.filter(name='somename')
-                def dec(func):
-                    return self.filter(name, func)
-                return dec
-        elif name != None and filter_func != None:
-            # register.filter('somename', somefunc)
-            self.filters[name] = filter_func
-            return filter_func
-        else:
-            raise InvalidTemplateLibrary("Unsupported arguments to Library.filter: (%r, %r)", (name, filter_func))
-
-    def filter_function(self, func):
-        self.filters[getattr(func, "_decorated_function", func).__name__] = func
-        return func
-
-    def simple_tag(self,func):
-        params, xx, xxx, defaults = getargspec(func)
-
-        class SimpleNode(Node):
-            def __init__(self, vars_to_resolve):
-                self.vars_to_resolve = map(Variable, vars_to_resolve)
-
-            def render(self, context):
-                resolved_vars = [var.resolve(context) for var in self.vars_to_resolve]
-                return func(*resolved_vars)
-
-        compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, SimpleNode)
-        compile_func.__doc__ = func.__doc__
-        self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
-        return func
-
-    def inclusion_tag(self, file_name, context_class=Context, takes_context=False):
-        def dec(func):
-            params, xx, xxx, defaults = getargspec(func)
-            if takes_context:
-                if params[0] == 'context':
-                    params = params[1:]
-                else:
-                    raise TemplateSyntaxError("Any tag function decorated with takes_context=True must have a first argument of 'context'")
-
-            class InclusionNode(Node):
-                def __init__(self, vars_to_resolve):
-                    self.vars_to_resolve = map(Variable, vars_to_resolve)
-
-                def render(self, context):
-                    resolved_vars = [var.resolve(context) for var in self.vars_to_resolve]
-                    if takes_context:
-                        args = [context] + resolved_vars
-                    else:
-                        args = resolved_vars
-
-                    dict = func(*args)
-
-                    if not getattr(self, 'nodelist', False):
-                        from django.template.loader import get_template, select_template
-                        if not isinstance(file_name, basestring) and is_iterable(file_name):
-                            t = select_template(file_name)
-                        else:
-                            t = get_template(file_name)
-                        self.nodelist = t.nodelist
-                    return self.nodelist.render(context_class(dict,
-                            autoescape=context.autoescape))
-
-            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
-            compile_func.__doc__ = func.__doc__
-            self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
-            return func
-        return dec
-
-def get_library(module_name):
-    lib = libraries.get(module_name, None)
-    if not lib:
-        try:
-            mod = __import__(module_name, {}, {}, [''])
-        except ImportError, e:
-            raise InvalidTemplateLibrary("Could not load template library from %s, %s" % (module_name, e))
-        try:
-            lib = mod.register
-            libraries[module_name] = lib
-        except AttributeError:
-            raise InvalidTemplateLibrary("Template library %s does not have a variable named 'register'" % module_name)
-    return lib
-
-def add_to_builtins(module_name):
-    builtins.append(get_library(module_name))
-
-add_to_builtins('django.template.defaulttags')
-add_to_builtins('django.template.defaultfilters')

django/template/utils.py

@@ +1 @@
+import re
+from django.template import Node, NodeList, TokenSyntaxError, TemplateSyntaxError
+
+class EmptyNode(Node):
+    def render(self, context):
+        return u''
+        
+class ConditionalNode(Node):
+    def __init__(self, nodelist_true, nodelist_false):
+        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
+
+    def __iter__(self):
+        for node in self.nodelist_true:
+            yield node
+        for node in self.nodelist_false:
+            yield node
+
+    def get_nodes_by_type(self, nodetype):
+        nodes = []
+        if isinstance(self, nodetype):
+            nodes.append(self)
+        nodes.extend(self.nodelist_true.get_nodes_by_type(nodetype))
+        nodes.extend(self.nodelist_false.get_nodes_by_type(nodetype))
+        return nodes
+        
+    def check_condition(self, context):
+        return False
+        
+    def render(self, context):
+        if self.check_condition(context):
+            return self.nodelist_true.render(context)
+        elif self.nodelist_false:
+            return self.nodelist_false.render(context)
+        return u''
+
+def parse_conditional_nodelists(parser, name):
+    end_tag = 'end' + name
+    nodelist_true = parser.parse(('else', end_tag))
+    token = parser.next_token()
+    if token.contents == 'else':
+        nodelist_false = parser.parse((end_tag,))
+        parser.delete_first_token()
+    else:
+        nodelist_false = NodeList()
+    return nodelist_true, nodelist_false
+
+def parse_args_and_kwargs(bits, until=()):
+    args = []
+    kwargs = {}
+    while True:
+        name = bits.pop_name()
+        if name in until:
+            bits.pushback()
+            break
+        if name and bits.pop_lexem('='):
+            kwargs[name] = bits.parse_expression(required=True)
+        else:
+            if name:
+                bits.pushback()
+            try:
+                args.append(bits.parse_expression())
+            except TokenSyntaxError:
+                break
+        if not bits.pop_lexem(','):
+            break
+    return args, kwargs
+
+def parse_as(bits):
+    if bits.pop_lexem('as'):
+        name = bits.pop_name()
+        if name:
+            return name
+    raise TokenSyntaxError
+
+def resolve_args_and_kwargs(args, kwargs, context):
+        resolved_args = [arg.resolve(context, True) for arg in args]
+        resolved_kwargs = {}
+        for name in kwargs:
+                resolved_kwargs[name] = kwargs[name].resolve(context, True)
+        return resolved_args, resolved_kwargs

django/template/expressions.py

@@ +1 @@
+from django.conf import settings
+from django.utils.encoding import force_unicode
+from django.utils.safestring import SafeData, EscapeData, mark_safe, mark_for_escaping
+
+__all__ = ('LookupError', 'Expression', 'Variable', 'Literal', 'Lookup', 'FilterExpression')
+
+class LookupError(Exception):
+    def __init__(self, var, msg, params=()):
+        self.var = var
+        self.msg = msg
+        self.params = params
+
+    def __str__(self):
+        return unicode(self).encode('utf-8')
+
+    def __unicode__(self):
+        return self.msg % tuple([force_unicode(p, errors='replace') for p in self.params])
+
+
+class Expression(object):
+    def resolve_safe(self, context, default=None):
+        try:
+            return self.resolve(context)
+        except LookupError:
+            return default
+
+    def resolve(self, context):
+        pass
+
+class Literal(Expression):
+    def __init__(self, value):
+        self.value = value
+
+    def resolve(self, context):
+        return self.value
+        
+class Lookup(Expression):
+    def __init__(self, lookups, var=None):
+        self.var = var
+        self.lookups = lookups
+
+    def __str__(self):
+        return "%s" % self.var
+        
+    def resolve(self, context):
+        current = context
+        for bit in self.lookups:
+            try: # dictionary lookup
+                current = current[bit]
+            except (TypeError, AttributeError, KeyError):
+                try: # attribute lookup
+                    current = getattr(current, bit)
+                    if callable(current):
+                        if getattr(current, 'alters_data', False):
+                            current = settings.TEMPLATE_STRING_IF_INVALID
+                        else:
+                            try: # method call (assuming no args required)
+                                current = current()
+                            except TypeError: # arguments *were* required
+                                # GOTCHA: This will also catch any TypeError
+                                # raised in the function itself.
+                                current = settings.TEMPLATE_STRING_IF_INVALID # invalid method call
+                            except Exception, e:
+                                if getattr(e, 'silent_variable_failure', False):
+                                    current = settings.TEMPLATE_STRING_IF_INVALID
+                                else:
+                                    raise
+                except (TypeError, AttributeError):
+                    try: # list-index lookup
+                        current = current[int(bit)]
+                    except (IndexError, # list index out of range
+                            ValueError, # invalid literal for int()
+                            KeyError,   # current is a dict without `int(bit)` key
+                            TypeError,  # unsubscriptable object
+                            ):
+                        raise LookupError(self.var, "Failed lookup for key [%s] in %r", (bit, current))
+                except Exception, e:
+                    if getattr(e, 'silent_variable_failure', False):
+                        current = settings.TEMPLATE_STRING_IF_INVALID
+                    else:
+                        raise
+
+        return current
+
+class FilterExpression(Expression):
+    def __init__(self, root, filters):
+        self.root = root
+        self.filters = filters
+
+    def resolve(self, context):
+        try:
+            obj = self.root.resolve(context)
+        except LookupError:
+            if not self.filters:
+                raise
+            obj = settings.TEMPLATE_STRING_IF_INVALID
+        for func, args in self.filters:
+            arg_vals = []         
+            for arg in args:
+                arg_vals.append(arg.resolve(context))
+            if getattr(func, 'needs_autoescape', False):
+                new_obj = func(obj, autoescape=context.autoescape, *arg_vals)
+            else:
+                new_obj = func(obj, *arg_vals)
+            if getattr(func, 'is_safe', False) and isinstance(obj, SafeData):
+                obj = mark_safe(new_obj)
+            elif isinstance(obj, EscapeData):
+                obj = mark_for_escaping(new_obj)
+            else:
+                obj = new_obj
+        return obj
+
+    def __str__(self):
+        return str(self.root)+'|<filtered>'

django/template/defaulttags.py

@@ -8 +8 @@
-except NameError:
-    from django.utils.itercompat import reversed     # Python 2.3 fallback
-
-, Variable
-VariableDoesNotExist, BLOCK_TAG_START, BLOCK_TAG_END, VARIABLE_TAG_START, VARIABLE_TAG_END, SINGLE_BRACE_START, SINGLE_BRACE_END, COMMENT_TAG_START, COMMENT_TAG_END
+
+LookupError, TokenSyntaxError
-from django.template import get_library, Library, InvalidTemplateLibrary
+from django.template.compiler import uses_token_stream, BLOCK_TAG_START, BLOCK_TAG_END, VARIABLE_TAG_START, VARIABLE_TAG_END, SINGLE_BRACE_START, SINGLE_BRACE_END, COMMENT_TAG_START, COMMENT_TAG_END
+from django.template.utils import EmptyNode, ConditionalNode, parse_conditional_nodelists, parse_as, parse_args_and_kwargs
-from django.conf import settings
-smart
+force
-from django.utils.itercompat import groupby
-from django.utils.safestring import mark_safe
-
@@ -33 +35 @@
-        else:
-            return output
-
-
-
-
+
-
-class CycleNode(Node):
-r
-[Variable(v) for v in cyclevars]
+l
+cyclevals
-        self.variable_name = variable_name
-
-    def render(self, context):
-
+_safe
-        if self.variable_name:
-            context[self.variable_name] = value
-        return value
@@ -62 +62 @@
-
-    def render(self, context):
-        output = self.nodelist.render(context)
-        # Apply filters.
-        context.update({'var': output})
-(context
+_safe(context, default=''
-        context.pop()
-        return filtered
-
-class FirstOfNode(Node):
-r
-rs = map(Variable, vars)
+l
+ls = vals
-
-    def render(self, context):
-
-
-
-
-
+
+
-            if value:
-smart_unicode(value)
+value
-        return u''
-
-class ForNode(Node):
-_loop
+
-        self.loopvars, self.sequence = loopvars, sequence
-        self.is_reversed = is_reversed
-_loop = nodelist_loop
+ = nodelist
-
-    def __repr__(self):
-        reversed_text = self.is_reversed and ' reversed' or ''
-        return "<For Node: for %s in %s, tail_len: %d%s>" % \
-_loop
+
-             reversed_text)
-
-    def __iter__(self):
-_loop
+
-            yield node
-
-    def get_nodes_by_type(self, nodetype):
-        nodes = []
-        if isinstance(self, nodetype):
-            nodes.append(self)
-        nodes.extend(self.nodelist_loop.get_nodes_by_type(nodetype))
-        return nodes
-
-    def render(self, context):
-nodelist = NodeList()
+result = []
-        if 'forloop' in context:
-            parentloop = context['forloop']
-        else:
-            parentloop = {}
-        context.push()
-
-
-
-
+
-        if values is None:
-            values = []
-        if not hasattr(values, '__len__'):
@@ -144 +130 @@
-                context.update(dict(zip(self.loopvars, item)))
-            else:
-                context[self.loopvars[0]] = item
-_loop
-nodelis
+
+resul
-            if unpack:
-                # The loop variables were pushed on to the context so pop them
-                # off again. This is necessary because the tag lets the length
@@ -154 +140 @@
-                # context.
-                context.pop()
-        context.pop()
-nodelist.render(context
+mark_safe(''.join([force_unicode(b) for b in result])
-
-
-*var
-elf.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
-_
-_varlist = map(Variable, varlist)
-_
+Conditional
+val
+uper(IfChangedNode, self).__init__(nodelist_true, nodelist_false)
+
+vallist = vallist
+
-
-    def render(self, context):
-_
-_
-_
+
+
+
-        try:
-_var
+val
-                # Consider multiple parameters.  This automatically behaves
-                # like an OR evaluation of the multiple variables.
-var.resolve(context) for var in self._var
+expr.resolve(context) for expr in self.val
-            else:
-                compare_to = self.nodelist_true.render(context)
-VariableDoesNotExist
+LookupError
-            compare_to = None
-
-compare_to != self._
-_
-_
+ compare_to != self.
+
+
-            context.push()
-            context['ifchanged'] = {'firstloop': firstloop}
-            content = self.nodelist_true.render(context)
@@ -187 +173 @@
-            return content
-        elif self.nodelist_false:
-            return self.nodelist_false.render(context)
-
+u
-
-
-
-
-
+
+
+
+
+
-        self.negate = negate
-
-
-
+
+
+
-
-    def render(self, context):
-        try:
-            val1 = self.var1.resolve(context)
-        except VariableDoesNotExist:
-            val1 = None
-        try:
-            val2 = self.var2.resolve(context)
-        except VariableDoesNotExist:
-            val2 = None
-        if (self.negate and val1 != val2) or (not self.negate and val1 == val2):
-            return self.nodelist_true.render(context)
-        return self.nodelist_false.render(context)
-
-
+Conditional
-    def __init__(self, bool_exprs, nodelist_true, nodelist_false, link_type):
-
-
-
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-        else:
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-    class LinkTypes:
-        and_ = 0,
-        or_ = 1
-
-class RegroupNode(Node):
-    def __init__(self, target, expression, var_name):
-        self.target, self.expression = target, expression
-        self.var_name = var_name
-
-    def render(self, context):
-(context, True
+_safe(context
-        if obj_list == None:
-            # target variable wasn't found in context; fail silently.
-            context[self.var_name] = []
-
+u
-        # List of dictionaries in the format:
-        # {'grouper': 'key', 'list': [list of contents]}.
-        context[self.var_name] = [
-            {'grouper': key, 'list': list(val)}
-            for key, val in
-: f(v, True
+_safe: f(v
-        ]
-
+u
-
-def include_is_allowed(filepath):
-    for root in settings.ALLOWED_INCLUDE_ROOTS:
@@ -293 +242 @@
-            if settings.DEBUG:
-                return "[Didn't have permission to include file]"
-            else:
-
+u
-        try:
-            fp = open(self.filepath, 'r')
-            output = fp.read()
@@ -308 +257 @@
-                if settings.DEBUG:
-                    return "[Included template had syntax error: %s]" % e
-                else:
-
+u
-        return output
-
-
-
-
+
-
-class NowNode(Node):
-    def __init__(self, format_string):
@@ -323 +270 @@
-        from datetime import datetime
-        from django.utils.dateformat import DateFormat
-        df = DateFormat(datetime.now())
-
+.resolve_safe(context)
-
-class SpacelessNode(Node):
-    def __init__(self, nodelist):
@@ -359 +306 @@
-
-    def render(self, context):
-        from django.core.urlresolvers import reverse, NoReverseMatch
-
-
+_safe
+_safe
-                       for k, v in self.kwargs.items()])
-        
-        
@@ -382 +329 @@
-                    
-        if self.asvar:
-            context[self.asvar] = url
-
+u
-        else:
-            return url
-
@@ -396 +343 @@
-        try:
-            value = self.val_expr.resolve(context)
-            maxvalue = self.max_expr.resolve(context)
-VariableDoesNotExist
-
+LookupError
+u
-        try:
-
-
-
+
-        except (ValueError, ZeroDivisionError):
-
-str
+u
+unicode
-
-class WithNode(Node):
-va
-var = va
-
+exp
+expr = exp
+        
-        self.nodelist = nodelist
-
-    def __repr__(self):
-        return "<WithNode>"
-
-    def render(self, context):
-        val = self.var.resolve(context)
-        context.push()
-val
+self.expr.resolve_safe(context)
-        output = self.nodelist.render(context)
-        context.pop()
-        return output
@@ -434 +375 @@
-    arg = args[1]
-    if arg not in (u'on', u'off'):
-        raise TemplateSyntaxError("'Autoescape' argument should be 'on' or 'off'")
-
-
+
-    return AutoEscapeControlNode((arg == 'on'), nodelist)
-autoescape = register.tag(autoescape)
-
@@ -493 +433 @@
-        # Backwards compatibility: {% cycle a,b %} or {% cycle a,b as foo %}
-        # case.
-        args[1:2] = ['"%s"' % arg for arg in args[1].split(",")]
-
+
-    if len(args) == 2:
-        # {% cycle foo %} case.
-        name = args[1]
@@ -505 +445 @@
-
-    if len(args) > 4 and args[-2] == 'as':
-        name = args[-1]
-
+
+
-        if not hasattr(parser, '_namedCycleNodes'):
-            parser._namedCycleNodes = {}
-        parser._namedCycleNodes[name] = node
-    else:
-
+
+
-    return node
-cycle = register.tag(cycle)
-
@@ -542 +484 @@
-            This text will be HTML-escaped, and will appear in lowercase.
-        {% endfilter %}
-    """
-
-
-
+
+
+
+
+
+
+
-        if getattr(func, '_decorated_function', func).__name__ in ('escape', 'safe'):
-            raise TemplateSyntaxError('"filter %s" is not permitted.  Use the "autoescape" tag instead.' % func.__name__)
-
-
+
-    return FilterNode(filter_expr, nodelist)
-do_filter = register.tag("filter", do_filter)
-
-#@register.tag
-
+
+
-    """
-    Outputs the first variable passed that is not False.
-
@@ -581 +527 @@
-        {% firstof var1 var2 var3 "fallback value" %}
-
-    """
-
-
-
-
-
-
+
+
+
-
-#@register.tag(name="for")
-
+
+
-    """
-    Loops over each item in an array.
-
@@ -628 +572 @@
-        ==========================  ================================================
-
-    """
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
-
-
+
+
+
+
-
-    loopvars = re.sub(r' *, *', ',', ' '.join(bits[1:in_index])).split(',')
-    for var in loopvars:
-        if not var or ' ' in var:
-            raise TemplateSyntaxError("'for' tag received an invalid argument:"
-                                      " %s" % token.contents)
-
-    sequence = parser.compile_filter(bits[in_index+1])
-    nodelist_loop = parser.parse(('endfor',))
-    parser.delete_first_token()
-    return ForNode(loopvars, sequence, is_reversed, nodelist_loop)
-do_for = register.tag("for", do_for)
-
-def do_ifequal(parser, token, negate):
-    bits = list(token.split_contents())
-    if len(bits) != 3:
-        raise TemplateSyntaxError, "%r takes two arguments" % bits[0]
-    end_tag = 'end' + bits[0]
-    nodelist_true = parser.parse(('else', end_tag))
-    token = parser.next_token()
-    if token.contents == 'else':
-        nodelist_false = parser.parse((end_tag,))
-        parser.delete_first_token()
-    else:
-        nodelist_false = NodeList()
-    return IfEqualNode(bits[1], bits[2], nodelist_true, nodelist_false, negate)
-
-#@register.tag
-
+
+
-    """
-    Outputs the contents of the block if the two arguments equal each other.
-
@@ -682 +614 @@
-            ...
-        {% endifnotequal %}
-    """
-token
-ifequal
+bits
+uses_token_stream(ifequal)
-
-#@register.tag
-
+
+
-    """
-    Outputs the contents of the block if the two arguments are not equal.
-    See ifequal.
-    """
-token
-ifnotequal
+bits
+uses_token_stream(ifnotequal)
-
-#@register.tag(name="if")
-
+
+
-    """
-    The ``{% if %}`` tag evaluates a variable, and if that variable is "true"
-    (i.e., exists, is not empty, and is not a false boolean value), the
@@ -753 +687 @@
-            {% endif %}
-        {% endif %}
-    """
-
-
-
-
-
-
-
+
+
-    boolvars = []
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-        else:
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    return IfNode(boolvars, nodelist_true, nodelist_false, link_type)
-do_if
+uses_token_stream(do_if)
-
-#@register.tag
-
+
+
-    """
-    Checks if a value has changed from the last iteration of a loop.
-
@@ -817 +741 @@
-                    {{ date.hour }}
-                {% endifchanged %}
-            {% endfor %}
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-
-#@register.tag
-def ssi(parser, token):
@@ -882 +800 @@
-load = register.tag(load)
-
-#@register.tag
-
+
+
-    """
-    Displays the date, formatted according to the given string.
-
@@ -893 +812 @@
-
-        It is {% now "jS F Y H:i" %}
-    """
-
-
-
-
+
-    return NowNode(format_string)
-now
+uses_token_stream(now)
-
-#@register.tag
-
+
+
-    """
-    Regroups a list of alike objects by a common attribute.
-
@@ -947 +864 @@
-        {% regroup people|dictsort:"gender" by gender as grouped %}
-
-    """
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-    return RegroupNode(target, expression, var_name)
-regroup
+uses_token_stream(regroup)
-
-def spaceless(parser, token):
-    """
@@ -989 +900 @@
-            </strong>
-        {% endspaceless %}
-    """
-
-
-
+
-spaceless = register.tag(spaceless)
-
-#@register.tag
@@ -1028 +937 @@
-    return TemplateTagNode(tag)
-templatetag = register.tag(templatetag)
-
-
+
+
+
-    """
-    Returns an absolute URL matching given view with its parameters.
-
@@ -1059 +970 @@
-
-    The URL will look like ``/clients/client/123/``.
-    """
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-
-#@register.tag
-
+
+
-    """
-    For creating bar charts and such, this tag calculates the ratio of a given
-    value to a maximum value, and then applies that ratio to a constant.
@@ -1099 +994 @@
-    the above example will be 88 pixels wide (because 175/200 = .875;
-    .875 * 100 = 87.5 which is rounded up to 88).
-    """
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-
-#@register.tag
-
+
+
-    """
-    Adds a value to the context (inside of this block) for caching and easy
-    access.
@@ -1122 +1011 @@
-        {% with person.some_sql_method as total %}
-            {{ total }} object{{ total|pluralize }}
-        {% endwith %}
+        
-    """
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+

django/template/compat.py

@@ +1 @@
+import warnings
+from django.template.expressions import Expression, LookupError
+from django.template.compiler import TemplateSyntaxError
+from django.template.nodes import ExpressionNode
+
+VariableDoesNotExist = LookupError
+VariableNode = ExpressionNode
+
+class Variable(Expression):
+    def __init__(self, var):
+        warnings.warn('Use Lookup instead of Variable.', DeprecationWarning, stacklevel=2)    
+        self.var = var
+        from django.template.compiler import TokenStream
+        stream = TokenStream(None, var)
+        self.expression = stream.parse_value()
+        stream.assert_consumed("Invalid variable: %s" % var)
+
+    def resolve(self, context):
+        return self.expression.resolve(context)
+
+    def __repr__(self):
+        return "<%s: %r>" % (self.__class__.__name__, self.var)
+
+    def __str__(self):
+        return self.var
+        
+
+def resolve_variable(path, context):
+    """
+    Returns the resolved variable, which may contain attribute syntax, within
+    the given context.
+
+    Deprecated.
+    """
+    warnings.warn('Use Lookup instead of resolve_variable.', DeprecationWarning, stacklevel=2)
+    from django.template.compiler import TokenStream
+    stream = TokenStream(None, path)
+    val = stream.parse_value()
+    stream.assert_consumed("Invalid variable: %s" % path)    
+    return val.resolve(context)
+
+
+class TokenParser(object):
+    """
+    Subclass this and implement the top() method to parse a template line. When
+    instantiating the parser, pass in the line from the Django template parser.
+
+    The parser's "tagname" instance-variable stores the name of the tag that
+    the filter was called with.
+    """
+    def __init__(self, subject):
+        self.subject = subject
+        self.pointer = 0
+        self.backout = []
+        self.tagname = self.tag()
+
+    def top(self):
+        "Overload this method to do the actual parsing and return the result."
+        raise NotImplementedError()
+
+    def more(self):
+        "Returns True if there is more stuff in the tag."
+        return self.pointer < len(self.subject)
+
+    def back(self):
+        "Undoes the last microparser. Use this for lookahead and backtracking."
+        if not len(self.backout):
+            raise TemplateSyntaxError("back called without some previous parsing")
+        self.pointer = self.backout.pop()
+
+    def tag(self):
+        "A microparser that just returns the next tag from the line."
+        subject = self.subject
+        i = self.pointer
+        if i >= len(subject):
+            raise TemplateSyntaxError("expected another tag, found end of string: %s" % subject)
+        p = i
+        while i < len(subject) and subject[i] not in (' ', '\t'):
+            i += 1
+        s = subject[p:i]
+        while i < len(subject) and subject[i] in (' ', '\t'):
+            i += 1
+        self.backout.append(self.pointer)
+        self.pointer = i
+        return s
+
+    def value(self):
+        "A microparser that parses for a value: some string constant or variable name."
+        subject = self.subject
+        i = self.pointer
+        if i >= len(subject):
+            raise TemplateSyntaxError("Searching for value. Expected another value but found end of string: %s" % subject)
+        if subject[i] in ('"', "'"):
+            p = i
+            i += 1
+            while i < len(subject) and subject[i] != subject[p]:
+                i += 1
+            if i >= len(subject):
+                raise TemplateSyntaxError("Searching for value. Unexpected end of string in column %d: %s" % (i, subject))
+            i += 1
+            res = subject[p:i]
+            while i < len(subject) and subject[i] in (' ', '\t'):
+                i += 1
+            self.backout.append(self.pointer)
+            self.pointer = i
+            return res
+        else:
+            p = i
+            while i < len(subject) and subject[i] not in (' ', '\t'):
+                if subject[i] in ('"', "'"):
+                    c = subject[i]
+                    i += 1
+                    while i < len(subject) and subject[i] != c:
+                        i += 1
+                    if i >= len(subject):
+                        raise TemplateSyntaxError("Searching for value. Unexpected end of string in column %d: %s" % (i, subject))
+                i += 1
+            s = subject[p:i]
+            while i < len(subject) and subject[i] in (' ', '\t'):
+                i += 1
+            self.backout.append(self.pointer)
+            self.pointer = i
+            return s

django/template/loader_tags.py

@@ -1 @@
-
-
-
+
+
+
+
-from django.conf import settings
-from django.utils.safestring import mark_safe
-
@@ -28 +29 @@
-    def super(self):
-        if self.parent:
-            return mark_safe(self.parent.render(self.context))
-
+u
-
-    def add_parent(self, nodelist):
-        if self.parent:
@@ -39 +40 @@
-class ExtendsNode(Node):
-    must_be_first = True
-
-parent_name_expr, 
+
-        self.nodelist = nodelist
-, self.parent_name_expr = parent_name, parent_name_expr
+ = parent_name
-        self.template_dirs = template_dirs
-
-    def __repr__(self):
-        if self.parent_name_expr:
-            return "<ExtendsNode: extends %s>" % self.parent_name_expr.token
-        return '<ExtendsNode: extends "%s">' % self.parent_name
-
-    def get_parent(self, context):
-
-
-
+
-        if not parent:
-            error_msg = "Invalid template name in 'extends' tag: %r." % parent
-            if self.parent_name_expr:
-                error_msg += " Got this from the '%s' variable." % self.parent_name_expr.token
-            raise TemplateSyntaxError, error_msg
-        if hasattr(parent, 'render'):
-            return parent # parent is a Template object
@@ -114 +109 @@
-
-class IncludeNode(Node):
-    def __init__(self, template_name):
-Variable(template_name)
+template_name
-
-    def render(self, context):
-        try:
-
+_safe
-            t = get_template(template_name)
-            return t.render(context)
-        except TemplateSyntaxError, e:
-            if settings.TEMPLATE_DEBUG:
-                raise
-
+u
-        except:
-
+u
-
+
+#@register.tag('block')
-def do_block(parser, token):
-    """
-    Define a block that can be overridden by child templates.
@@ -144 +141 @@
-        parser.__loaded_blocks.append(block_name)
-    except AttributeError: # parser.__loaded_blocks isn't a list yet
-        parser.__loaded_blocks = [block_name]
-
-
+
-    return BlockNode(block_name, nodelist)
+register.tag('block', do_block)
-
-
+
+
+
+
-    """
-    Signal that this template extends a parent template.
-
-    This tag may be used in two ways: ``{% extends "base" %}`` (with quotes)
-    uses the literal value "base" as the name of the parent template to extend,
-variable %}`` uses the value of ``variable
+expression %}`` uses the value of ``expression
-    name of the parent template to extend (if it evaluates to a string) or as
-    the parent tempate itelf (if it evaluates to a Template object).
-    """
-
-
-
-
-
-
-
-
+
-    nodelist = parser.parse()
-    if nodelist.get_nodes_by_type(ExtendsNode):
-
-
+
+
+
-
-
+
+
+
+
-    """
-    Loads a template and renders it with the current context.
-
@@ -179 +176 @@
-
-        {% include "foo/some_include" %}
-    """
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+

django/template/library.py

@@ +1 @@
+import re
+from inspect import getargspec
+from django.conf import settings
+from django.template.context import Context
+from django.template.nodes import Node
+from django.template.compiler import TemplateSyntaxError
+from django.utils.itercompat import is_iterable
+from django.utils.functional import curry
+
+__all__ = ('InvalidTemplateLibrary', 'Library', 'get_library', 'add_to_builtins')
+
+# global dictionary of libraries that have been loaded using get_library
+libraries = {}
+# global list of libraries to load by default for a new parser
+builtins = []
+
+class InvalidTemplateLibrary(Exception):
+    pass
+
+def generic_tag_compiler(params, defaults, name, node_class, parser, token, takes_context=False, takes_nodelist=False):
+    "Returns a template.Node subclass."
+    bits = parser.token_stream(token)
+    bmax = len(params)
+    def_len = defaults and len(defaults) or 0
+    bmin = bmax - def_len
+    args = stream.parse_expression_list(minimum=bmin, maximum=bmax)
+    stream.assert_comsumed()
+    if takes_context:
+        node_class = curry(node_class, takes_context=takes_context) 
+    if takes_nodelist:
+        nodelist = parser.parse_nodelist(('end%s' % name,)) 
+        node_class = curry(node_class, nodelist=nodelist)     
+    return node_class(args)
+
+class Library(object):
+    def __init__(self):
+        self.filters = {}
+        self.tags = {}
+
+    def tag(self, name=None, compile_function=None):
+        if name == None and compile_function == None:
+            # @register.tag()
+            return self.tag_function
+        elif name != None and compile_function == None:
+            if(callable(name)):
+                # @register.tag
+                return self.tag_function(name)
+            else:
+                # @register.tag('somename') or @register.tag(name='somename')
+                def dec(func):
+                    return self.tag(name, func)
+                return dec
+        elif name != None and compile_function != None:
+            # register.tag('somename', somefunc)
+            self.tags[name] = compile_function
+            return compile_function
+        else:
+            raise InvalidTemplateLibrary("Unsupported arguments to Library.tag: (%r, %r)", (name, compile_function))
+
+    def tag_function(self,func):
+        self.tags[getattr(func, "_decorated_function", func).__name__] = func
+        return func
+
+    def filter(self, name=None, filter_func=None):
+        if name == None and filter_func == None:
+            # @register.filter()
+            return self.filter_function
+        elif filter_func == None:
+            if(callable(name)):
+                # @register.filter
+                return self.filter_function(name)
+            else:
+                # @register.filter('somename') or @register.filter(name='somename')
+                def dec(func):
+                    return self.filter(name, func)
+                return dec
+        elif name != None and filter_func != None:
+            # register.filter('somename', somefunc)
+            self.filters[name] = filter_func
+            return filter_func
+        else:
+            raise InvalidTemplateLibrary("Unsupported arguments to Library.filter: (%r, %r)", (name, filter_func))
+
+    def filter_function(self, func):
+        self.filters[getattr(func, "_decorated_function", func).__name__] = func
+        return func
+
+    def simple_tag(self, compile_function=None):
+        def dec(func):
+            params, xx, xxx, defaults = getargspec(func)
+
+            class SimpleNode(Node):
+                def __init__(self, args): 
+                    self.args = args
+
+                def render(self, context):
+                    return func(*[arg.resolve_safe(context) for arg in self.args])
+
+            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, SimpleNode)
+            compile_func.__doc__ = func.__doc__
+            self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
+            return func
+        
+        if callable(compile_function):
+            # @register.simple_tag
+            return dec(compile_function)
+        return dec
+
+    def inclusion_tag(self, file_name, context_class=Context, takes_context=False):
+        def dec(func):
+            params, xx, xxx, defaults = getargspec(func)
+            if takes_context:
+                if params[0] == 'context':
+                    params = params[1:]
+                else:
+                    raise TemplateSyntaxError("Any tag function decorated with takes_context=True must have a first argument of 'context'")
+
+            class InclusionNode(Node):
+                def __init__(self, args):
+                    self.args = args
+
+                def render(self, context):
+                    resolved_vars = [arg.resolve_safe(context) for arg in self.args]
+                    if takes_context:
+                        args = [context] + resolved_vars
+                    else:
+                        args = resolved_vars
+
+                    dict = func(*args)
+
+                    if not getattr(self, 'nodelist', False):
+                        from django.template.loader import get_template, select_template
+                        if not isinstance(file_name, basestring) and is_iterable(file_name):
+                            t = select_template(file_name)
+                        else:
+                            t = get_template(file_name)
+                        self.nodelist = t.nodelist
+                    return self.nodelist.render(context_class(dict, autoescape=context.autoescape))
+
+            compile_func = curry(generic_tag_compiler, params, defaults, getattr(func, "_decorated_function", func).__name__, InclusionNode)
+            compile_func.__doc__ = func.__doc__
+            self.tag(getattr(func, "_decorated_function", func).__name__, compile_func)
+            return func
+        return dec
+
+def get_library(module_name):
+    lib = libraries.get(module_name, None)
+    if not lib:
+        try:
+            mod = __import__(module_name, {}, {}, [''])
+        except ImportError, e:
+            raise InvalidTemplateLibrary("Could not load template library from %s, %s" % (module_name, e))
+        try:
+            lib = mod.register
+            libraries[module_name] = lib
+        except AttributeError:
+            raise InvalidTemplateLibrary("Template library %s does not have a variable named 'register'" % module_name)
+    return lib
+
+def add_to_builtins(module_name):
+    builtins.append(get_library(module_name))

django/template/debug.py

@@ -1 @@
-
-
-
-
+
+
+
-
-class DebugLexer(Lexer):
-    def __init__(self, template_string, origin):
@@ -50 +49 @@
-        return DebugNodeList()
-
-    def create_variable_node(self, contents):
-Variable
+Expression
-
-    def extend_nodelist(self, nodelist, node, token):
-        node.source = token.source
@@ -65 +64 @@
-        if not hasattr(e, 'source'):
-            e.source = token.source
-
+    def token_stream(self, token):
+        return DebugTokenStream(self, token)
+
+
-class DebugNodeList(NodeList):
-    def render_node(self, node, context):
-        try:
@@ -81 +84 @@
-            raise wrapped
-        return result
-
-VariableNode(Variable
+ExpressionNode(Expression
-    def render(self, context):
-        try:
-output = force_unicode(self.filter_expression.resolve(context)
+return super(DebugExpressionNode, self).render(context
-        except TemplateSyntaxError, e:
-            if not hasattr(e, 'source'):
-                e.source = self.source
-            raise
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+

django/template/loader.py

@@ -21 +21 @@
-# installed, because pkg_resources is necessary to read eggs.
-
-from django.core.exceptions import ImproperlyConfigured
-TemplateDoesNotExist, 
+
-from django.conf import settings
-
-template_source_loaders = None
-
+class TemplateDoesNotExist(Exception):
+    pass
+
-class LoaderOrigin(Origin):
-    def __init__(self, display_name, loader, name, dirs):
-        super(LoaderOrigin, self).__init__(display_name)

tests/regressiontests/templates/tests.py

@@ -132 +132 @@
-
-    def test_token_smart_split(self):
-        # Regression test for #7027
-Token(template
+compiler.Token(template.compiler
-        split = token.split_contents()
-        self.assertEqual(split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")'])
-
@@ -194 +194 @@
-                    output = self.render(test_template, vals)
-                except Exception, e:
-                    if e.__class__ != result:
-
+#
-                        failures.append("Template test (TEMPLATE_STRING_IF_INVALID='%s'): %s -- FAILED. Got %s, exception: %s" % (invalid_str, name, e.__class__, e))
-                    continue
-                if output != result:
@@ -288 +288 @@
-            'basic-syntax25': ('{{ "fred" }}', {}, "fred"),
-            'basic-syntax26': (r'{{ "\"fred\"" }}', {}, "\"fred\""),
-            'basic-syntax27': (r'{{ _("\"fred\"") }}', {}, "\"fred\""),
+            'basic-syntax28': ("{{ 'fred' }}", {}, "fred"), 
+            'basic-syntax29': (r"{{ '\'fred\'' }}", {}, "'fred'"), 
+            'basic-syntax30': (r"{{ _('\'fred\'') }}", {}, "'fred'"), 
-
-            # List-index syntax allows a template to access a certain item of a subscriptable object.
-            'list-index01': ("{{ var.1 }}", {"var": ["first item", "second item"]}, "second item"),
@@ -347 +350 @@
-            'filter-syntax11': (r'{{ var|default_if_none:var2 }}', {"var": None, "var2": "happy"}, 'happy'),
-
-            # Default argument testing
-
+            
-
-            # Fail silently for methods that raise an exception with a
-            # "silent_variable_failure" attribute
@@ -375 +378 @@
-            
-            #filters should accept empty string constants
-            'filter-syntax20': ('{{ ""|default_if_none:"was none" }}', {}, ""),
+            
+            # Single-quoted argument
+            'filter-syntax20': (r"{{ var|yesno:'yup,nup,mup' }} {{ var|yesno }}", {"var": True}, 'yup yes'),             
-
-            ### COMMENT SYNTAX ########################################################
-            'comment-syntax01': ("{# this is hidden #}hello", {}, "hello"),
@@ -419 +425 @@
-            'cycle14': ("{% cycle one two as foo %}{% cycle foo %}", {'one': '1','two': '2'}, '12'),
-            'cycle13': ("{% for i in test %}{% cycle aye bee %}{{ i }},{% endfor %}", {'test': range(5), 'aye': 'a', 'bee': 'b'}, 'a0,b1,a2,b3,a4,'),
-
+            ### EMPTY STRINGS ######################################################### 
+            'emptystring01': ("{{ '' }}", {}, ""), 
+            'emptystring02': ("{% ifequal foo '' %}x{% endifequal %}", {'foo': ''}, 'x'), 
+            'emptystring03': ("{% ifequal foo|default:'' foo %}x{% endifequal %}", {'foo': ''}, 'x'), 
+
-            ### EXCEPTIONS ############################################################
-
-            # Raise exception for invalid template name
@@ -621 +632 @@
-            'ifequal-numeric10': ('{% ifequal x -5 %}yes{% endifequal %}', {'x': -5}, 'yes'),
-            'ifequal-numeric11': ('{% ifequal x -5.2 %}yes{% endifequal %}', {'x': -5.2}, 'yes'),
-            'ifequal-numeric12': ('{% ifequal x +5 %}yes{% endifequal %}', {'x': 5}, 'yes'),
+            
+            # FILTER EXPRESSIONS AS ARGUMENTS
+            'ifequal-filter01': ('{% ifequal a|upper "A" %}x{% endifequal %}', {'a': 'a'}, 'x'), 
+            'ifequal-filter02': ('{% ifequal "A" a|upper %}x{% endifequal %}', {'a': 'a'}, 'x'), 
+            'ifequal-filter03': ('{% ifequal a|upper b|upper %}x{% endifequal %}', {'a': 'x', 'b': 'X'}, 'x'), 
+            'ifequal-filter04': ('{% ifequal x|slice:"1" "a" %}x{% endifequal %}', {'x': 'aaa'}, 'x'), 
+            'ifequal-filter05': ('{% ifequal x|slice:"1"|upper "A" %}x{% endifequal %}', {'x': 'aaa'}, 'x'),             
-
-            ### IFNOTEQUAL TAG ########################################################
-            'ifnotequal01': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 2}, "yes"),
@@ -816 +834 @@
-                            you
-                            gentlemen.
-                            """),
+                            
+            ### NEGATIVE NUMERIC LITERALS #############################################                             
+            'negative-numeric-literal01': ('{{ -1 }}', {}, '-1'), 
+            'negative-numeric-literal02': ('{{ -2.01 }}', {}, '-2.01'), 
+            'negative-numeric-literal03': ('{{ -0.1 }}', {}, '-0.1'), 
+            'negative-numeric-literal04': ('{% ifequal -1 -1 %}x{% endifequal %}', {}, 'x'), 
+            'negative-numeric-literal05': ('{{ foo|default:-1 }}', {'foo': None}, '-1'),                            
-
-            ### REGROUP TAG ###########################################################
-            'regroup01': ('{% regroup data by bar as grouped %}' + \
@@ -841 +866 @@
-                          '{% endfor %},' + \
-                          '{% endfor %}',
-                          {}, ''),
+                          
+            'regroup03': ('{% regroup data by created|date:"F Y" as grouped %}' + \
+                          '{% for group in grouped %}' + \
+                          '{{ group.grouper }}' + \
+                          '({% for item in group.list %}' + \
+                          '{{ item.created|date:"d" }}' + \
+                          '{% endfor %})' + \
+                          '{% endfor %}',
+                          {'data': [ 
+                                {'created': datetime(2008, 1, 1)}, 
+                                {'created': datetime(2008, 2, 2)}, 
+                                {'created': datetime(2008, 3, 3)}, 
+                                {'created': datetime(2008, 4, 4)}, 
+                          ]}, 'January 2008(01)February 2008(02)March 2008(03)April 2008(04)'),
-
-            ### TEMPLATETAG TAG #######################################################
-            'templatetag01': ('{% templatetag openblock %}', {}, '{%'),
@@ -902 +941 @@
-            'url07': (u'{% url regressiontests.templates.views.client2 tag=v %}', {'v': u'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
-            'url08': (u'{% url метка_оператора v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
-            'url09': (u'{% url метка_оператора_2 tag=v %}', {'v': 'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'),
+            'url10': (u'{% url "метка_оператора" v %}', {'v': u'Ω'}, '/url_tag/%D0%AE%D0%BD%D0%B8%D0%BA%D0%BE%D0%B4/%CE%A9/'), 
-
-            # Failures
-            'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),