more compiler stuff
--HG--
branch : trunk
diff --git a/jinja2/nodes.py b/jinja2/nodes.py
index e6e68a1..dc8cc0b 100644
--- a/jinja2/nodes.py
+++ b/jinja2/nodes.py
@@ -35,15 +35,14 @@
}
-
-
class Impossible(Exception):
- """
- Raised if the node could not perform a requested action.
- """
+ """Raised if the node could not perform a requested action."""
class NodeType(type):
+ """A metaclass for nodes that handles the field and attribute
+ inheritance. fields and attributes from the parent class are
+ automatically forwarded to the child."""
def __new__(cls, name, bases, d):
for attr in 'fields', 'attributes':
@@ -57,9 +56,7 @@
class Node(object):
- """
- Baseclass for all Jinja nodes.
- """
+ """Baseclass for all Jinja nodes."""
__metaclass__ = NodeType
fields = ()
attributes = ('lineno',)
@@ -115,11 +112,10 @@
yield result
def set_ctx(self, ctx):
- """
- Reset the context of a node and all child nodes. Per default the parser
- will all generate nodes that have a 'load' context as it's the most common
- one. This method is used in the parser to set assignment targets and
- other nodes to a store context.
+ """Reset the context of a node and all child nodes. Per default the
+ parser will all generate nodes that have a 'load' context as it's the
+ most common one. This method is used in the parser to set assignment
+ targets and other nodes to a store context.
"""
todo = deque([self])
while todo:
@@ -137,28 +133,21 @@
class Stmt(Node):
- """
- Base node for all statements.
- """
+ """Base node for all statements."""
class Helper(Node):
- """
- Nodes that exist in a specific context only.
- """
+ """Nodes that exist in a specific context only."""
class Template(Node):
- """
- Node that represents a template.
- """
+ """Node that represents a template."""
fields = ('body',)
class Output(Stmt):
- """
- A node that holds multiple expressions which are then printed out. This
- is used both for the `print` statement and the regular template data.
+ """A node that holds multiple expressions which are then printed out.
+ This is used both for the `print` statement and the regular template data.
"""
fields = ('nodes',)
@@ -179,112 +168,81 @@
class Extends(Stmt):
- """
- Represents an extends statement.
- """
+ """Represents an extends statement."""
fields = ('template',)
class For(Stmt):
- """
- A node that represents a for loop
- """
+ """A node that represents a for loop"""
fields = ('target', 'iter', 'body', 'else_', 'recursive')
class If(Stmt):
- """
- A node that represents an if condition.
- """
+ """A node that represents an if condition."""
fields = ('test', 'body', 'else_')
class Macro(Stmt):
- """
- A node that represents a macro.
- """
- fields = ('name', 'args', 'defaults', 'dyn_args', 'dyn_kwargs', 'body')
+ """A node that represents a macro."""
+ fields = ('name', 'args', 'defaults', 'body')
class CallBlock(Stmt):
- """
- A node that represents am extended macro call.
- """
+ """A node that represents am extended macro call."""
fields = ('call', 'body')
class Set(Stmt):
- """
- Allows defining own variables.
- """
+ """Allows defining own variables."""
fields = ('name', 'expr')
class FilterBlock(Stmt):
- """
- Node for filter sections.
- """
+ """Node for filter sections."""
fields = ('body', 'filters')
class Block(Stmt):
- """
- A node that represents a block.
- """
+ """A node that represents a block."""
fields = ('name', 'body')
class Include(Stmt):
- """
- A node that represents the include tag.
- """
+ """A node that represents the include tag."""
fields = ('template', 'target')
class Trans(Stmt):
- """
- A node for translatable sections.
- """
+ """A node for translatable sections."""
fields = ('singular', 'plural', 'indicator', 'replacements')
class ExprStmt(Stmt):
- """
- A statement that evaluates an expression to None.
- """
+ """A statement that evaluates an expression to None."""
fields = ('node',)
class Assign(Stmt):
- """
- Assigns an expression to a target.
- """
+ """Assigns an expression to a target."""
fields = ('target', 'node')
class Expr(Node):
- """
- Baseclass for all expressions.
- """
+ """Baseclass for all expressions."""
def as_const(self):
- """
- Return the value of the expression as constant or raise `Impossible`
- if this was not possible.
+ """Return the value of the expression as constant or raise
+ `Impossible` if this was not possible.
"""
raise Impossible()
def can_assign(self):
- """
- Check if it's possible to assign something to this node.
- """
+ """Check if it's possible to assign something to this node."""
return False
class BinExpr(Expr):
- """
- Baseclass for all binary expressions.
- """
+ """Baseclass for all binary expressions."""
fields = ('left', 'right')
operator = None
@@ -293,14 +251,11 @@
try:
return f(self.left.as_const(), self.right.as_const())
except:
- print self.left, f, self.right
raise Impossible()
class UnaryExpr(Expr):
- """
- Baseclass for all unary expressions.
- """
+ """Baseclass for all unary expressions."""
fields = ('node',)
operator = None
@@ -313,9 +268,7 @@
class Name(Expr):
- """
- any name such as {{ foo }}
- """
+ """any name such as {{ foo }}"""
fields = ('name', 'ctx')
def can_assign(self):
@@ -323,15 +276,11 @@
class Literal(Expr):
- """
- Baseclass for literals.
- """
+ """Baseclass for literals."""
class Const(Literal):
- """
- any constat such as {{ "foo" }}
- """
+ """any constat such as {{ "foo" }}"""
fields = ('value',)
def as_const(self):
@@ -339,8 +288,7 @@
class Tuple(Literal):
- """
- For loop unpacking and some other things like multiple arguments
+ """For loop unpacking and some other things like multiple arguments
for subscripts.
"""
fields = ('items', 'ctx')
@@ -356,9 +304,7 @@
class List(Literal):
- """
- any list literal such as {{ [1, 2, 3] }}
- """
+ """any list literal such as {{ [1, 2, 3] }}"""
fields = ('items',)
def as_const(self):
@@ -366,9 +312,7 @@
class Dict(Literal):
- """
- any dict literal such as {{ {1: 2, 3: 4} }}
- """
+ """any dict literal such as {{ {1: 2, 3: 4} }}"""
fields = ('items',)
def as_const(self):
@@ -376,19 +320,20 @@
class Pair(Helper):
- """
- A key, value pair for dicts.
- """
+ """A key, value pair for dicts."""
fields = ('key', 'value')
def as_const(self):
return self.key.as_const(), self.value.as_const()
+class Keyword(Helper):
+ """A key, value pair for keyword arguments."""
+ fields = ('key', 'value')
+
+
class CondExpr(Expr):
- """
- {{ foo if bar else baz }}
- """
+ """{{ foo if bar else baz }}"""
fields = ('test', 'expr1', 'expr2')
def as_const(self):
@@ -398,37 +343,27 @@
class Filter(Expr):
- """
- {{ foo|bar|baz }}
- """
+ """{{ foo|bar|baz }}"""
fields = ('node', 'filters')
class FilterCall(Expr):
- """
- {{ |bar() }}
- """
+ """{{ |bar() }}"""
fields = ('name', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
class Test(Expr):
- """
- {{ foo is lower }}
- """
+ """{{ foo is lower }}"""
fields = ('node', 'name', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
class Call(Expr):
- """
- {{ foo(bar) }}
- """
+ """{{ foo(bar) }}"""
fields = ('node', 'args', 'kwargs', 'dyn_args', 'dyn_kwargs')
class Subscript(Expr):
- """
- {{ foo.bar }} and {{ foo['bar'] }} etc.
- """
+ """{{ foo.bar }} and {{ foo['bar'] }} etc."""
fields = ('node', 'arg', 'ctx')
def as_const(self):
@@ -442,16 +377,12 @@
class Slice(Expr):
- """
- 1:2:3 etc.
- """
+ """1:2:3 etc."""
fields = ('start', 'stop', 'step')
class Concat(Expr):
- """
- For {{ foo ~ bar }}. Concatenates strings.
- """
+ """For {{ foo ~ bar }}. Concatenates strings."""
fields = ('nodes',)
def as_const(self):
@@ -459,72 +390,52 @@
class Compare(Expr):
- """
- {{ foo == bar }}, {{ foo >= bar }} etc.
- """
+ """{{ foo == bar }}, {{ foo >= bar }} etc."""
fields = ('expr', 'ops')
class Operand(Helper):
- """
- Operator + expression.
- """
+ """Operator + expression."""
fields = ('op', 'expr')
class Mul(BinExpr):
- """
- {{ foo * bar }}
- """
+ """{{ foo * bar }}"""
operator = '*'
class Div(BinExpr):
- """
- {{ foo / bar }}
- """
+ """{{ foo / bar }}"""
operator = '/'
class FloorDiv(BinExpr):
- """
- {{ foo // bar }}
- """
+ """{{ foo // bar }}"""
operator = '//'
class Add(BinExpr):
- """
- {{ foo + bar }}
- """
+ """{{ foo + bar }}"""
operator = '+'
class Sub(BinExpr):
- """
- {{ foo - bar }}
- """
+ """{{ foo - bar }}"""
operator = '-'
class Mod(BinExpr):
- """
- {{ foo % bar }}
- """
+ """{{ foo % bar }}"""
operator = '%'
class Pow(BinExpr):
- """
- {{ foo ** bar }}
- """
+ """{{ foo ** bar }}"""
operator = '**'
class And(BinExpr):
- """
- {{ foo and bar }}
- """
+ """{{ foo and bar }}"""
operator = 'and'
def as_const(self):
@@ -532,9 +443,7 @@
class Or(BinExpr):
- """
- {{ foo or bar }}
- """
+ """{{ foo or bar }}"""
operator = 'or'
def as_const(self):
@@ -542,21 +451,15 @@
class Not(UnaryExpr):
- """
- {{ not foo }}
- """
+ """{{ not foo }}"""
operator = 'not'
class Neg(UnaryExpr):
- """
- {{ -foo }}
- """
+ """{{ -foo }}"""
operator = '-'
class Pos(UnaryExpr):
- """
- {{ +foo }}
- """
+ """{{ +foo }}"""
operator = '+'