Update Jinja2 (Python template library) to 2.7.1

third_party/jinja2/compiler.py

 # -*- coding: utf-8 -*-
 """
     jinja2.compiler
     ~~~~~~~~~~~~~~~
 
     Compiles nodes into python code.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
-from cStringIO import StringIO
 from itertools import chain
 from copy import deepcopy
+from keyword import iskeyword as is_python_keyword
 from jinja2 import nodes
 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, next
+from jinja2.utils import Markup, concat, escape
+from jinja2._compat import range_type, next, text_type, string_types, \
+     iteritems, NativeStringIO, imap
 
 
 operators = {
     'eq':       '==',
     'ne':       '!=',
     'gt':       '>',
     'gteq':     '>=',
     'lt':       '<',
     'lteq':     '<=',
     'in':       'in',
     'notin':    'not in'
 }
 
-try:
-    exec '(0 if 0 else 0)'
-except SyntaxError:
-    have_condexpr = False
-else:
-    have_condexpr = True
-
-
 # what method to iterate over items do we want to use for dict iteration
 # in generated code?  on 2.x let's go with iteritems, on 3.x with items
 if hasattr(dict, 'iteritems'):
     dict_item_iter = 'iteritems'
 else:
     dict_item_iter = 'items'
 
 
 # does if 0: dummy(x) get us x into the scope?
 def unoptimize_before_dead_code():
     x = 42
     def f():
         if 0: dummy(x)
     return f
-unoptimize_before_dead_code = bool(unoptimize_before_dead_code().func_closure)
+
+# The getattr is necessary for pypy which does not set this attribute if
+# no closure is on the function
+unoptimize_before_dead_code = bool(
+    getattr(unoptimize_before_dead_code(), '__closure__', None))
 
 
 def generate(node, environment, name, filename, stream=None,
              defer_init=False):
     """Generate the python source for a node tree."""
     if not isinstance(node, nodes.Template):
         raise TypeError('Can\'t compile non template nodes')
     generator = CodeGenerator(environment, name, filename, stream, defer_init)
     generator.visit(node)
     if stream is None:
         return generator.stream.getvalue()
 
 
 def has_safe_repr(value):
     """Does the node have a safe representation?"""
     if value is None or value is NotImplemented or value is Ellipsis:
         return True
-    if isinstance(value, (bool, int, long, float, complex, basestring,
-                          xrange, Markup)):
+    if isinstance(value, (bool, int, float, complex, range_type,
+            Markup) + string_types):
         return True
     if isinstance(value, (tuple, list, set, frozenset)):
         for item in value:
             if not has_safe_repr(item):
                 return False
         return True
     elif isinstance(value, dict):
-        for key, value in value.iteritems():
+        for key, value in iteritems(value):
             if not has_safe_repr(key):
                 return False
             if not has_safe_repr(value):
                 return False
         return True
     return False
 
 
 def find_undeclared(nodes, names):
     """Check if the names passed are accessed undeclared.  The return value
@@ skipping 269 matching lines @@
     doesn't make sense to further process the code.  Any block that
     raises such an exception is not further processed.
     """
 
 
 class CodeGenerator(NodeVisitor):
 
     def __init__(self, environment, name, filename, stream=None,
                  defer_init=False):
         if stream is None:
-            stream = StringIO()
+            stream = NativeStringIO()
         self.environment = environment
         self.name = name
         self.filename = filename
         self.stream = stream
         self.created_block_context = False
         self.defer_init = defer_init
 
         # aliases for imports
         self.import_aliases = {}
 
@@ skipping 153 matching lines @@
 
         for arg in node.args:
             self.write(', ')
             self.visit(arg, frame)
 
         if not kwarg_workaround:
             for kwarg in node.kwargs:
                 self.write(', ')
                 self.visit(kwarg, frame)
             if extra_kwargs is not None:
-                for key, value in extra_kwargs.iteritems():
+                for key, value in iteritems(extra_kwargs):
                     self.write(', %s=%s' % (key, value))
         if node.dyn_args:
             self.write(', *')
             self.visit(node.dyn_args, frame)
 
         if kwarg_workaround:
             if node.dyn_kwargs is not None:
                 self.write(', **dict({')
             else:
                 self.write(', **{')
             for kwarg in node.kwargs:
                 self.write('%r: ' % kwarg.key)
                 self.visit(kwarg.value, frame)
                 self.write(', ')
             if extra_kwargs is not None:
-                for key, value in extra_kwargs.iteritems():
+                for key, value in iteritems(extra_kwargs):
                     self.write('%r: %s, ' % (key, value))
             if node.dyn_kwargs is not None:
                 self.write('}, **')
                 self.visit(node.dyn_kwargs, frame)
                 self.write(')')
             else:
                 self.write('}')
 
         elif node.dyn_kwargs is not None:
             self.write(', **')
@@ skipping 46 matching lines @@
         to_declare = set()
         for name in frame.identifiers.declared_locally:
             if name not in aliases:
                 to_declare.add('l_' + name)
         if to_declare:
             self.writeline(' = '.join(to_declare) + ' = missing')
         return aliases
 
     def pop_scope(self, aliases, frame):
         """Restore all aliases and delete unused variables."""
-        for name, alias in aliases.iteritems():
+        for name, alias in iteritems(aliases):
             self.writeline('l_%s = %s' % (name, alias))
         to_delete = set()
         for name in frame.identifiers.declared_locally:
             if name not in aliases:
                 to_delete.add('l_' + name)
         if to_delete:
             # we cannot use the del statement here because enclosed
             # scopes can trigger a SyntaxError:
             #   a = 42; b = lambda: a; del a
             self.writeline(' = '.join(to_delete) + ' = missing')
@@ skipping 17 matching lines @@
         children = list(children)
         func_frame = frame.inner()
         func_frame.inspect(children)
 
         # variables that are undeclared (accessed before declaration) and
         # declared locally *and* part of an outside scope raise a template
         # assertion error. Reason: we can't generate reasonable code from
         # it without aliasing all the variables.
         # this could be fixed in Python 3 where we have the nonlocal
         # keyword or if we switch to bytecode generation
-        overriden_closure_vars = (
+        overridden_closure_vars = (
             func_frame.identifiers.undeclared &
             func_frame.identifiers.declared &
             (func_frame.identifiers.declared_locally |
              func_frame.identifiers.declared_parameter)
         )
-        if overriden_closure_vars:
+        if overridden_closure_vars:
             self.fail('It\'s not possible to set and access variables '
                       'derived from an outer scope! (affects: %s)' %
-                      ', '.join(sorted(overriden_closure_vars)), node.lineno)
+                      ', '.join(sorted(overridden_closure_vars)), node.lineno)
 
         # remove variables from a closure from the frame's undeclared
         # identifiers.
         func_frame.identifiers.undeclared -= (
             func_frame.identifiers.undeclared &
             func_frame.identifiers.declared
         )
 
         # no special variables for this scope, abort early
         if not find_special:
@@ skipping 134 matching lines @@
                 self.indent()
                 self.writeline('if parent_template is not None:')
             self.indent()
             self.writeline('for event in parent_template.'
                            'root_render_func(context):')
             self.indent()
             self.writeline('yield event')
             self.outdent(2 + (not self.has_known_extends))
 
         # at this point we now have the blocks collected and can visit them too.
-        for name, block in self.blocks.iteritems():
+        for name, block in iteritems(self.blocks):
             block_frame = Frame(eval_ctx)
             block_frame.inspect(block.body)
             block_frame.block = name
             self.writeline('def block_%s(context%s):' % (name, envenv),
                            block, 1)
             self.indent()
             undeclared = find_undeclared(block.body, ('self', 'super'))
             if 'self' in undeclared:
                 block_frame.identifiers.add_special('self')
                 self.writeline('l_self = TemplateReference(context)')
@@ skipping 46 matching lines @@
 
             # if we have a known extends we just add a template runtime
             # error into the generated code.  We could catch that at compile
             # time too, but i welcome it not to confuse users by throwing the
             # same error at different times just "because we can".
             if not self.has_known_extends:
                 self.writeline('if parent_template is not None:')
                 self.indent()
             self.writeline('raise TemplateRuntimeError(%r)' %
                            'extended multiple times')
-            self.outdent()
 
             # if we have a known extends already we don't need that code here
             # as we know that the template execution will end here.
             if self.has_known_extends:
                 raise CompilerExit()
+            else:
+                self.outdent()
 
         self.writeline('parent_template = environment.get_template(', node)
         self.visit(node.template, frame)
         self.write(', %r)' % self.name)
         self.writeline('for name, parent_block in parent_template.'
                        'blocks.%s():' % dict_item_iter)
         self.indent()
         self.writeline('context.blocks.setdefault(name, []).'
                        'append(parent_block)')
         self.outdent()
@@ skipping 10 matching lines @@
     def visit_Include(self, node, frame):
         """Handles includes."""
         if node.with_context:
             self.unoptimize_scope(frame)
         if node.ignore_missing:
             self.writeline('try:')
             self.indent()
 
         func_name = 'get_or_select_template'
         if isinstance(node.template, nodes.Const):
-            if isinstance(node.template.value, basestring):
+            if isinstance(node.template.value, string_types):
                 func_name = 'get_template'
             elif isinstance(node.template.value, (tuple, list)):
                 func_name = 'select_template'
         elif isinstance(node.template, (nodes.Tuple, nodes.List)):
             func_name = 'select_template'
 
         self.writeline('template = environment.%s(' % func_name, node)
         self.visit(node.template, frame)
         self.write(', %r)' % self.name)
         if node.ignore_missing:
@@ skipping 81 matching lines @@
             else:
                 self.writeline('context.vars.update({%s})' % ', '.join(
                     '%r: l_%s' % (name, name) for name in var_names
                 ))
         if discarded_names:
             if len(discarded_names) == 1:
                 self.writeline('context.exported_vars.discard(%r)' %
                                discarded_names[0])
             else:
                 self.writeline('context.exported_vars.difference_'
-                               'update((%s))' % ', '.join(map(repr, discarded_names)))
+                               'update((%s))' % ', '.join(imap(repr, discarded_names)))
 
     def visit_For(self, node, frame):
         # when calculating the nodes for the inner frame we have to exclude
         # the iterator contents from it
         children = node.iter_child_nodes(exclude=('iter',))
         if node.recursive:
             loop_frame = self.function_scoping(node, frame, children,
                                                find_special=False)
         else:
             loop_frame = frame.inner()
             loop_frame.inspect(children)
 
         # try to figure out if we have an extended loop.  An extended loop
         # is necessary if the loop is in recursive mode if the special loop
         # variable is accessed in the body.
         extended_loop = node.recursive or 'loop' in \
                         find_undeclared(node.iter_child_nodes(
                             only=('body',)), ('loop',))
 
         # if we don't have an recursive loop we have to find the shadowed
         # variables at that point.  Because loops can be nested but the loop
         # variable is a special one we have to enforce aliasing for it.
         if not node.recursive:
             aliases = self.push_scope(loop_frame, ('loop',))
 
         # otherwise we set up a buffer and add a function def
         else:
-            self.writeline('def loop(reciter, loop_render_func):', node)
+            self.writeline('def loop(reciter, loop_render_func, depth=0):', node)
             self.indent()
             self.buffer(loop_frame)
             aliases = {}
 
         # make sure the loop variable is a special one and raise a template
         # assertion error if a loop tries to write to loop
         if extended_loop:
+            self.writeline('l_loop = missing')
             loop_frame.identifiers.add_special('loop')
         for name in node.find_all(nodes.Name):
             if name.ctx == 'store' and name.name == 'loop':
                 self.fail('Can\'t assign to special loop variable '
                           'in for-loop target', name.lineno)
 
         self.pull_locals(loop_frame)
         if node.else_:
             iteration_indicator = self.temporary_identifier()
             self.writeline('%s = 1' % iteration_indicator)
@@ skipping 30 matching lines @@
             test_frame = loop_frame.copy()
             self.visit(node.test, test_frame)
             self.write('))')
 
         elif node.recursive:
             self.write('reciter')
         else:
             self.visit(node.iter, loop_frame)
 
         if node.recursive:
-            self.write(', recurse=loop_render_func):')
+            self.write(', loop_render_func, depth):')
         else:
             self.write(extended_loop and '):' or ':')
 
         # tests in not extended loops become a continue
         if not extended_loop and node.test is not None:
             self.indent()
             self.writeline('if not ')
             self.visit(node.test, loop_frame)
             self.write(':')
             self.indent()
@@ skipping 77 matching lines @@
         self.newline(node)
         self.visit(node.node, frame)
 
     def visit_Output(self, node, frame):
         # if we have a known extends statement, we don't output anything
         # if we are in a require_output_check section
         if self.has_known_extends and frame.require_output_check:
             return
 
         if self.environment.finalize:
-            finalize = lambda x: unicode(self.environment.finalize(x))
+            finalize = lambda x: text_type(self.environment.finalize(x))
         else:
-            finalize = unicode
+            finalize = text_type
 
         # if we are inside a frame that requires output checking, we do so
         outdent_later = False
         if frame.require_output_check:
             self.writeline('if parent_template is None:')
             self.indent()
             outdent_later = True
 
         # try to evaluate as many chunks as possible into a static
         # string at compile time.
@@ skipping 128 matching lines @@
                     if idx:
                         self.write(', ')
                     self.write('%r: l_%s' % (name, name))
                 self.write('})')
             if public_names:
                 if len(public_names) == 1:
                     self.writeline('context.exported_vars.add(%r)' %
                                    public_names[0])
                 else:
                     self.writeline('context.exported_vars.update((%s))' %
-                                   ', '.join(map(repr, public_names)))
+                                   ', '.join(imap(repr, public_names)))
 
     # -- Expression Visitors
 
     def visit_Name(self, node, frame):
         if node.ctx == 'store' and frame.toplevel:
             frame.toplevel_assignments.add(node.name)
         self.write('l_' + node.name)
         frame.assigned_names.add(node.name)
 
     def visit_Const(self, node, frame):
@@ skipping 167 matching lines @@
         self.write(')')
 
     def visit_CondExpr(self, node, frame):
         def write_expr2():
             if node.expr2 is not None:
                 return self.visit(node.expr2, frame)
             self.write('environment.undefined(%r)' % ('the inline if-'
                        'expression on %s evaluated to false and '
                        'no else section was defined.' % self.position(node)))
 
-        if not have_condexpr:
-            self.write('((')
-            self.visit(node.test, frame)
-            self.write(') and (')
-            self.visit(node.expr1, frame)
-            self.write(',) or (')
-            write_expr2()
-            self.write(',))[0]')
-        else:
-            self.write('(')
-            self.visit(node.expr1, frame)
-            self.write(' if ')
-            self.visit(node.test, frame)
-            self.write(' else ')
-            write_expr2()
-            self.write(')')
+        self.write('(')
+        self.visit(node.expr1, frame)
+        self.write(' if ')
+        self.visit(node.test, frame)
+        self.write(' else ')
+        write_expr2()
+        self.write(')')
 
     def visit_Call(self, node, frame, forward_caller=False):
         if self.environment.sandboxed:
             self.write('environment.call(context, ')
         else:
             self.write('context.call(')
         self.visit(node.node, frame)
         extra_kwargs = forward_caller and {'caller': 'caller'} or None
         self.signature(node, frame, extra_kwargs)
         self.write(')')
@@ skipping 56 matching lines @@
 
     def visit_ScopedEvalContextModifier(self, node, frame):
         old_ctx_name = self.temporary_identifier()
         safed_ctx = frame.eval_ctx.save()
         self.writeline('%s = context.eval_ctx.save()' % old_ctx_name)
         self.visit_EvalContextModifier(node, frame)
         for child in node.body:
             self.visit(child, frame)
         frame.eval_ctx.revert(safed_ctx)
         self.writeline('context.eval_ctx.revert(%s)' % old_ctx_name)