Update Jinja2 (Python template library) to 2.7.1

third_party/jinja2/nodes.py

 # -*- coding: utf-8 -*-
 """
     jinja2.nodes
     ~~~~~~~~~~~~
 
     This module implements additional nodes derived from the ast base node.
 
     It also provides some node tree helper functions like `in_lineno` and
     `get_nodes` used by the parser and translator in order to normalize
     python and jinja nodes.
 
     :copyright: (c) 2010 by the Jinja Team.
     :license: BSD, see LICENSE for more details.
 """
 import operator
-from itertools import chain, izip
+
 from collections import deque
-from jinja2.utils import Markup, MethodType, FunctionType
+from jinja2.utils import Markup
+from jinja2._compat import next, izip, with_metaclass, text_type, \
+     method_type, function_type
 
 
 #: the types we support for context functions
-_context_function_types = (FunctionType, MethodType)
+_context_function_types = (function_type, method_type)
 
 
 _binop_to_func = {
     '*':        operator.mul,
     '/':        operator.truediv,
     '//':       operator.floordiv,
     '**':       operator.pow,
     '%':        operator.mod,
     '+':        operator.add,
     '-':        operator.sub
@@ skipping 62 matching lines @@
 def get_eval_context(node, ctx):
     if ctx is None:
         if node.environment is None:
             raise RuntimeError('if no eval context is passed, the '
                                'node must have an attached '
                                'environment.')
         return EvalContext(node.environment)
     return ctx
 
 
-class Node(object):
+class Node(with_metaclass(NodeType, object)):
     """Baseclass for all Jinja2 nodes.  There are a number of nodes available
-    of different types.  There are three major types:
+    of different types.  There are four major types:
 
     -   :class:`Stmt`: statements
     -   :class:`Expr`: expressions
     -   :class:`Helper`: helper nodes
     -   :class:`Template`: the outermost wrapper node
 
     All nodes have fields and attributes.  Fields may be other nodes, lists,
     or arbitrary values.  Fields are passed to the constructor as regular
     positional arguments, attributes as keyword arguments.  Each node has
     two attributes: `lineno` (the line number of the node) and `environment`.
     The `environment` attribute is set at the end of the parsing process for
     all nodes automatically.
     """
-    __metaclass__ = NodeType
     fields = ()
     attributes = ('lineno', 'environment')
     abstract = True
 
     def __init__(self, *fields, **attributes):
         if self.abstract:
             raise TypeError('abstract nodes are not instanciable')
         if fields:
             if len(fields) != len(self.fields):
                 if not self.fields:
                     raise TypeError('%r takes 0 arguments' %
                                     self.__class__.__name__)
                 raise TypeError('%r takes 0 or %d argument%s' % (
                     self.__class__.__name__,
                     len(self.fields),
                     len(self.fields) != 1 and 's' or ''
                 ))
             for name, arg in izip(self.fields, fields):
                 setattr(self, name, arg)
         for attr in self.attributes:
             setattr(self, attr, attributes.pop(attr, None))
         if attributes:
             raise TypeError('unknown attribute %r' %
-                            iter(attributes).next())
+                            next(iter(attributes)))
 
     def iter_fields(self, exclude=None, only=None):
         """This method iterates over all fields that are defined and yields
         ``(key, value)`` tuples.  Per default all fields are returned, but
         it's possible to limit that to some fields by providing the `only`
         parameter or to exclude some using the `exclude` parameter.  Both
         should be sets or tuples of field names.
         """
         for name in self.fields:
             if (exclude is only is None) or \
@@ skipping 68 matching lines @@
             todo.extend(node.iter_child_nodes())
         return self
 
     def __eq__(self, other):
         return type(self) is type(other) and \
                tuple(self.iter_fields()) == tuple(other.iter_fields())
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
+    # Restore Python 2 hashing behavior on Python 3
+    __hash__ = object.__hash__
+
     def __repr__(self):
         return '%s(%s)' % (
             self.__class__.__name__,
             ', '.join('%s=%r' % (arg, getattr(self, arg, None)) for
                       arg in self.fields)
         )
 
 
 class Stmt(Node):
     """Base node for all statements."""
@@ skipping 189 matching lines @@
 
     def as_const(self, eval_ctx=None):
         return self.value
 
     @classmethod
     def from_untrusted(cls, value, lineno=None, environment=None):
         """Return a const object if the value is representable as
         constant value in the generated code, otherwise it will raise
         an `Impossible` exception.
         """
-        from compiler import has_safe_repr
+        from .compiler import has_safe_repr
         if not has_safe_repr(value):
             raise Impossible()
         return cls(value, lineno=lineno, environment=environment)
 
 
 class TemplateData(Literal):
     """A constant template string."""
     fields = ('data',)
 
     def as_const(self, eval_ctx=None):
@@ skipping 226 matching lines @@
 
 
 class Concat(Expr):
     """Concatenates the list of expressions provided after converting them to
     unicode.
     """
     fields = ('nodes',)
 
     def as_const(self, eval_ctx=None):
         eval_ctx = get_eval_context(self, eval_ctx)
-        return ''.join(unicode(x.as_const(eval_ctx)) for x in self.nodes)
+        return ''.join(text_type(x.as_const(eval_ctx)) for x in self.nodes)
 
 
 class Compare(Expr):
     """Compares an expression with some other expressions.  `ops` must be a
     list of :class:`Operand`\s.
     """
     fields = ('expr', 'ops')
 
     def as_const(self, eval_ctx=None):
         eval_ctx = get_eval_context(self, eval_ctx)
@@ skipping 200 matching lines @@
     :class:`EvalContextModifier` but will only modify the
     :class:`~jinja2.nodes.EvalContext` for nodes in the :attr:`body`.
     """
     fields = ('body',)
 
 
 # make sure nobody creates custom nodes
 def _failing_new(*args, **kwargs):
     raise TypeError('can\'t create custom node types')
 NodeType.__new__ = staticmethod(_failing_new); del _failing_new