six.advance_iterator -> next

diff --git a/jinja2/_compat.py b/jinja2/_compat.py
index 6318f0b1acd17ebc4ec7cfae754e07f046f65bd1..7825cb6ac6e7bc3115ab9a950247e188e86931f8 100644 (file)
--- a/jinja2/_compat.py
+++ b/jinja2/_compat.py
@@ -11,6 +11,7 @@
     :copyright: Copyright 2013 by the Jinja team, see AUTHORS.
     :license: BSD, see LICENSE for details.
 """
+import six
 
 # https://bitbucket.org/gutworth/six/issue/25/add-unichr
 try:
@@ -18,7 +19,6 @@ try:
 except NameError:
     unichr = chr  # py3
 
-try:
-    range_type = xrange
-except NameError:
-    range_type = range
+range_type = six.moves.xrange
+next = six.advance_iterator
+imap = six.moves.map

diff --git a/jinja2/compiler.py b/jinja2/compiler.py
index 894317b0b5700a87d1b65537dbb79926d6bea9d3..ce8e06d21cbda4f76b253fb6021516b7d26e79ca 100644 (file)
--- a/jinja2/compiler.py
+++ b/jinja2/compiler.py
@@ -8,6 +8,8 @@
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
+import six
+
 from itertools import chain
 from copy import deepcopy
 from jinja2 import nodes
@@ -15,8 +17,7 @@ from jinja2.nodes import EvalContext
 from jinja2.visitor import NodeVisitor
 from jinja2.exceptions import TemplateAssertionError
 from jinja2.utils import Markup, concat, escape, is_python_keyword
-from jinja2._compat import range_type
-import six
+from jinja2._compat import range_type, next
 from six.moves import cStringIO as StringIO, map
 
 
@@ -1359,7 +1360,7 @@ class CodeGenerator(NodeVisitor):
             public_names = [x for x in assignment_frame.toplevel_assignments
                             if not x.startswith('_')]
             if len(assignment_frame.toplevel_assignments) == 1:
-                name = six.advance_iterator(iter(assignment_frame.toplevel_assignments))
+                name = next(iter(assignment_frame.toplevel_assignments))
                 self.writeline('context.vars[%r] = l_%s' % (name, name))
             else:
                 self.writeline('context.vars.update({')

diff --git a/jinja2/ext.py b/jinja2/ext.py
index c456dbf21748c2b8892d31d3987f04d8c75f49f2..8ded3d12fb418333443d5fc14711c53148660c88 100644 (file)
--- a/jinja2/ext.py
+++ b/jinja2/ext.py
@@ -20,6 +20,7 @@ from jinja2.environment import Environment
 from jinja2.runtime import concat
 from jinja2.exceptions import TemplateAssertionError, TemplateSyntaxError
 from jinja2.utils import contextfunction, import_string, Markup
+from jinja2._compat import next
 import six
 
 
@@ -215,7 +216,7 @@ class InternationalizationExtension(Extension):
 
     def parse(self, parser):
         """Parse a translatable tag."""
-        lineno = six.advance_iterator(parser.stream).lineno
+        lineno = next(parser.stream).lineno
         num_called_num = False
 
         # find all the variables referenced.  Additionally a variable can be
@@ -240,7 +241,7 @@ class InternationalizationExtension(Extension):
 
             # expressions
             if parser.stream.current.type == 'assign':
-                six.advance_iterator(parser.stream)
+                next(parser.stream)
                 variables[name.value] = var = parser.parse_expression()
             else:
                 variables[name.value] = var = nodes.Name(name.value, 'load')
@@ -272,7 +273,7 @@ class InternationalizationExtension(Extension):
         # if we have a pluralize block, we parse that too
         if parser.stream.current.test('name:pluralize'):
             have_plural = True
-            six.advance_iterator(parser.stream)
+            next(parser.stream)
             if parser.stream.current.type != 'block_end':
                 name = parser.stream.expect('name')
                 if name.value not in variables:
@@ -283,10 +284,10 @@ class InternationalizationExtension(Extension):
                 num_called_num = name.value == 'num'
             parser.stream.expect('block_end')
             plural_names, plural = self._parse_block(parser, False)
-            six.advance_iterator(parser.stream)
+            next(parser.stream)
             referenced.update(plural_names)
         else:
-            six.advance_iterator(parser.stream)
+            next(parser.stream)
 
         # register free names as simple name expressions
         for var in referenced:
@@ -314,15 +315,15 @@ class InternationalizationExtension(Extension):
         while 1:
             if parser.stream.current.type == 'data':
                 buf.append(parser.stream.current.value.replace('%', '%%'))
-                six.advance_iterator(parser.stream)
+                next(parser.stream)
             elif parser.stream.current.type == 'variable_begin':
-                six.advance_iterator(parser.stream)
+                next(parser.stream)
                 name = parser.stream.expect('name').value
                 referenced.append(name)
                 buf.append('%%(%s)s' % name)
                 parser.stream.expect('variable_end')
             elif parser.stream.current.type == 'block_begin':
-                six.advance_iterator(parser.stream)
+                next(parser.stream)
                 if parser.stream.current.test('name:endtrans'):
                     break
                 elif parser.stream.current.test('name:pluralize'):
@@ -395,7 +396,7 @@ class ExprStmtExtension(Extension):
     tags = set(['do'])
 
     def parse(self, parser):
-        node = nodes.ExprStmt(lineno=six.advance_iterator(parser.stream).lineno)
+        node = nodes.ExprStmt(lineno=next(parser.stream).lineno)
         node.node = parser.parse_tuple()
         return node
 
@@ -405,7 +406,7 @@ class LoopControlExtension(Extension):
     tags = set(['break', 'continue'])
 
     def parse(self, parser):
-        token = six.advance_iterator(parser.stream)
+        token = next(parser.stream)
         if token.value == 'break':
             return nodes.Break(lineno=token.lineno)
         return nodes.Continue(lineno=token.lineno)
@@ -416,7 +417,7 @@ class WithExtension(Extension):
     tags = set(['with'])
 
     def parse(self, parser):
-        node = nodes.Scope(lineno=six.advance_iterator(parser.stream).lineno)
+        node = nodes.Scope(lineno=next(parser.stream).lineno)
         assignments = []
         while parser.stream.current.type != 'block_end':
             lineno = parser.stream.current.lineno
@@ -437,7 +438,7 @@ class AutoEscapeExtension(Extension):
     tags = set(['autoescape'])
 
     def parse(self, parser):
-        node = nodes.ScopedEvalContextModifier(lineno=six.advance_iterator(parser.stream).lineno)
+        node = nodes.ScopedEvalContextModifier(lineno=next(parser.stream).lineno)
         node.options = [
             nodes.Keyword('autoescape', parser.parse_expression())
         ]

diff --git a/jinja2/filters.py b/jinja2/filters.py
index adc513e17e10568fd466d4be879f19eead9004e2..f0fbb385a3410d986a0659907c1110613f9f2480 100644 (file)
--- a/jinja2/filters.py
+++ b/jinja2/filters.py
@@ -10,6 +10,8 @@
 """
 import re
 import math
+import six
+
 from random import choice
 from operator import itemgetter
 from itertools import groupby
@@ -17,7 +19,7 @@ from jinja2.utils import Markup, escape, pformat, urlize, soft_unicode, \
      unicode_urlencode
 from jinja2.runtime import Undefined
 from jinja2.exceptions import FilterArgumentError
-import six
+from jinja2._compat import next
 from six.moves import map
 
 
@@ -342,7 +344,7 @@ def do_center(value, width=80):
 def do_first(environment, seq):
     """Return the first item of a sequence."""
     try:
-        return six.advance_iterator(iter(seq))
+        return next(iter(seq))
     except StopIteration:
         return environment.undefined('No first item, sequence was empty.')
 
@@ -351,7 +353,7 @@ def do_first(environment, seq):
 def do_last(environment, seq):
     """Return the last item of a sequence."""
     try:
-        return six.advance_iterator(iter(reversed(seq)))
+        return next(iter(reversed(seq)))
     except StopIteration:
         return environment.undefined('No last item, sequence was empty.')
 
@@ -820,7 +822,7 @@ def do_map(*args, **kwargs):
         attribute = kwargs.pop('attribute')
         if kwargs:
             raise FilterArgumentError('Unexpected keyword argument %r' %
-                six.advance_iterator(iter(kwargs)))
+                next(iter(kwargs)))
         func = make_attrgetter(context.environment, attribute)
     else:
         try:

diff --git a/jinja2/lexer.py b/jinja2/lexer.py
index b39a738722775a36dee2c73edec0d31fa6e2a1cc..07cf5c606d40bcc4fcc6e3c2791df217fd106020 100644 (file)
--- a/jinja2/lexer.py
+++ b/jinja2/lexer.py
@@ -15,11 +15,13 @@
     :license: BSD, see LICENSE for more details.
 """
 import re
+import six
+
 from operator import itemgetter
 from collections import deque
 from jinja2.exceptions import TemplateSyntaxError
 from jinja2.utils import LRUCache
-import six
+from jinja2._compat import next
 
 
 # cache for the lexers. Exists in order to be able to have multiple
@@ -285,7 +287,7 @@ class TokenStreamIterator(six.Iterator):
         if token.type is TOKEN_EOF:
             self.stream.close()
             raise StopIteration()
-        six.advance_iterator(self.stream)
+        next(self.stream)
         return token
 
 
@@ -302,7 +304,7 @@ class TokenStream(six.Iterator):
         self.filename = filename
         self.closed = False
         self.current = Token(1, TOKEN_INITIAL, '')
-        six.advance_iterator(self)
+        next(self)
 
     def __iter__(self):
         return TokenStreamIterator(self)
@@ -319,7 +321,7 @@ class TokenStream(six.Iterator):
 
     def look(self):
         """Look at the next token."""
-        old_token = six.advance_iterator(self)
+        old_token = next(self)
         result = self.current
         self.push(result)
         self.current = old_token
@@ -328,14 +330,14 @@ class TokenStream(six.Iterator):
     def skip(self, n=1):
         """Got n tokens ahead."""
         for x in range(n):
-            six.advance_iterator(self)
+            next(self)
 
     def next_if(self, expr):
         """Perform the token test and return the token if it matched.
         Otherwise the return value is `None`.
         """
         if self.current.test(expr):
-            return six.advance_iterator(self)
+            return next(self)
 
     def skip_if(self, expr):
         """Like :meth:`next_if` but only returns `True` or `False`."""
@@ -348,7 +350,7 @@ class TokenStream(six.Iterator):
             self.current = self._pushed.popleft()
         elif self.current.type is not TOKEN_EOF:
             try:
-                self.current = six.advance_iterator(self._iter)
+                self.current = next(self._iter)
             except StopIteration:
                 self.close()
         return rv
@@ -377,7 +379,7 @@ class TokenStream(six.Iterator):
         try:
             return self.current
         finally:
-            six.advance_iterator(self)
+            next(self)
 
 
 def get_lexer(environment):

diff --git a/jinja2/nodes.py b/jinja2/nodes.py
index 7e5229e0198570c3be99c8f75397564cb63a4660..e276f7ef1ff6cc9af3e70809c1acfd4a86de41cf 100644 (file)
--- a/jinja2/nodes.py
+++ b/jinja2/nodes.py
@@ -12,10 +12,12 @@
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
+import six
 import operator
+
 from collections import deque
 from jinja2.utils import Markup, MethodType, FunctionType
-import six
+from jinja2._compat import next
 from six.moves import zip
 
 
@@ -143,7 +145,7 @@ class Node(six.with_metaclass(NodeType, object)):
             setattr(self, attr, attributes.pop(attr, None))
         if attributes:
             raise TypeError('unknown attribute %r' %
-                            six.advance_iterator(iter(attributes)))
+                            next(iter(attributes)))
 
     def iter_fields(self, exclude=None, only=None):
         """This method iterates over all fields that are defined and yields

diff --git a/jinja2/parser.py b/jinja2/parser.py
index 953027cf90ccde7c255cd4e9458216c956724acd..f60cd018c51fff457dfaea5283b78267a4a0eefd 100644 (file)
--- a/jinja2/parser.py
+++ b/jinja2/parser.py
@@ -11,8 +11,7 @@
 from jinja2 import nodes
 from jinja2.exceptions import TemplateSyntaxError, TemplateAssertionError
 from jinja2.lexer import describe_token, describe_token_expr
-import six
-from six.moves import map
+from jinja2._compat import next, imap
 
 
 #: statements that callinto 
@@ -54,7 +53,7 @@ class Parser(object):
     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)
@@ -163,12 +162,12 @@ class Parser(object):
             self.fail_eof(end_tokens)
 
         if drop_needle:
-            six.advance_iterator(self.stream)
+            next(self.stream)
         return result
 
     def parse_set(self):
         """Parse an assign statement."""
-        lineno = six.advance_iterator(self.stream).lineno
+        lineno = next(self.stream).lineno
         target = self.parse_assign_target()
         self.stream.expect('assign')
         expr = self.parse_tuple()
@@ -186,7 +185,7 @@ class Parser(object):
             test = self.parse_expression()
         recursive = self.stream.skip_if('name:recursive')
         body = self.parse_statements(('name:endfor', 'name:else'))
-        if six.advance_iterator(self.stream).value == 'endfor':
+        if next(self.stream).value == 'endfor':
             else_ = []
         else:
             else_ = self.parse_statements(('name:endfor',), drop_needle=True)
@@ -200,7 +199,7 @@ class Parser(object):
             node.test = self.parse_tuple(with_condexpr=False)
             node.body = self.parse_statements(('name:elif', 'name:else',
                                                'name:endif'))
-            token = six.advance_iterator(self.stream)
+            token = next(self.stream)
             if token.test('name:elif'):
                 new_node = nodes.If(lineno=self.stream.current.lineno)
                 node.else_ = [new_node]
@@ -215,7 +214,7 @@ class Parser(object):
         return result
 
     def parse_block(self):
-        node = nodes.Block(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.Block(lineno=next(self.stream).lineno)
         node.name = self.stream.expect('name').value
         node.scoped = self.stream.skip_if('name:scoped')
 
@@ -232,21 +231,21 @@ class Parser(object):
         return node
 
     def parse_extends(self):
-        node = nodes.Extends(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.Extends(lineno=next(self.stream).lineno)
         node.template = self.parse_expression()
         return node
 
     def parse_import_context(self, node, default):
         if self.stream.current.test_any('name:with', 'name:without') and \
            self.stream.look().test('name:context'):
-            node.with_context = six.advance_iterator(self.stream).value == 'with'
+            node.with_context = next(self.stream).value == 'with'
             self.stream.skip()
         else:
             node.with_context = default
         return node
 
     def parse_include(self):
-        node = nodes.Include(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.Include(lineno=next(self.stream).lineno)
         node.template = self.parse_expression()
         if self.stream.current.test('name:ignore') and \
            self.stream.look().test('name:missing'):
@@ -257,14 +256,14 @@ class Parser(object):
         return self.parse_import_context(node, True)
 
     def parse_import(self):
-        node = nodes.Import(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.Import(lineno=next(self.stream).lineno)
         node.template = self.parse_expression()
         self.stream.expect('name:as')
         node.target = self.parse_assign_target(name_only=True).name
         return self.parse_import_context(node, False)
 
     def parse_from(self):
-        node = nodes.FromImport(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.FromImport(lineno=next(self.stream).lineno)
         node.template = self.parse_expression()
         self.stream.expect('name:import')
         node.names = []
@@ -272,7 +271,7 @@ class Parser(object):
         def parse_context():
             if self.stream.current.value in ('with', 'without') and \
                self.stream.look().test('name:context'):
-                node.with_context = six.advance_iterator(self.stream).value == 'with'
+                node.with_context = next(self.stream).value == 'with'
                 self.stream.skip()
                 return True
             return False
@@ -317,7 +316,7 @@ class Parser(object):
         self.stream.expect('rparen')
 
     def parse_call_block(self):
-        node = nodes.CallBlock(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.CallBlock(lineno=next(self.stream).lineno)
         if self.stream.current.type == 'lparen':
             self.parse_signature(node)
         else:
@@ -331,14 +330,14 @@ class Parser(object):
         return node
 
     def parse_filter_block(self):
-        node = nodes.FilterBlock(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.FilterBlock(lineno=next(self.stream).lineno)
         node.filter = self.parse_filter(None, start_inline=True)
         node.body = self.parse_statements(('name:endfilter',),
                                           drop_needle=True)
         return node
 
     def parse_macro(self):
-        node = nodes.Macro(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.Macro(lineno=next(self.stream).lineno)
         node.name = self.parse_assign_target(name_only=True).name
         self.parse_signature(node)
         node.body = self.parse_statements(('name:endmacro',),
@@ -346,7 +345,7 @@ class Parser(object):
         return node
 
     def parse_print(self):
-        node = nodes.Output(lineno=six.advance_iterator(self.stream).lineno)
+        node = nodes.Output(lineno=next(self.stream).lineno)
         node.nodes = []
         while self.stream.current.type != 'block_end':
             if node.nodes:
@@ -420,7 +419,7 @@ class Parser(object):
 
     def parse_not(self):
         if self.stream.current.test('name:not'):
-            lineno = six.advance_iterator(self.stream).lineno
+            lineno = next(self.stream).lineno
             return nodes.Not(self.parse_not(), lineno=lineno)
         return self.parse_compare()
 
@@ -431,7 +430,7 @@ class Parser(object):
         while 1:
             token_type = self.stream.current.type
             if token_type in _compare_operators:
-                six.advance_iterator(self.stream)
+                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()))
@@ -450,7 +449,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         left = self.parse_sub()
         while self.stream.current.type == 'add':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             right = self.parse_sub()
             left = nodes.Add(left, right, lineno=lineno)
             lineno = self.stream.current.lineno
@@ -460,7 +459,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         left = self.parse_concat()
         while self.stream.current.type == 'sub':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             right = self.parse_concat()
             left = nodes.Sub(left, right, lineno=lineno)
             lineno = self.stream.current.lineno
@@ -470,7 +469,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         args = [self.parse_mul()]
         while self.stream.current.type == 'tilde':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             args.append(self.parse_mul())
         if len(args) == 1:
             return args[0]
@@ -480,7 +479,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         left = self.parse_div()
         while self.stream.current.type == 'mul':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             right = self.parse_div()
             left = nodes.Mul(left, right, lineno=lineno)
             lineno = self.stream.current.lineno
@@ -490,7 +489,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         left = self.parse_floordiv()
         while self.stream.current.type == 'div':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             right = self.parse_floordiv()
             left = nodes.Div(left, right, lineno=lineno)
             lineno = self.stream.current.lineno
@@ -500,7 +499,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         left = self.parse_mod()
         while self.stream.current.type == 'floordiv':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             right = self.parse_mod()
             left = nodes.FloorDiv(left, right, lineno=lineno)
             lineno = self.stream.current.lineno
@@ -510,7 +509,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         left = self.parse_pow()
         while self.stream.current.type == 'mod':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             right = self.parse_pow()
             left = nodes.Mod(left, right, lineno=lineno)
             lineno = self.stream.current.lineno
@@ -520,7 +519,7 @@ class Parser(object):
         lineno = self.stream.current.lineno
         left = self.parse_unary()
         while self.stream.current.type == 'pow':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             right = self.parse_unary()
             left = nodes.Pow(left, right, lineno=lineno)
             lineno = self.stream.current.lineno
@@ -530,10 +529,10 @@ class Parser(object):
         token_type = self.stream.current.type
         lineno = self.stream.current.lineno
         if token_type == 'sub':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             node = nodes.Neg(self.parse_unary(False), lineno=lineno)
         elif token_type == 'add':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             node = nodes.Pos(self.parse_unary(False), lineno=lineno)
         else:
             node = self.parse_primary()
@@ -552,20 +551,20 @@ class Parser(object):
                 node = nodes.Const(None, lineno=token.lineno)
             else:
                 node = nodes.Name(token.value, 'load', lineno=token.lineno)
-            six.advance_iterator(self.stream)
+            next(self.stream)
         elif token.type == 'string':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             buf = [token.value]
             lineno = token.lineno
             while self.stream.current.type == 'string':
                 buf.append(self.stream.current.value)
-                six.advance_iterator(self.stream)
+                next(self.stream)
             node = nodes.Const(''.join(buf), lineno=lineno)
         elif token.type in ('integer', 'float'):
-            six.advance_iterator(self.stream)
+            next(self.stream)
             node = nodes.Const(token.value, lineno=token.lineno)
         elif token.type == 'lparen':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             node = self.parse_tuple(explicit_parentheses=True)
             self.stream.expect('rparen')
         elif token.type == 'lbracket':
@@ -687,10 +686,10 @@ class Parser(object):
         return node
 
     def parse_subscript(self, node):
-        token = six.advance_iterator(self.stream)
+        token = next(self.stream)
         if token.type == 'dot':
             attr_token = self.stream.current
-            six.advance_iterator(self.stream)
+            next(self.stream)
             if attr_token.type == 'name':
                 return nodes.Getattr(node, attr_token.value, 'load',
                                      lineno=token.lineno)
@@ -716,13 +715,13 @@ class Parser(object):
         lineno = self.stream.current.lineno
 
         if self.stream.current.type == 'colon':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             args = [None]
         else:
             node = self.parse_expression()
             if self.stream.current.type != 'colon':
                 return node
-            six.advance_iterator(self.stream)
+            next(self.stream)
             args = [node]
 
         if self.stream.current.type == 'colon':
@@ -733,7 +732,7 @@ class Parser(object):
             args.append(None)
 
         if self.stream.current.type == 'colon':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             if self.stream.current.type not in ('rbracket', 'comma'):
                 args.append(self.parse_expression())
             else:
@@ -763,11 +762,11 @@ class Parser(object):
                     break
             if self.stream.current.type == 'mul':
                 ensure(dyn_args is None and dyn_kwargs is None)
-                six.advance_iterator(self.stream)
+                next(self.stream)
                 dyn_args = self.parse_expression()
             elif self.stream.current.type == 'pow':
                 ensure(dyn_kwargs is None)
-                six.advance_iterator(self.stream)
+                next(self.stream)
                 dyn_kwargs = self.parse_expression()
             else:
                 ensure(dyn_args is None and dyn_kwargs is None)
@@ -793,11 +792,11 @@ class Parser(object):
     def parse_filter(self, node, start_inline=False):
         while self.stream.current.type == 'pipe' or start_inline:
             if not start_inline:
-                six.advance_iterator(self.stream)
+                next(self.stream)
             token = self.stream.expect('name')
             name = token.value
             while self.stream.current.type == 'dot':
-                six.advance_iterator(self.stream)
+                next(self.stream)
                 name += '.' + self.stream.expect('name').value
             if self.stream.current.type == 'lparen':
                 args, kwargs, dyn_args, dyn_kwargs = self.parse_call(None)
@@ -811,15 +810,15 @@ class Parser(object):
         return node
 
     def parse_test(self, node):
-        token = six.advance_iterator(self.stream)
+        token = next(self.stream)
         if self.stream.current.test('name:not'):
-            six.advance_iterator(self.stream)
+            next(self.stream)
             negated = True
         else:
             negated = False
         name = self.stream.expect('name').value
         while self.stream.current.type == 'dot':
-            six.advance_iterator(self.stream)
+            next(self.stream)
             name += '.' + self.stream.expect('name').value
         dyn_args = dyn_kwargs = None
         kwargs = []
@@ -862,14 +861,14 @@ class Parser(object):
                     if token.value:
                         add_data(nodes.TemplateData(token.value,
                                                     lineno=token.lineno))
-                    six.advance_iterator(self.stream)
+                    next(self.stream)
                 elif token.type == 'variable_begin':
-                    six.advance_iterator(self.stream)
+                    next(self.stream)
                     add_data(self.parse_tuple(with_condexpr=True))
                     self.stream.expect('variable_end')
                 elif token.type == 'block_begin':
                     flush_data()
-                    six.advance_iterator(self.stream)
+                    next(self.stream)
                     if end_tokens is not None and \
                        self.stream.current.test_any(*end_tokens):
                         return body

diff --git a/jinja2/runtime.py b/jinja2/runtime.py
index 9742ecedde790a321e131b5d070923c91c747d59..f2c47199f9ce0720d48383980ac5edc1ed92ae9a 100644 (file)
--- a/jinja2/runtime.py
+++ b/jinja2/runtime.py
@@ -14,6 +14,7 @@ from jinja2.utils import Markup, soft_unicode, escape, missing, concat, \
      internalcode, object_type_repr
 from jinja2.exceptions import UndefinedError, TemplateRuntimeError, \
      TemplateNotFound
+from jinja2._compat import next
 import six
 from six.moves import map
 
@@ -320,7 +321,7 @@ class LoopContext(object):
 
     def _safe_next(self):
         try:
-            return six.advance_iterator(self._iterator)
+            return next(self._iterator)
         except StopIteration:
             return _last_iteration
 

diff --git a/jinja2/testsuite/api.py b/jinja2/testsuite/api.py
index f6bca48173d0335d70680a9de751904dad04a09a..1b68bf8b30711e2409eedf74a0fb829c91135b0e 100644 (file)
--- a/jinja2/testsuite/api.py
+++ b/jinja2/testsuite/api.py
@@ -14,12 +14,12 @@ import tempfile
 import shutil
 
 from jinja2.testsuite import JinjaTestCase
+from jinja2._compat import next
 
 from jinja2 import Environment, Undefined, DebugUndefined, \
      StrictUndefined, UndefinedError, meta, \
      is_undefined, Template, DictLoader
 from jinja2.utils import Cycler
-import six
 
 env = Environment()
 
@@ -54,8 +54,8 @@ class ExtendedAPITestCase(JinjaTestCase):
         c = Cycler(*items)
         for item in items + items:
             assert c.current == item
-            assert six.advance_iterator(c) == item
-        six.advance_iterator(c)
+            assert next(c) == item
+        next(c)
         assert c.current == 2
         c.reset()
         assert c.current == 1
@@ -111,8 +111,8 @@ class MetaTestCase(JinjaTestCase):
     def test_find_refererenced_templates(self):
         ast = env.parse('{% extends "layout.html" %}{% include helper %}')
         i = meta.find_referenced_templates(ast)
-        assert six.advance_iterator(i) == 'layout.html'
-        assert six.advance_iterator(i) is None
+        assert next(i) == 'layout.html'
+        assert next(i) is None
         assert list(i) == []
 
         ast = env.parse('{% extends "layout.html" %}'
@@ -146,20 +146,20 @@ class StreamingTestCase(JinjaTestCase):
         tmpl = env.from_string("<ul>{% for item in seq %}<li>{{ loop.index "
                                "}} - {{ item }}</li>{%- endfor %}</ul>")
         stream = tmpl.stream(seq=list(range(4)))
-        self.assert_equal(six.advance_iterator(stream), '<ul>')
-        self.assert_equal(six.advance_iterator(stream), '<li>1 - 0</li>')
-        self.assert_equal(six.advance_iterator(stream), '<li>2 - 1</li>')
-        self.assert_equal(six.advance_iterator(stream), '<li>3 - 2</li>')
-        self.assert_equal(six.advance_iterator(stream), '<li>4 - 3</li>')
-        self.assert_equal(six.advance_iterator(stream), '</ul>')
+        self.assert_equal(next(stream), '<ul>')
+        self.assert_equal(next(stream), '<li>1 - 0</li>')
+        self.assert_equal(next(stream), '<li>2 - 1</li>')
+        self.assert_equal(next(stream), '<li>3 - 2</li>')
+        self.assert_equal(next(stream), '<li>4 - 3</li>')
+        self.assert_equal(next(stream), '</ul>')
 
     def test_buffered_streaming(self):
         tmpl = env.from_string("<ul>{% for item in seq %}<li>{{ loop.index "
                                "}} - {{ item }}</li>{%- endfor %}</ul>")
         stream = tmpl.stream(seq=list(range(4)))
         stream.enable_buffering(size=3)
-        self.assert_equal(six.advance_iterator(stream), u'<ul><li>1 - 0</li><li>2 - 1</li>')
-        self.assert_equal(six.advance_iterator(stream), u'<li>3 - 2</li><li>4 - 3</li></ul>')
+        self.assert_equal(next(stream), u'<ul><li>1 - 0</li><li>2 - 1</li>')
+        self.assert_equal(next(stream), u'<li>3 - 2</li><li>4 - 3</li></ul>')
 
     def test_streaming_behavior(self):
         tmpl = env.from_string("")

diff --git a/jinja2/testsuite/ext.py b/jinja2/testsuite/ext.py
index 817b1d2e6eb9fbe14307e6be00a027f94ffa5d26..9fd75ea60e22dd347df4060a38d89db315a3dcf3 100644 (file)
--- a/jinja2/testsuite/ext.py
+++ b/jinja2/testsuite/ext.py
@@ -9,6 +9,7 @@
     :license: BSD, see LICENSE for more details.
 """
 import re
+import six
 import unittest
 
 from jinja2.testsuite import JinjaTestCase
@@ -17,7 +18,7 @@ from jinja2 import Environment, DictLoader, contextfunction, nodes
 from jinja2.exceptions import TemplateAssertionError
 from jinja2.ext import Extension
 from jinja2.lexer import Token, count_newlines
-import six
+from jinja2._compat import next
 from six import BytesIO
 
 importable_object = 23
@@ -111,7 +112,7 @@ class TestExtension(Extension):
             self.attr('ext_attr'),
             nodes.ImportedName(__name__ + '.importable_object'),
             nodes.ContextReference()
-        ])]).set_lineno(six.advance_iterator(parser.stream).lineno)
+        ])]).set_lineno(next(parser.stream).lineno)
 
     def _dump(self, sandboxed, ext_attr, imported_object, context):
         return '%s|%s|%s|%s' % (

diff --git a/jinja2/testsuite/lexnparse.py b/jinja2/testsuite/lexnparse.py
index d2473cf01479283787eb8e05dda354e71680f0eb..cbe0f2c01df1e66adaed66c3e25fb61344433eb7 100644 (file)
--- a/jinja2/testsuite/lexnparse.py
+++ b/jinja2/testsuite/lexnparse.py
@@ -9,14 +9,15 @@
     :license: BSD, see LICENSE for more details.
 """
 import sys
+import six
 import unittest
 
 from jinja2.testsuite import JinjaTestCase
 
 from jinja2 import Environment, Template, TemplateSyntaxError, \
      UndefinedError, nodes
+from jinja2._compat import next
 from jinja2.lexer import Token, TokenStream, TOKEN_EOF, TOKEN_BLOCK_BEGIN, TOKEN_BLOCK_END
-import six
 
 env = Environment()
 
@@ -39,11 +40,11 @@ class TokenStreamTestCase(JinjaTestCase):
         assert ts.current.type is TOKEN_BLOCK_BEGIN
         assert bool(ts)
         assert not bool(ts.eos)
-        six.advance_iterator(ts)
+        next(ts)
         assert ts.current.type is TOKEN_BLOCK_END
         assert bool(ts)
         assert not bool(ts.eos)
-        six.advance_iterator(ts)
+        next(ts)
         assert ts.current.type is TOKEN_EOF
         assert not bool(ts)
         assert bool(ts.eos)
@@ -98,7 +99,7 @@ class LexerTestCase(JinjaTestCase):
             if test in '([{}])':
                 continue
             stream = env.lexer.tokenize('{{ %s }}' % test)
-            six.advance_iterator(stream)
+            next(stream)
             assert stream.current.type == expect
 
     def test_normalizing(self):