binding: Updates Jinja2 from 2.7.1 to 2.8.

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.lexer import describe_token, describe_token_expr
-from jinja2._compat import next, imap
+from jinja2._compat import 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):
     """This is the central parsing class Jinja2 uses.  It's passed to
     extensions and can be used to parse expressions or statements.
     """
@@ skipping 134 matching lines @@
             self.fail_eof(end_tokens)
 
         if drop_needle:
             next(self.stream)
         return result
 
     def parse_set(self):
         """Parse an assign statement."""
         lineno = next(self.stream).lineno
         target = self.parse_assign_target()
-        self.stream.expect('assign')
-        expr = self.parse_tuple()
-        return nodes.Assign(target, expr, lineno=lineno)
+        if self.stream.skip_if('assign'):
+            expr = self.parse_tuple()
+            return nodes.Assign(target, expr, lineno=lineno)
+        body = self.parse_statements(('name:endset',),
+                                     drop_needle=True)
+        return nodes.AssignBlock(target, body, lineno=lineno)
 
     def parse_for(self):
         """Parse a for loop."""
         lineno = self.stream.expect('name:for').lineno
         target = self.parse_assign_target(extra_end_rules=('name:in',))
         self.stream.expect('name:in')
         iter = self.parse_tuple(with_condexpr=False,
                                 extra_end_rules=('name:recursive',))
         test = None
         if self.stream.skip_if('name:if'):
@@ skipping 120 matching lines @@
         node.args = args = []
         node.defaults = defaults = []
         self.stream.expect('lparen')
         while self.stream.current.type != 'rparen':
             if args:
                 self.stream.expect('comma')
             arg = self.parse_assign_target(name_only=True)
             arg.set_ctx('param')
             if self.stream.skip_if('assign'):
                 defaults.append(self.parse_expression())
+            elif defaults:
+                self.fail('non-default argument follows default argument')
             args.append(arg)
         self.stream.expect('rparen')
 
     def parse_call_block(self):
         node = nodes.CallBlock(lineno=next(self.stream).lineno)
         if self.stream.current.type == 'lparen':
             self.parse_signature(node)
         else:
             node.args = []
             node.defaults = []
@@ skipping 102 matching lines @@
         lineno = self.stream.current.lineno
         expr = self.parse_add()
         ops = []
         while 1:
             token_type = self.stream.current.type
             if token_type in _compare_operators:
                 next(self.stream)
                 ops.append(nodes.Operand(token_type, self.parse_add()))
             elif self.stream.skip_if('name:in'):
                 ops.append(nodes.Operand('in', self.parse_add()))
-            elif self.stream.current.test('name:not') and \
-                 self.stream.look().test('name:in'):
+            elif (self.stream.current.test('name:not') and
+                  self.stream.look().test('name:in')):
                 self.stream.skip(2)
                 ops.append(nodes.Operand('notin', self.parse_add()))
             else:
                 break
             lineno = self.stream.current.lineno
         if not ops:
             return expr
         return nodes.Compare(expr, ops, lineno=lineno)
 
     def parse_add(self):
@@ skipping 315 matching lines @@
                 ensure(dyn_args is None and dyn_kwargs is None)
                 next(self.stream)
                 dyn_args = self.parse_expression()
             elif self.stream.current.type == 'pow':
                 ensure(dyn_kwargs is None)
                 next(self.stream)
                 dyn_kwargs = self.parse_expression()
             else:
                 ensure(dyn_args is None and dyn_kwargs is None)
                 if self.stream.current.type == 'name' and \
-                    self.stream.look().type == 'assign':
+                   self.stream.look().type == 'assign':
                     key = self.stream.current.value
                     self.stream.skip(2)
                     value = self.parse_expression()
                     kwargs.append(nodes.Keyword(key, value,
                                                 lineno=value.lineno))
                 else:
                     ensure(not kwargs)
                     args.append(self.parse_expression())
 
             require_comma = True
@@ skipping 32 matching lines @@
         else:
             negated = False
         name = self.stream.expect('name').value
         while self.stream.current.type == 'dot':
             next(self.stream)
             name += '.' + self.stream.expect('name').value
         dyn_args = dyn_kwargs = None
         kwargs = []
         if self.stream.current.type == 'lparen':
             args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
-        elif self.stream.current.type in ('name', 'string', 'integer',
-                                          'float', 'lparen', 'lbracket',
-                                          'lbrace') and not \
-             self.stream.current.test_any('name:else', 'name:or',
-                                          'name:and'):
+        elif (self.stream.current.type in ('name', 'string', 'integer',
+                                           'float', 'lparen', 'lbracket',
+                                           'lbrace') and not
+              self.stream.current.test_any('name:else', 'name:or',
+                                           'name:and')):
             if self.stream.current.test('name:is'):
                 self.fail('You cannot chain multiple tests with is')
             args = [self.parse_expression()]
         else:
             args = []
         node = nodes.Test(node, name, args, kwargs, dyn_args,
                           dyn_kwargs, lineno=token.lineno)
         if negated:
             node = nodes.Not(node, lineno=token.lineno)
         return node
@@ skipping 44 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