Update Jinja2 (Python template library) to 2.7.1

third_party/jinja2/parser.py

 # -*- coding: utf-8 -*-
 """
     jinja2.parser
     ~~~~~~~~~~~~~
 
     Implements the template parser.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
 from jinja2 import nodes
 from jinja2.exceptions import TemplateSyntaxError, TemplateAssertionError
-from jinja2.utils import next
 from jinja2.lexer import describe_token, describe_token_expr
+from jinja2._compat import next, imap
 
 
 #: statements that callinto 
 _statement_keywords = frozenset(['for', 'if', 'block', 'extends', 'print',
                                  'macro', 'include', 'from', 'import',
                                  'set'])
 _compare_operators = frozenset(['eq', 'ne', 'lt', 'lteq', 'gt', 'gteq'])
 
 
 class Parser(object):
@@ skipping 21 matching lines @@
         line number or last line number as well as the current name and
         filename.
         """
         if lineno is None:
             lineno = self.stream.current.lineno
         raise exc(msg, lineno, self.name, self.filename)
 
     def _fail_ut_eof(self, name, end_token_stack, lineno):
         expected = []
         for exprs in end_token_stack:
-            expected.extend(map(describe_token_expr, exprs))
+            expected.extend(imap(describe_token_expr, exprs))
         if end_token_stack:
             currently_looking = ' or '.join(
                 "'%s'" % describe_token_expr(expr)
                 for expr in end_token_stack[-1])
         else:
             currently_looking = None
 
         if name is None:
             message = ['Unexpected end of template.']
         else:
@@ skipping 149 matching lines @@
     def parse_block(self):
         node = nodes.Block(lineno=next(self.stream).lineno)
         node.name = self.stream.expect('name').value
         node.scoped = self.stream.skip_if('name:scoped')
 
         # common problem people encounter when switching from django
         # to jinja.  we do not support hyphens in block names, so let's
         # raise a nicer error message in that case.
         if self.stream.current.type == 'sub':
             self.fail('Block names in Jinja have to be valid Python '
-                      'identifiers and may not contain hypens, use an '
+                      'identifiers and may not contain hyphens, use an '
                       'underscore instead.')
 
         node.body = self.parse_statements(('name:endblock',), drop_needle=True)
         self.stream.skip_if('name:' + node.name)
         return node
 
     def parse_extends(self):
         node = nodes.Extends(lineno=next(self.stream).lineno)
         node.template = self.parse_expression()
         return node
@@ skipping 454 matching lines @@
             attr_token = self.stream.current
             next(self.stream)
             if attr_token.type == 'name':
                 return nodes.Getattr(node, attr_token.value, 'load',
                                      lineno=token.lineno)
             elif attr_token.type != 'integer':
                 self.fail('expected name or number', attr_token.lineno)
             arg = nodes.Const(attr_token.value, lineno=attr_token.lineno)
             return nodes.Getitem(node, arg, 'load', lineno=token.lineno)
         if token.type == 'lbracket':
-            priority_on_attribute = False
             args = []
             while self.stream.current.type != 'rbracket':
                 if args:
                     self.stream.expect('comma')
                 args.append(self.parse_subscribed())
             self.stream.expect('rbracket')
             if len(args) == 1:
                 arg = args[0]
             else:
                 arg = nodes.Tuple(args, 'load', lineno=token.lineno)
@@ skipping 175 matching lines @@
             if end_tokens is not None:
                 self._end_token_stack.pop()
 
         return body
 
     def parse(self):
         """Parse the whole template into a `Template` node."""
         result = nodes.Template(self.subparse(), lineno=1)
         result.set_environment(self.environment)
         return result