Ticket #7806: tplrf-r8970.diff

django/templatetags/i18n.py

@@ -1 +1 @@
 import re
 
-from django.template import Node, Variable, VariableNode
-from django.template import TemplateSyntaxError, TokenParser, Library
-from django.template import TOKEN_TEXT, TOKEN_VAR
+from django.template import Node, VariableNode, TokenParser, Variable, TemplateSyntaxError, Library
+from django.template.compiler import uses_token_stream, TOKEN_TEXT, TOKEN_VAR
 from django.utils import translation
 from django.utils.encoding import force_unicode
 
@@ -35 +34 @@
 
 class TranslateNode(Node):
     def __init__(self, value, noop):
-        self.value = Variable(value)
+        self.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])
 
-def do_translate(parser, token):
+
+#@uses_token_stream
+def do_translate(parser, bits):
     """
     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.
     """
-    class TranslateParser(TokenParser):
-        def top(self):
-            value = self.value()
-            if self.more():
-                if self.tag() == 'noop':
-                    noop = True
-                else:
-                    raise TemplateSyntaxError, "only option for 'trans' is 'noop'"
-            else:
-                noop = False
-            return (value, noop)
-    value, noop = TranslateParser(token.contents).top()
+    value = bits.parse_expression(required=True)
+    noop = bits.pop_lexem('noop')
     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)
-register.tag('trans', do_translate)
+register.tag('trans', )
 register.tag('blocktrans', do_block_translate)

django/templatetags/cache.py

@@ -1 @@
-from django.template import Library, Node, TemplateSyntaxError, Variable, VariableDoesNotExist
-from django.template import resolve_variable
+from django.template import Library, Node, TemplateSyntaxError, Variable
+from django.template
 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
-        self.expire_time_var = Variable(expire_time_var)
+        self.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.
-        cache_key = u':'.join([self.fragment_name] + [urlquote(resolve_variable(var, context)) for var in self.vary_on])
+        cache_key = u':'.join([self.fragment_name] + [urlquote(context)) for var in self.vary_on])
         value = cache.get(cache_key)
         if value is None:
             value = self.nodelist.render(context)
             cache.set(cache_key, value, expire_time)
         return value
 
-def do_cache(parser, token):
+def do_cache(parser, ):
     """
     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.
     """
-    nodelist = parser.parse(('endcache',))
-    parser.delete_first_token()
-    tokens = token.contents.split()
-    if len(tokens) < 3:
-        raise TemplateSyntaxError(u"'%r' tag requires at least 2 arguments." % tokens[0])
-    return CacheNode(nodelist, tokens[1], tokens[2], tokens[3:])
+    nodelist = parser.parse_nodelist(('endcache',))
+    expire_time = bits.parse_expression(required=True)
+    name = bits.pop_name()
+    if not name:
+        raise TemplateSyntaxError, "'cache' requires a fragment name"    
+    vary_on = bits.parse_expression_list()
+    return CacheNode(nodelist, expire_time, name, vary_on)
 
-register.tag('cache', do_cache)
+register.tag('cache', )

django/template/nodes.py

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/template/compiler.py

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/template/__init__.py

@@ -12 +12 @@
 Node objects.
 
 Each Node is responsible for creating some sort of output -- e.g. simple text
-(TextNode), variable values in a given context (VariableNode), results of basic
+(TextNode), variable values in a given context (Node), results of basic
 logic (IfNode), results of looping (ForNode), or anything else. The core Node
-types are TextNode, VariableNode, IfNode and ForNode, but plugin modules can
+types are TextNode, Node, IfNode and ForNode, but plugin modules can
 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>'
 """
-import re
-from inspect import getargspec
-from django.conf import settings
+
 from django.template.context import Context, RequestContext, ContextPopException
-from django.utils.itercompat import is_iterable
-from django.utils.functional import curry, Promise
-from django.utils.text import smart_split
-from django.utils.encoding import smart_unicode, force_unicode
-from django.utils.translation import ugettext as _
-from django.utils.safestring import SafeData, EscapeData, mark_safe, mark_for_escaping
-from django.utils.html import escape
+from django.template.nodes import Node, NodeList, TextNode, ExpressionNode
+from django.template.compiler import Origin, StringOrigin, Template, \
+    TemplateSyntaxError, compile_string, TokenSyntaxError
+from django.template.library import Library, InvalidTemplateLibrary, \
+    get_library, add_to_builtins, libraries
+from django.template.expressions import Expression, LookupError
 
-__all__ = ('Template', 'Context', 'RequestContext', 'compile_string')
+#backcompat
+from django.template.compat import Variable, VariableDoesNotExist, VariableNode, \
+    resolve_variable, TokenParser
+from django.template.loader import TemplateDoesNotExist
 
-TOKEN_TEXT = 0
-TOKEN_VAR = 1
-TOKEN_BLOCK = 2
-TOKEN_COMMENT = 3
+__all__ = (
+    'Template', 'TemplateSyntaxError', 'compile_string', 'Origin', 'TokenSyntaxError',
+    'Context', 'RequestContext',
+    'Expression', 'LookupError',
+    #FIXME: should these be public? 'Literal', 'Lookup', 'FilterExpression'
+    'Library', 'InvalidTemplateLibrary', 'get_library', 'add_to_builtins', 'libraries',
+    #backcompat
+    'Variable', 'VariableDoesNotExist', 'resolve_variable', 'TemplateDoesNotExist', 'TokenParser', 'VariableNode',
+)
 
-# 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 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/template/expressions.py

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/template/defaulttags.py

@@ -8 +8 @@
 except NameError:
     from django.utils.itercompat import reversed     # Python 2.3 fallback
 
-from django.template import Node, NodeList, Template, Context, Variable
-from django.template import TemplateSyntaxError, 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
+from django.template import Node, NodeList, Template, Context
+from django.template import TemplateSyntaxError, 
 from django.template import get_library, Library, InvalidTemplateLibrary
+
+
 from django.conf import settings
-from django.utils.encoding import smart_str, smart_unicode
+from django.utils.encoding import smart_str, _unicode
 from django.utils.itercompat import groupby
 from django.utils.safestring import mark_safe
 
@@ -33 +35 @@
         else:
             return output
 
-class CommentNode(Node):
-    def render(self, context):
-        return ''
+class CommentNode(EmptyNode): pass
 
 class CycleNode(Node):
-    def __init__(self, cyclevars, variable_name=None):
-        self.cycle_iter = itertools_cycle([Variable(v) for v in cyclevars])
+    def __init__(self, cyclevas, variable_name=None):
+        self.cycle_iter = itertools_cycle()
         self.variable_name = variable_name
 
     def render(self, context):
-        value = self.cycle_iter.next().resolve(context)
+        value = self.cycle_iter.next().resolve(context)
         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})
-        filtered = self.filter_expr.resolve(context)
+        filtered = self.filter_expr.resolve)
         context.pop()
         return filtered
 
 class FirstOfNode(Node):
-    def __init__(self, vars):
-        self.vars = map(Variable, vars)
+    def __init__(self, vas):
+        self.va
 
     def render(self, context):
-        for var in self.vars:
-            try:
-                value = var.resolve(context)
-            except VariableDoesNotExist:
-                continue
+        for val in self.vals:
+            value = val.resolve_safe(context)
             if value:
-                return smart_unicode(value)
+                return 
         return u''
 
 class ForNode(Node):
-    def __init__(self, loopvars, sequence, is_reversed, nodelist_loop):
+    def __init__(self, loopvars, sequence, is_reversed, nodelist):
         self.loopvars, self.sequence = loopvars, sequence
         self.is_reversed = is_reversed
-        self.nodelist_loop = nodelist_loop
+        self.nodelist
 
     def __repr__(self):
         reversed_text = self.is_reversed and ' reversed' or ''
         return "<For Node: for %s in %s, tail_len: %d%s>" % \
-            (', '.join(self.loopvars), self.sequence, len(self.nodelist_loop),
+            (', '.join(self.loopvars), self.sequence, len(self.nodelist),
              reversed_text)
 
     def __iter__(self):
-        for node in self.nodelist_loop:
+        for node in self.nodelist:
             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()
+        
         if 'forloop' in context:
             parentloop = context['forloop']
         else:
             parentloop = {}
         context.push()
-        try:
-            values = self.sequence.resolve(context, True)
-        except VariableDoesNotExist:
-            values = []
+        values = self.sequence.resolve_safe(context, default=[])
         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
-            for node in self.nodelist_loop:
-                nodelist.append(node.render(context))
+            for node in self.nodelist:
+                t.append(node.render(context))
             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()
-        return nodelist.render(context)
+        return )
 
-class IfChangedNode(Node):
-    def __init__(self, nodelist_true, nodelist_false, *varlist):
-        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
-        self._last_seen = None
-        self._varlist = map(Variable, varlist)
-        self._id = str(id(self))
+class IfChangedNode(Node):
+    def __init__(self, nodelist_true, nodelist_false, list):
+        s
+        self.last_seen = None
+        self.
+        self.id = str(id(self))
 
     def render(self, context):
-        if 'forloop' in context and self._id not in context['forloop']:
-            self._last_seen = None
-            context['forloop'][self._id] = 1
+        if 'forloop' in context and self.id not in context['forloop']:
+            self.last_seen = None
+            context['forloop'][self.id] = 1
         try:
-            if self._varlist:
+            if self.list:
                 # Consider multiple parameters.  This automatically behaves
                 # like an OR evaluation of the multiple variables.
-                compare_to = [var.resolve(context) for var in self._varlist]
+                compare_to = [list]
             else:
                 compare_to = self.nodelist_true.render(context)
-        except VariableDoesNotExist:
+        except :
             compare_to = None
 
-        if compare_to != self._last_seen:
-            firstloop = (self._last_seen == None)
-            self._last_seen = compare_to
+        if last_seen:
+            firstloop = (self.last_seen == None)
+            self.last_seen = compare_to
             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)
-        return ''
+        return ''
 
-class IfEqualNode(Node):
-    def __init__(self, var1, var2, nodelist_true, nodelist_false, negate):
-        self.var1, self.var2 = Variable(var1), Variable(var2)
-        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
+
+class IfEqualNode(ConditionalNode):
+    def __init__(self, val1, val2, nodelist_true, nodelist_false, negate):
+        super(IfEqualNode, self).__init__(nodelist_true, nodelist_false)
+        self.val1, self.val2 = val1, val2
         self.negate = negate
 
-    def __repr__(self):
-        return "<IfEqualNode>"
+    def check_condition(self, context):
+        val1, val2 = self.val1.resolve_safe(context), self.val2.resolve_safe(context)
+        return self.negate == (val1 != val2)
 
-    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)
 
-class IfNode(Node):
+class IfNode(Node):
     def __init__(self, bool_exprs, nodelist_true, nodelist_false, link_type):
-        self.bool_exprs = bool_exprs
-        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
-        self.link_type = link_type
+        super(IfNode, self).__init__(nodelist_true, nodelist_false)
+        self.bool_exprs, self.link_type = bool_exprs, link_type
 
-    def __repr__(self):
-        return "<If node>"
-
-    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 render(self, context):
-        if self.link_type == IfNode.LinkTypes.or_:
-            for ifnot, bool_expr in self.bool_exprs:
-                try:
-                    value = bool_expr.resolve(context, True)
-                except VariableDoesNotExist:
-                    value = None
-                if (value and not ifnot) or (ifnot and not value):
-                    return self.nodelist_true.render(context)
-            return self.nodelist_false.render(context)
+    def check_condition(self, context):
+        if self.link_type == 'or':
+            for negated, bool_expr in self.bool_exprs:
+                value = bool_expr.resolve_safe(context, default=False)
+                if bool(value) != negated:
+                    return True
+            return False
         else:
-            for ifnot, bool_expr in self.bool_exprs:
-                try:
-                    value = bool_expr.resolve(context, True)
-                except VariableDoesNotExist:
-                    value = None
-                if not ((value and not ifnot) or (ifnot and not value)):
-                    return self.nodelist_false.render(context)
-            return self.nodelist_true.render(context)
+            for negated, bool_expr in self.bool_exprs:
+                value = bool_expr.resolve_safe(context, default=False)
+                if bool(value) == negated:
+                    return False
+            return True
+        
 
-    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):
-        obj_list = self.target.resolve(context, True)
+        obj_list = self.target.resolve)
         if obj_list == None:
             # target variable wasn't found in context; fail silently.
             context[self.var_name] = []
-            return ''
+            return ''
         # 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
-            groupby(obj_list, lambda v, f=self.expression.resolve: f(v, True))
+            groupby(obj_list, lambda v, f=self.expression.resolve))
         ]
-        return ''
+        return ''
 
 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:
-                return '' # Fail silently for invalid includes.
+                return '' # Fail silently for invalid includes.
         try:
             fp = open(self.filepath, 'r')
             output = fp.read()
@@ -308 +257 @@
                 if settings.DEBUG:
                     return "[Included template had syntax error: %s]" % e
                 else:
-                    return '' # Fail silently for invalid included templates.
+                    return '' # Fail silently for invalid included templates.
         return output
 
-class LoadNode(Node):
-    def render(self, context):
-        return ''
+class LoadNode(EmptyNode): pass
 
 class NowNode(Node):
     def __init__(self, format_string):
@@ -323 +270 @@
         from datetime import datetime
         from django.utils.dateformat import DateFormat
         df = DateFormat(datetime.now())
-        return df.format(self.format_string)
+        return df.format(self.format_string)
 
 class SpacelessNode(Node):
     def __init__(self, nodelist):
@@ -359 +306 @@
 
     def render(self, context):
         from django.core.urlresolvers import reverse, NoReverseMatch
-        args = [arg.resolve(context) for arg in self.args]
-        kwargs = dict([(smart_str(k,'ascii'), v.resolve(context))
+        args = [arg.resolve(context) for arg in self.args]
+        kwargs = dict([(smart_str(k,'ascii'), v.resolve(context))
                        for k, v in self.kwargs.items()])
         
         
@@ -382 +329 @@
                     
         if self.asvar:
             context[self.asvar] = url
-            return ''
+            return ''
         else:
             return url
 
@@ -396 +343 @@
         try:
             value = self.val_expr.resolve(context)
             maxvalue = self.max_expr.resolve(context)
-        except VariableDoesNotExist:
-            return ''
+        except :
+            return ''
         try:
-            value = float(value)
-            maxvalue = float(maxvalue)
-            ratio = (value / maxvalue) * int(self.max_width)
+            ratio = (float(value) / float(maxvalue)) * int(self.max_width)
         except (ValueError, ZeroDivisionError):
-            return ''
-        return str(int(round(ratio)))
+            return ''
+        return (int(round(ratio)))
 
 class WithNode(Node):
-    def __init__(self, var, name, nodelist):
-        self.var = var
-        self.name = name
+    def __init__(self, r, name, nodelist):
+        self.r
+        self.name = name
         self.nodelist = nodelist
 
-    def __repr__(self):
-        return "<WithNode>"
-
     def render(self, context):
-        val = self.var.resolve(context)
         context.push()
-        context[self.name] = val
+        context[self.name] = 
         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'")
-    nodelist = parser.parse(('endautoescape',))
-    parser.delete_first_token()
+    nodelist = parser.parse_nodelist(('endautoescape',))
     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]
-        node = CycleNode(args[1:-2], name)
+        values = [parser.compile_filter(arg) for arg in args[1:-2]]
+        node = CycleNode(values, name)
         if not hasattr(parser, '_namedCycleNodes'):
             parser._namedCycleNodes = {}
         parser._namedCycleNodes[name] = node
     else:
-        node = CycleNode(args[1:])
+        values = [parser.compile_filter(arg) for arg in args[1:]]
+        node = CycleNode(values)
     return node
 cycle = register.tag(cycle)
 
@@ -542 +484 @@
             This text will be HTML-escaped, and will appear in lowercase.
         {% endfilter %}
     """
-    _, rest = token.contents.split(None, 1)
-    filter_expr = parser.compile_filter("var|%s" % (rest))
-    for func, unused in filter_expr.filters:
+    name, filter_ = token.contents.split(None, 1)        
+    bits = parser.token_stream("var|%s" % filter_)
+    try:
+        filter_expr = bits.parse_expression()
+    except TokenSyntaxError:
+        raise TemplateSyntaxError("'%s' requires a valid filter chain, got: '%s'" % name, filter_)
+    for func, args in filter_expr.filters:
         if getattr(func, '_decorated_function', func).__name__ in ('escape', 'safe'):
             raise TemplateSyntaxError('"filter %s" is not permitted.  Use the "autoescape" tag instead.' % func.__name__)
-    nodelist = parser.parse(('endfilter',))
-    parser.delete_first_token()
+    nodelist = parser.parse_nodelist(('endfilter',))
     return FilterNode(filter_expr, nodelist)
 do_filter = register.tag("filter", do_filter)
 
 #@register.tag
-def firstof(parser, token):
+#@uses_token_stream
+def firstof(parser, bits):
     """
     Outputs the first variable passed that is not False.
 
@@ -581 +527 @@
         {% firstof var1 var2 var3 "fallback value" %}
 
     """
-    bits = token.split_contents()[1:]
-    if len(bits) < 1:
-        raise TemplateSyntaxError("'firstof' statement requires at least one"
-                                  " argument")
-    return FirstOfNode(bits)
-firstof = register.tag(firstof)
+    expressions = bits.parse_expression_list(minimum=1)
+    return FirstOfNode(expressions)
+firstof = register.tag(uses_token_stream(firstof))
 
 #@register.tag(name="for")
-def do_for(parser, token):
+#@uses_token_stream
+def do_for(parser, bits):
     """
     Loops over each item in an array.
 
@@ -628 +572 @@
         ==========================  ================================================
 
     """
-    bits = token.contents.split()
-    if len(bits) < 4:
-        raise TemplateSyntaxError("'for' statements should have at least four"
-                                  " words: %s" % token.contents)
+    loopvars = []
+    while True:
+        var = bits.pop_name()
+        if not var:
+            break
+        loopvars.append(var)
+        if not bits.pop_lexem(','):
+            break
+    if not loopvars:
+        raise TemplateSyntaxError("'for' tag requires at least one loopvar")    
+        
+    if not bits.pop_lexem('in'):
+        raise TemplateSyntaxError("'for' tag requires 'in' keyword")
+    sequence = bits.parse_expression(required=True)
+    reversed = bits.pop_lexem('reversed')
+    nodelist = parser.parse_nodelist(('endfor',))
+    return ForNode(loopvars, sequence, reversed, nodelist)
+do_for = register.tag("for", uses_token_stream(do_for))
 
-    is_reversed = bits[-1] == 'reversed'
-    in_index = is_reversed and -3 or -2
-    if bits[in_index] != 'in':
-        raise TemplateSyntaxError("'for' statements should use the format"
-                                  " 'for x in y': %s" % token.contents)
+def do_ifequal(parser, bits, negate):
+    val1, val2 = bits.parse_expression_list(count=2)
+    nodelist_true, nodelist_false = parse_conditional_nodelists(parser, bits.name)
+    return IfEqualNode(val1, val2, nodelist_true, nodelist_false, negate)
 
-    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
-def ifequal(parser, token):
+#@uses_token_stream
+def ifequal(parser, bits):
     """
     Outputs the contents of the block if the two arguments equal each other.
 
@@ -682 +614 @@
             ...
         {% endifnotequal %}
     """
-    return do_ifequal(parser, token, False)
-ifequal = register.tag(ifequal)
+    return do_ifequal(parser, , False)
+ifequal = register.tag()
 
 #@register.tag
-def ifnotequal(parser, token):
+#@uses_token_stream
+def ifnotequal(parser, bits):
     """
     Outputs the contents of the block if the two arguments are not equal.
     See ifequal.
     """
-    return do_ifequal(parser, token, True)
-ifnotequal = register.tag(ifnotequal)
+    return do_ifequal(parser, , True)
+ifnotequal = register.tag()
 
 #@register.tag(name="if")
-def do_if(parser, token):
+#@uses_token_stream
+def do_if(parser, bits):
     """
     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 %}
     """
-    bits = token.contents.split()
-    del bits[0]
-    if not bits:
-        raise TemplateSyntaxError("'if' statement requires at least one argument")
-    # Bits now looks something like this: ['a', 'or', 'not', 'b', 'or', 'c.d']
-    bitstr = ' '.join(bits)
-    boolpairs = bitstr.split(' and ')
+    link_type = None
+    link = None
     boolvars = []
-    if len(boolpairs) == 1:
-        link_type = IfNode.LinkTypes.or_
-        boolpairs = bitstr.split(' or ')
-    else:
-        link_type = IfNode.LinkTypes.and_
-        if ' or ' in bitstr:
-            raise TemplateSyntaxError, "'if' tags can't mix 'and' and 'or'"
-    for boolpair in boolpairs:
-        if ' ' in boolpair:
-            try:
-                not_, boolvar = boolpair.split()
-            except ValueError:
-                raise TemplateSyntaxError, "'if' statement improperly formatted"
-            if not_ != 'not':
-                raise TemplateSyntaxError, "Expected 'not' in if statement"
-            boolvars.append((True, parser.compile_filter(boolvar)))
+    while True:
+        negated = False
+        if bits.pop_lexem('not'):
+            negated = True
+        expr = bits.parse_expression(required=True)
+        boolvars.append((negated, expr))
+        link = bits.pop_name()
+        if not link:
+            break
+        if link_type:
+            if link_type != link:
+                bits.syntax_error("can't mix 'and' and 'or'")
         else:
-            boolvars.append((False, parser.compile_filter(boolpair)))
-    nodelist_true = parser.parse(('else', 'endif'))
-    token = parser.next_token()
-    if token.contents == 'else':
-        nodelist_false = parser.parse(('endif',))
-        parser.delete_first_token()
-    else:
-        nodelist_false = NodeList()
+            if not link in ('and', 'or'):
+                bits.pushback()
+                bits.expected("'and' or 'or'")
+            link_type = link
+    
+    nodelist_true, nodelist_false = parse_conditional_nodelists(parser, 'if')    
     return IfNode(boolvars, nodelist_true, nodelist_false, link_type)
-do_if = register.tag("if", do_if)
+do_if = register.tag("if", )
 
 #@register.tag
-def ifchanged(parser, token):
+#@uses_token_stream
+def ifchanged(parser, bits):
     """
     Checks if a value has changed from the last iteration of a loop.
 
@@ -817 +741 @@
                     {{ date.hour }}
                 {% endifchanged %}
             {% endfor %}
-    """
-    bits = token.contents.split()
-    nodelist_true = parser.parse(('else', 'endifchanged'))
-    token = parser.next_token()
-    if token.contents == 'else':
-        nodelist_false = parser.parse(('endifchanged',))
-        parser.delete_first_token()
-    else:
-        nodelist_false = NodeList()
-    return IfChangedNode(nodelist_true, nodelist_false, *bits[1:])
-ifchanged = register.tag(ifchanged)
+    """    
+    values = bits.parse_expression_list()
+    nodelist_true, nodelist_false = parse_conditional_nodelists(parser, bits.name)
+    return IfChangedNode(nodelist_true, nodelist_false, values)
+ifchanged = register.tag(uses_token_stream(ifchanged))
 
 #@register.tag
 def ssi(parser, token):
@@ -882 +800 @@
 load = register.tag(load)
 
 #@register.tag
-def now(parser, token):
+#@uses_token_stream
+def now(parser, bits):
     """
     Displays the date, formatted according to the given string.
 
@@ -893 +812 @@
 
         It is {% now "jS F Y H:i" %}
     """
-    bits = token.contents.split('"')
-    if len(bits) != 3:
-        raise TemplateSyntaxError, "'now' statement takes one argument"
-    format_string = bits[1]
+    format_string = bits.parse_expression(required=True)
     return NowNode(format_string)
-now = register.tag(now)
+now = register.tag()
 
 #@register.tag
-def regroup(parser, token):
+#@uses_token_stream
+def regroup(parser, bits):
     """
     Regroups a list of alike objects by a common attribute.
 
@@ -947 +864 @@
         {% regroup people|dictsort:"gender" by gender as grouped %}
 
     """
-    firstbits = token.contents.split(None, 3)
-    if len(firstbits) != 4:
-        raise TemplateSyntaxError, "'regroup' tag takes five arguments"
-    target = parser.compile_filter(firstbits[1])
-    if firstbits[2] != 'by':
-        raise TemplateSyntaxError("second argument to 'regroup' tag must be 'by'")
-    lastbits_reversed = firstbits[3][::-1].split(None, 2)
-    if lastbits_reversed[1][::-1] != 'as':
-        raise TemplateSyntaxError("next-to-last argument to 'regroup' tag must"
-                                  " be 'as'")
-
-    expression = parser.compile_filter(lastbits_reversed[2][::-1])
-
-    var_name = lastbits_reversed[0][::-1]
+    target = bits.parse_expression(required=True)    
+    if not bits.pop_lexem('by'):
+        raise bits.expected("'by'")
+    expression = bits.parse_expression(required=True)
+    try:
+        var_name = parse_as(bits)
+    except TokenSyntaxError:
+        raise bits.expected("as <name>")
     return RegroupNode(target, expression, var_name)
-regroup = register.tag(regroup)
+regroup = register.tag()
 
 def spaceless(parser, token):
     """
@@ -989 +900 @@
             </strong>
         {% endspaceless %}
     """
-    nodelist = parser.parse(('endspaceless',))
-    parser.delete_first_token()
-    return SpacelessNode(nodelist)
+    return SpacelessNode(parser.parse_nodelist(('endspaceless',)))
 spaceless = register.tag(spaceless)
 
 #@register.tag
@@ -1028 +937 @@
     return TemplateTagNode(tag)
 templatetag = register.tag(templatetag)
 
-def url(parser, token):
+#@register.tag
+#@uses_token_stream
+def url(parser, bits):
     """
     Returns an absolute URL matching given view with its parameters.
 
@@ -1059 +970 @@
 
     The URL will look like ``/clients/client/123/``.
     """
-    bits = token.contents.split(' ')
-    if len(bits) < 2:
-        raise TemplateSyntaxError("'%s' takes at least one argument"
-                                  " (path to a view)" % bits[0])
-    viewname = bits[1]
-    args = []
-    kwargs = {}
-    asvar = None
-        
-    if len(bits) > 2:
-        bits = iter(bits[2:])
-        for bit in bits:
-            if bit == 'as':
-                asvar = bits.next()
-                break
-            else:
-                for arg in bit.split(","):
-                    if '=' in arg:
-                        k, v = arg.split('=', 1)
-                        k = k.strip()
-                        kwargs[k] = parser.compile_filter(v)
-                    elif arg:
-                        args.append(parser.compile_filter(arg))
-    return URLNode(viewname, args, kwargs, asvar)
-url = register.tag(url)
+    view = bits.parse_string(bare=True, required=True)
+    args, kwargs = parse_args_and_kwargs(bits, until=('as',))
+    try:
+        asvar = parse_as(bits)
+    except TokenSyntaxError:
+        asvar = None
+    return URLNode(view, args, kwargs, asvar)
+url = register.tag(uses_token_stream(url))
 
 #@register.tag
-def widthratio(parser, token):
+#@uses_token_stream
+def widthratio(parser, bits):
     """
     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).
     """
-    bits = token.contents.split()
-    if len(bits) != 4:
-        raise TemplateSyntaxError("widthratio takes three arguments")
-    tag, this_value_expr, max_value_expr, max_width = bits
-    try:
-        max_width = int(max_width)
-    except ValueError:
-        raise TemplateSyntaxError("widthratio final argument must be an integer")
-    return WidthRatioNode(parser.compile_filter(this_value_expr),
-                          parser.compile_filter(max_value_expr), max_width)
-widthratio = register.tag(widthratio)
+    this_value_expr, max_value_expr = bits.parse_expression_list(count=2)
+    max_width = bits.parse_int(required=True)
+    return WidthRatioNode(this_value_expr, max_value_expr, max_width)
+widthratio = register.tag(uses_token_stream(widthratio))
 
 #@register.tag
-def do_with(parser, token):
+#@uses_token_stream
+def do_with(parser, bits):
     """
     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 %}
+
     """
-    bits = list(token.split_contents())
-    if len(bits) != 4 or bits[2] != "as":
-        raise TemplateSyntaxError("%r expected format is 'value as name'" %
-                                  bits[0])
-    var = parser.compile_filter(bits[1])
-    name = bits[3]
-    nodelist = parser.parse(('endwith',))
-    parser.delete_first_token()
-    return WithNode(var, name, nodelist)
-do_with = register.tag('with', do_with)
+    try:
+        expr = bits.parse_expression()
+        name = parse_as(bits)
+    except TokenSyntaxError:
+        bits.expected("value as name")
+    nodelist = parser.parse_nodelist(('endwith',))
+    return WithNode(expr, name, nodelist)
+do_with = register.tag('with', uses_token_stream(do_with))

django/template/compat.py

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/template/loader_tags.py

@@ -1 @@
-from django.template import TemplateSyntaxError, TemplateDoesNotExist, Variable
-from django.template import Library, Node, TextNode
-from django.template.loader import get_template, get_template_from_string, find_template_source
+from django.template import TemplateSyntaxError, Library, Node, TextNode
+from django.template.compiler import uses_token_stream
+from django.template.loader import TemplateDoesNotExist, get_template, get_template_from_string, find_template_source
+from django.template.expressions import Literal
 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))
-        return ''
+        return ''
 
     def add_parent(self, nodelist):
         if self.parent:
@@ -39 +40 @@
 class ExtendsNode(Node):
     must_be_first = True
 
-    def __init__(self, nodelist, parent_name, parent_name_expr, template_dirs=None):
+    def __init__(self, nodelist, parent_name, template_dirs=None):
         self.nodelist = nodelist
-        self.parent_name, self.parent_name_expr = parent_name, parent_name_expr
+        self.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 self.parent_name_expr:
-            self.parent_name = self.parent_name_expr.resolve(context)
-        parent = self.parent_name
+        parent = self.parent_name.resolve_safe(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):
-        self.template_name = Variable(template_name)
+        self.template_name = 
 
     def render(self, context):
         try:
-            template_name = self.template_name.resolve(context)
+            template_name = self.template_name.resolve(context)
             t = get_template(template_name)
             return t.render(context)
         except TemplateSyntaxError, e:
             if settings.TEMPLATE_DEBUG:
                 raise
-            return ''
+            return ''
         except:
-            return '' # Fail silently for invalid included templates.
+            return '' # Fail silently for invalid included templates.
 
+
+
 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]
-    nodelist = parser.parse(('endblock', 'endblock %s' % block_name))
-    parser.delete_first_token()
+    nodelist = parser.parse_nodelist(('endblock', 'endblock %s' % block_name))
     return BlockNode(block_name, nodelist)
+
 
-def do_extends(parser, token):
+
+#@register.tag('extends')
+#@uses_token_stream
+def do_extends(parser, bits):
     """
     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,
-    or ``{% extends variable %}`` uses the value of ``variable`` as either the
+    or ``{% extends `` as either the
     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).
     """
-    bits = token.contents.split()
-    if len(bits) != 2:
-        raise TemplateSyntaxError, "'%s' takes one argument" % bits[0]
-    parent_name, parent_name_expr = None, None
-    if bits[1][0] in ('"', "'") and bits[1][-1] == bits[1][0]:
-        parent_name = bits[1][1:-1]
-    else:
-        parent_name_expr = parser.compile_filter(bits[1])
+    parent_name = bits.parse_expression(required=True)
     nodelist = parser.parse()
     if nodelist.get_nodes_by_type(ExtendsNode):
-        raise TemplateSyntaxError, "'%s' cannot appear more than once in the same template" % bits[0]
-    return ExtendsNode(nodelist, parent_name, parent_name_expr)
+        raise TemplateSyntaxError, "'%s' cannot appear more than once in the same template" % bits.name
+    return ExtendsNode(nodelist, parent_name)
+register.tag('extends', uses_token_stream(do_extends))
 
-def do_include(parser, token):
+
+#@register.tag('include')
+#@uses_token_stream
+def do_include(parser, bits):
     """
     Loads a template and renders it with the current context.
 
@@ -179 +176 @@
 
         {% include "foo/some_include" %}
     """
-    bits = token.contents.split()
-    if len(bits) != 2:
-        raise TemplateSyntaxError, "%r tag takes one argument: the name of the template to be included" % bits[0]
-    path = bits[1]
-    if path[0] in ('"', "'") and path[-1] == path[0]:
-        return ConstantIncludeNode(path[1:-1])
-    return IncludeNode(bits[1])
-
-register.tag('block', do_block)
-register.tag('extends', do_extends)
-register.tag('include', do_include)
+    template_name = bits.parse_expression(required=True)
+    if isinstance(template_name, Literal):
+        # remove ConstantIncludeNode and this hack will be gone
+        return ConstantIncludeNode(template_name.resolve(None))
+    return IncludeNode(template_name)
+register.tag('include', uses_token_stream(do_include))

django/template/library.py

@@ +1 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

django/template/debug.py

@@ -1 @@
-from django.template import Lexer, Parser, tag_re, NodeList, VariableNode, TemplateSyntaxError
-from django.utils.encoding import force_unicode
-from django.utils.html import escape
-from django.utils.safestring import SafeData, EscapeData
+from django.template.compiler import Lexer, Parser, Token, TokenStream, tag_re, bit_re
+from django.template import NodeList, ExpressionNode, TemplateSyntaxError
+from django.utils.encoding import force_unicode, smart_str
 
 class DebugLexer(Lexer):
     def __init__(self, template_string, origin):
@@ -50 +49 @@
         return DebugNodeList()
 
     def create_variable_node(self, contents):
-        return DebugVariableNode(contents)
+        return DebugNode(contents)
 
     def extend_nodelist(self, nodelist, node, token):
         node.source = token.source
@@ -65 +64 @@
         if not hasattr(e, 'source'):
             e.source = token.source
 
+
+
+
+
 class DebugNodeList(NodeList):
     def render_node(self, node, context):
         try:
@@ -81 +84 @@
             raise wrapped
         return result
 
-class DebugVariableNode(VariableNode):
+class DebugNode):
     def render(self, context):
         try:
-            output = force_unicode(self.filter_expression.resolve(context))
+            )
         except TemplateSyntaxError, e:
             if not hasattr(e, 'source'):
                 e.source = self.source
             raise
-        except UnicodeDecodeError:
-            return ''
-        if (context.autoescape and not isinstance(output, SafeData)) or isinstance(output, EscapeData):
-            return escape(output)
-        else:
-            return output
+            
+class DebugTokenStream(TokenStream):
+    def syntax_error(self, msg):
+        if self.name:
+            msg = u"{%% %s %%} %s" % (self.name, msg)            
+        if self.token:
+            raise self.parser.source_error(self.token.source, msg)
+        raise TemplateSyntaxError(msg)
+            

django/template/loader.py

@@ -21 +21 @@
 # installed, because pkg_resources is necessary to read eggs.
 
 from django.core.exceptions import ImproperlyConfigured
-from django.template import Origin, Template, Context, TemplateDoesNotExist, add_to_builtins
+from django.template import Origin, Template, Context, add_to_builtins
 from django.conf import settings
 
 template_source_loaders = None
 
+
+
+
 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.Token(template.TOKEN_BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")')
+        token = template..TOKEN_BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")')
         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:
-                        raise
+                        raise
                         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\""),
+
+
+
 
             # 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
-            'filter-syntax12': (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'),
+            'filter-syntax12': (r'{{ var|yesno:"yup,nup,mup" }} {{ var|yesno }}', {"var": True}, 'yup yes'),
 
             # 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" }}', {}, ""),
+
+
+
 
             ### 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,'),
 
+
+
+
+
+
             ### 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'),
+
+
+
+
+
+
+
 
             ### IFNOTEQUAL TAG ########################################################
             'ifnotequal01': ("{% ifnotequal a b %}yes{% endifnotequal %}", {"a": 1, "b": 2}, "yes"),
@@ -816 +834 @@
                             you
                             gentlemen.
                             """),
+
+
+
+
+
+
+
 
             ### REGROUP TAG ###########################################################
             'regroup01': ('{% regroup data by bar as grouped %}' + \
@@ -841 +866 @@
                           '{% endfor %},' + \
                           '{% endfor %}',
                           {}, ''),
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
             ### 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/'),
+
 
             # Failures
             'url-fail01': ('{% url %}', {}, template.TemplateSyntaxError),