Update Jinja2 (Python template library) to 2.7.1

third_party/jinja2/debug.py

 # -*- coding: utf-8 -*-
 """
     jinja2.debug
     ~~~~~~~~~~~~
 
     Implements the debug interface for Jinja.  This module does some pretty
     ugly stuff with the Python traceback system in order to achieve tracebacks
     with correct line numbers, locals and contents.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
 import sys
 import traceback
 from types import TracebackType
-from jinja2.utils import CodeType, missing, internal_code
+from jinja2.utils import missing, internal_code
 from jinja2.exceptions import TemplateSyntaxError
+from jinja2._compat import iteritems, reraise, code_type
 
 # on pypy we can take advantage of transparent proxies
 try:
     from __pypy__ import tproxy
 except ImportError:
     tproxy = None
 
 
 # how does the raise helper look like?
 try:
-    exec "raise TypeError, 'foo'"
+    exec("raise TypeError, 'foo'")
 except SyntaxError:
     raise_helper = 'raise __jinja_exception__[1]'
 except TypeError:
     raise_helper = 'raise __jinja_exception__[0], __jinja_exception__[1]'
 
 
 class TracebackFrameProxy(object):
     """Proxies a traceback frame."""
 
     def __init__(self, tb):
@@ skipping 31 matching lines @@
         if operation in ('__getattribute__', '__getattr__'):
             return getattr(proxy, args[0])
         elif operation == '__setattr__':
             proxy.__setattr__(*args, **kwargs)
         else:
             return getattr(proxy, operation)(*args, **kwargs)
     return tproxy(TracebackType, operation_handler)
 
 
 class ProcessedTraceback(object):
-    """Holds a Jinja preprocessed traceback for priting or reraising."""
+    """Holds a Jinja preprocessed traceback for printing or reraising."""
 
     def __init__(self, exc_type, exc_value, frames):
         assert frames, 'no frames for this traceback?'
         self.exc_type = exc_type
         self.exc_value = exc_value
         self.frames = frames
 
         # newly concatenate the frames (which are proxies)
         prev_tb = None
         for tb in self.frames:
@@ skipping 60 matching lines @@
 
 
 def translate_exception(exc_info, initial_skip=0):
     """If passed an exc_info it will automatically rewrite the exceptions
     all the way down to the correct line numbers and frames.
     """
     tb = exc_info[2]
     frames = []
 
     # skip some internal frames if wanted
-    for x in xrange(initial_skip):
+    for x in range(initial_skip):
         if tb is not None:
             tb = tb.tb_next
     initial_tb = tb
 
     while tb is not None:
         # skip frames decorated with @internalcode.  These are internal
         # calls we can't avoid and that are useless in template debugging
         # output.
         if tb.tb_frame.f_code in internal_code:
             tb = tb.tb_next
@@ skipping 10 matching lines @@
             tb = fake_exc_info(exc_info[:2] + (tb,), template.filename,
                                lineno)[2]
 
         frames.append(make_frame_proxy(tb))
         tb = next
 
     # if we don't have any exceptions in the frames left, we have to
     # reraise it unchanged.
     # XXX: can we backup here?  when could this happen?
     if not frames:
-        raise exc_info[0], exc_info[1], exc_info[2]
+        reraise(exc_info[0], exc_info[1], exc_info[2])
 
     return ProcessedTraceback(exc_info[0], exc_info[1], frames)
 
 
 def fake_exc_info(exc_info, filename, lineno):
     """Helper for `translate_exception`."""
     exc_type, exc_value, tb = exc_info
 
     # figure the real context out
     if tb is not None:
         real_locals = tb.tb_frame.f_locals.copy()
         ctx = real_locals.get('context')
         if ctx:
             locals = ctx.get_all()
         else:
             locals = {}
-        for name, value in real_locals.iteritems():
+        for name, value in iteritems(real_locals):
             if name.startswith('l_') and value is not missing:
                 locals[name[2:]] = value
 
         # if there is a local called __jinja_exception__, we get
         # rid of it to not break the debug functionality.
         locals.pop('__jinja_exception__', None)
     else:
         locals = {}
 
     # assamble fake globals we need
@@ skipping 17 matching lines @@
         if tb is None:
             location = 'template'
         else:
             function = tb.tb_frame.f_code.co_name
             if function == 'root':
                 location = 'top-level template code'
             elif function.startswith('block_'):
                 location = 'block "%s"' % function[6:]
             else:
                 location = 'template'
-        code = CodeType(0, code.co_nlocals, code.co_stacksize,
-                        code.co_flags, code.co_code, code.co_consts,
-                        code.co_names, code.co_varnames, filename,
-                        location, code.co_firstlineno,
-                        code.co_lnotab, (), ())
+        code = code_type(0, code.co_nlocals, code.co_stacksize,
+                         code.co_flags, code.co_code, code.co_consts,
+                         code.co_names, code.co_varnames, filename,
+                         location, code.co_firstlineno,
+                         code.co_lnotab, (), ())
     except:
         pass
 
     # execute the code and catch the new traceback
     try:
-        exec code in globals, locals
+        exec(code, globals, locals)
     except:
         exc_info = sys.exc_info()
         new_tb = exc_info[2].tb_next
 
     # return without this frame
     return exc_info[:2] + (new_tb,)
 
 
 def _init_ugly_crap():
     """This function implements a few ugly things so that we can patch the
@@ skipping 55 matching lines @@
             obj.tb_next = ctypes.pointer(next)
 
     return tb_set_next
 
 
 # try to get a tb_set_next implementation if we don't have transparent
 # proxies.
 tb_set_next = None
 if tproxy is None:
     try:
-        from jinja2._debugsupport import tb_set_next
-    except ImportError:
-        try:
-            tb_set_next = _init_ugly_crap()
-        except:
-            pass
+        tb_set_next = _init_ugly_crap()
+    except:
+        pass
     del _init_ugly_crap