# HG changeset patch
# User cmlenz
# Date 1151519945 0
# Node ID 9a958398bed98e7fc43831711c12f1bfe4c3302f
# Parent  2ee9f28e16e5fb2a88ba36d0fbfcb39eb8a7f81d
 * More test cases for expression evaluation.
 * Fixes for the new AST-based Python 2.5 evaluation.

diff --git a/markup/eval.py b/markup/eval.py
--- a/markup/eval.py
+++ b/markup/eval.py
@@ -58,44 +58,7 @@
     >>> Expression('mine[key]').evaluate(data)
     'Bar'
     
-    Most of the standard Python operators are also available to template
-    expressions. Bitwise operators (including inversion and shifting) are not
-    supported.
-    
-    >>> Expression('1 + 1').evaluate(data)
-    2
-    >>> Expression('3 - 1').evaluate(data)
-    2
-    >>> Expression('1 * 2').evaluate(data)
-    2
-    >>> Expression('4 / 2').evaluate(data)
-    2
-    >>> Expression('4 // 3').evaluate(data)
-    1
-    >>> Expression('4 % 3').evaluate(data)
-    1
-    >>> Expression('2 ** 3').evaluate(data)
-    8
-    >>> Expression('not True').evaluate(data)
-    False
-    >>> Expression('True and False').evaluate(data)
-    False
-    >>> Expression('True or False').evaluate(data)
-    True
-    >>> Expression('1 == 3').evaluate(data)
-    False
-    >>> Expression('1 != 3 == 3').evaluate(data)
-    True
-    >>> Expression('1 > 0').evaluate(data)
-    True
-    >>> Expression('True and "Foo"').evaluate(data)
-    'Foo'
-    >>> data = dict(items=[1, 2, 3])
-    >>> Expression('2 in items').evaluate(data)
-    True
-    >>> Expression('not 2 in items').evaluate(data)
-    False
-    
+    All of the standard Python operators are available to template expressions.
     Built-in functions such as `len()` are also available in template
     expressions:
     
@@ -325,9 +288,12 @@
         _OP_MAP = {_ast.Add: operator.add, _ast.And: lambda l, r: l and r,
                    _ast.Div: operator.div, _ast.Eq: operator.eq,
                    _ast.FloorDiv: operator.floordiv, _ast.Gt: operator.gt,
+                   _ast.GtE: operator.ge,
                    _ast.In: lambda l, r: operator.contains(r, l),
+                   _ast.Lt: operator.lt, _ast.LtE: operator.le,
                    _ast.Mod: operator.mod, _ast.Mult: operator.mul,
                    _ast.Not: operator.not_, _ast.NotEq: operator.ne,
+                   _ast.NotIn: lambda l, r: not operator.contains(r, l),
                    _ast.Or: lambda l, r: l or r, _ast.Pow: operator.pow,
                    _ast.Sub: operator.sub, _ast.UAdd: operator.pos,
                    _ast.USub: operator.neg}
diff --git a/markup/template.py b/markup/template.py
--- a/markup/template.py
+++ b/markup/template.py
@@ -165,9 +165,8 @@
     Directives can be "anonymous" or "registered". Registered directives can be
     applied by the template author using an XML attribute with the
     corresponding name in the template. Such directives should be subclasses of
-    this base class that can  be instantiated with two parameters: `template`
-    is the `Template` instance, and `value` is the value of the directive
-    attribute.
+    this base class that can  be instantiated with the value of the directive
+    attribute as parameter.
     
     Anonymous directives are simply functions conforming to the protocol
     described above, and can only be applied programmatically (for example by
@@ -335,7 +334,8 @@
 
 
 class ForDirective(Directive):
-    """Implementation of the `py:for` template directive.
+    """Implementation of the `py:for` template directive for repeating an
+    element based on an iterable in the context data.
     
     >>> ctxt = Context(items=[1, 2, 3])
     >>> tmpl = Template('''<ul xmlns:py="http://purl.org/kid/ns#">
@@ -374,7 +374,8 @@
 
 
 class IfDirective(Directive):
-    """Implementation of the `py:if` template directive.
+    """Implementation of the `py:if` template directive for conditionally
+    excluding elements from being output.
     
     >>> ctxt = Context(foo=True, bar='Hello')
     >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#">
@@ -471,6 +472,9 @@
 class ReplaceDirective(Directive):
     """Implementation of the `py:replace` template directive.
     
+    This directive replaces the element with the result of evaluating the
+    value of the `py:replace` attribute:
+    
     >>> ctxt = Context(bar='Bye')
     >>> tmpl = Template('''<div xmlns:py="http://purl.org/kid/ns#">
     ...   <span py:replace="bar">Hello</span>
@@ -647,8 +651,8 @@
                         value = list(self._interpolate(value, *pos))
                         new_attrib.append((name, value))
                 if directives:
-                    directives.sort(lambda a, b: cmp(self._dir_order.index(a.__class__),
-                                                     self._dir_order.index(b.__class__)))
+                    directives.sort(lambda a, b: cmp(self._dir_order.index(b.__class__),
+                                                     self._dir_order.index(a.__class__)))
                     dirmap[(depth, tag)] = (directives, len(stream))
 
                 stream.append((kind, (tag, Attributes(new_attrib)), pos))
@@ -780,7 +784,6 @@
                     # nested events to which those directives should be
                     # applied
                     directives, substream = data
-                    directives.reverse()
                     for directive in directives:
                         substream = directive(iter(substream), ctxt)
                     substream = self._match(self._eval(substream, ctxt), ctxt)
diff --git a/markup/tests/eval.py b/markup/tests/eval.py
--- a/markup/tests/eval.py
+++ b/markup/tests/eval.py
@@ -52,6 +52,99 @@
         self.assertEqual((True,),
                          Expression("(value,)").evaluate({'value': True}))
 
+    def test_unaryop_pos(self):
+        self.assertEqual(1, Expression("+1").evaluate({}))
+        self.assertEqual(1, Expression("+x").evaluate({'x': 1}))
+
+    def test_unaryop_neg(self):
+        self.assertEqual(-1, Expression("-1").evaluate({}))
+        self.assertEqual(-1, Expression("-x").evaluate({'x': 1}))
+
+    def test_unaryop_not(self):
+        self.assertEqual(False, Expression("not True").evaluate({}))
+        self.assertEqual(False, Expression("not x").evaluate({'x': True}))
+
+    def test_binop_add(self):
+        self.assertEqual(3, Expression("2 + 1").evaluate({}))
+        self.assertEqual(3, Expression("x + y").evaluate({'x': 2, 'y': 1}))
+
+    def test_binop_sub(self):
+        self.assertEqual(1, Expression("2 - 1").evaluate({}))
+        self.assertEqual(1, Expression("x - y").evaluate({'x': 1, 'y': 1}))
+
+    def test_binop_sub(self):
+        self.assertEqual(1, Expression("2 - 1").evaluate({}))
+        self.assertEqual(1, Expression("x - y").evaluate({'x': 2, 'y': 1}))
+
+    def test_binop_mul(self):
+        self.assertEqual(4, Expression("2 * 2").evaluate({}))
+        self.assertEqual(4, Expression("x * y").evaluate({'x': 2, 'y': 2}))
+
+    def test_binop_pow(self):
+        self.assertEqual(4, Expression("2 ** 2").evaluate({}))
+        self.assertEqual(4, Expression("x ** y").evaluate({'x': 2, 'y': 2}))
+
+    def test_binop_div(self):
+        self.assertEqual(2, Expression("4 / 2").evaluate({}))
+        self.assertEqual(2, Expression("x / y").evaluate({'x': 4, 'y': 2}))
+
+    def test_binop_floordiv(self):
+        self.assertEqual(1, Expression("3 // 2").evaluate({}))
+        self.assertEqual(1, Expression("x // y").evaluate({'x': 3, 'y': 2}))
+
+    def test_binop_mod(self):
+        self.assertEqual(1, Expression("3 % 2").evaluate({}))
+        self.assertEqual(1, Expression("x % y").evaluate({'x': 3, 'y': 2}))
+
+    def test_binop_contains(self):
+        self.assertEqual(True, Expression("1 in (1, 2, 3)").evaluate({}))
+        self.assertEqual(True, Expression("x in y").evaluate({'x': 1,
+                                                              'y': (1, 2, 3)}))
+
+    def test_binop_not_contains(self):
+        self.assertEqual(True, Expression("4 not in (1, 2, 3)").evaluate({}))
+        self.assertEqual(True, Expression("x not in y").evaluate({'x': 4,
+                                                                  'y': (1, 2, 3)}))
+
+    def test_boolop_and(self):
+        self.assertEqual(False, Expression("True and False").evaluate({}))
+        self.assertEqual(False, Expression("x and y").evaluate({'x': True,
+                                                                'y': False}))
+
+    def test_boolop_or(self):
+        self.assertEqual(True, Expression("True or False").evaluate({}))
+        self.assertEqual(True, Expression("x or y").evaluate({'x': True,
+                                                              'y': False}))
+
+    def test_compare_eq(self):
+        self.assertEqual(True, Expression("1 == 1").evaluate({}))
+        self.assertEqual(True, Expression("x == y").evaluate({'x': 1, 'y': 1}))
+
+    def test_compare_ne(self):
+        self.assertEqual(False, Expression("1 != 1").evaluate({}))
+        self.assertEqual(False, Expression("x != y").evaluate({'x': 1, 'y': 1}))
+
+    def test_compare_lt(self):
+        self.assertEqual(True, Expression("1 < 2").evaluate({}))
+        self.assertEqual(True, Expression("x < y").evaluate({'x': 1, 'y': 2}))
+
+    def test_compare_le(self):
+        self.assertEqual(True, Expression("1 <= 1").evaluate({}))
+        self.assertEqual(True, Expression("x <= y").evaluate({'x': 1, 'y': 1}))
+
+    def test_compare_gt(self):
+        self.assertEqual(True, Expression("2 > 1").evaluate({}))
+        self.assertEqual(True, Expression("x > y").evaluate({'x': 2, 'y': 1}))
+
+    def test_compare_ge(self):
+        self.assertEqual(True, Expression("1 >= 1").evaluate({}))
+        self.assertEqual(True, Expression("x >= y").evaluate({'x': 1, 'y': 1}))
+
+    def test_compare_multi(self):
+        self.assertEqual(True, Expression("1 != 3 == 3").evaluate({}))
+        self.assertEqual(True, Expression("x != y == y").evaluate({'x': 3,
+                                                                   'y': 3}))
+
 
 def suite():
     suite = unittest.TestSuite()