Added Sort, Keep and Drop, with some other minor changes

Author: borntyping

dice/__init__.py

@@ -16,6 +16,8 @@
 def roll(string, single=True, verbose=False):
     """Parses and evaluates a dice expression"""
     ast = dice.grammar.expression.parseString(string, parseAll=True)
+    if verbose:
+        dice.elements.Element.verbose = True
     result = [element.evaluate_cached(verbose=verbose) for element in ast]
     if single:
         return dice.utilities.single(result)

dice/elements.py

@@ -9,7 +9,7 @@
 
 
 class Element(object):
-    verbose = True
+    verbose = False
 
     def evaluate(self):
         """Evaluate the current object - a no-op by default"""
@@ -103,15 +103,14 @@ def evaluate(self):
 class Operator(Element):
     @classmethod
     def parse(cls, string, location, tokens):
-        return cls(operands=tokens)
+        return cls(*tokens)
 
-    def __init__(self, operands):
-        self.operands = operands
+    def __init__(self, *operands):
+        self.operands = self.orginal_operands = operands
 
     def __repr__(self):
         return "{0}({1})".format(
-            classname(self),
-            ', '.join(map(str, self.operands)))
+            classname(self), ', '.join(map(str, self.orginal_operands)))
 
     def evaluate(self):
         self.operands = map(self.evaluate_object, self.operands)
@@ -145,3 +144,23 @@ class Add(IntegerOperator):
 
 class Total(Operator):
     function = sum
+
+
+class Sort(Operator):
+    def function(self, iterable):
+        iterable.sort()
+        return iterable
+
+
+class Drop(Operator):
+    def function(self, iterable, n):
+        for die in sorted(iterable)[:n]:
+            iterable.remove(die)
+        return iterable
+
+
+class Keep(Operator):
+    def function(self, iterable, n):
+        for die in sorted(iterable)[:-n]:
+            iterable.remove(die)
+        return iterable

dice/grammar.py

@@ -12,7 +12,8 @@
     CaselessLiteral, Forward, Literal, OneOrMore, StringStart, StringEnd,
     Suppress, Word, nums, opAssoc)
 
-from dice.elements import Integer, Dice, Total, Mul, Div, Sub, Add
+from dice.elements import (
+    Integer, Dice, Mul, Div, Sub, Add, Total, Sort, Drop, Keep)
 from dice.utilities import patch_pyparsing
 
 patch_pyparsing()
@@ -82,14 +83,18 @@ def parse_operator(expr, arity, association, action=None):
 
 # An expression in dice notation
 expression = StringStart() + operatorPrecedence(integer, [
-    (Literal('d').suppress(), 2, opAssoc.LEFT, Dice.parse_binary),
-    (Literal('d').suppress(), 1, opAssoc.RIGHT, Dice.parse_unary),
+    (CaselessLiteral('d').suppress(), 2, opAssoc.LEFT, Dice.parse_binary),
+    (CaselessLiteral('d').suppress(), 1, opAssoc.RIGHT, Dice.parse_unary),
 
     (Literal('/').suppress(), 2, opAssoc.LEFT, Div.parse),
     (Literal('*').suppress(), 2, opAssoc.LEFT, Mul.parse),
     (Literal('-').suppress(), 2, opAssoc.LEFT, Sub.parse),
     (Literal('+').suppress(), 2, opAssoc.LEFT, Add.parse),
 
     (CaselessLiteral('t').suppress(), 1, opAssoc.LEFT, Total.parse),
+    (CaselessLiteral('s').suppress(), 1, opAssoc.LEFT, Sort.parse),
+
+    (Literal('^').suppress(), 2, opAssoc.LEFT, Keep.parse),
+    (Literal('v').suppress(), 2, opAssoc.LEFT, Drop.parse),
 ]) + StringEnd()
 expression.setName("expression")

dice/tests/__init__.py

@@ -1 +1,5 @@
 """Tests for the dice package"""
+
+import dice.elements
+
+dice.elements.Element.verbose = True

dice/tests/test_elements.py

@@ -1,23 +1,30 @@
 from __future__ import absolute_import
 
-from dice.elements import Integer, Roll, Dice
+from dice.elements import Integer, Roll, Dice, Total
+from dice import roll
 
 
-def test_integer():
-    assert isinstance(Integer(1), int)
+class TestElements(object):
+    def test_integer(self):
+        assert isinstance(Integer(1), int)
 
+    def test_dice_from_iterable(self):
+        d = Dice.from_iterable((2, 6))
+        assert d.amount == 2 and d.sides == 6
 
-def test_dice_from_iterable():
-    d = Dice.from_iterable((2, 6))
-    assert d.amount == 2 and d.sides == 6
+    def test_dice_from_string(self):
+        d = Dice.from_string('2d6')
+        assert d.amount == 2 and d.sides == 6
 
+    def test_roll(self):
+        amount, sides = 6, 6
+        assert len(Roll.roll(amount, sides)) == amount
+        assert (1 * sides) <= sum(Roll.roll(amount, sides)) <= (amount * sides)
 
-def test_dice_from_string():
-    d = Dice.from_string('2d6')
-    assert d.amount == 2 and d.sides == 6
 
-
-def test_roll():
-    amount, sides = 6, 6
-    assert len(Roll.roll(amount, sides)) == amount
-    assert (1 * sides) <= sum(Roll.roll(amount, sides)) <= (amount * sides)
+class TestEvaluate(object):
+    def test_cache(self):
+        """Test that evaluation returns the same result on successive runs"""
+        roll('6d(6d6)t')
+        ast = Total(Dice(6, Dice(6, 6)))
+        assert ast.evaluate_cached() is ast.evaluate_cached()

dice/tests/test_grammar.py

@@ -27,7 +27,7 @@ def test_dice_values(self):
             assert 0 < die <= 6
 
 
-class TestFunctionOperators(object):
+class TestOperators(object):
     def test_add(self):
         assert roll('2 + 2') == 4
 
@@ -44,6 +44,19 @@ def test_div(self):
     def test_total(self):
         assert (6 * 1) <= roll('6d6t') <= (6 * 6)
 
+    def test_sort(self):
+        value = roll('6d6s')
+        assert value == sorted(value)
+        assert isinstance(value, Roll)
+
+    def test_drop(self):
+        value = roll('6d6 v 3')
+        assert len(value) == 3
+
+    def test_keep(self):
+        value = roll('6d6 ^ 3')
+        assert len(value) == 3
+
 
 class TestOperatorPrecedence(object):
     def test_operator_precedence_1(self):

tox.ini

@@ -1,7 +1,7 @@
 [tox]
 minversion=1.5.0
 toxworkdir=.cache
-envlist=py27-pep8,py27-pyflakes,py27-coverage,py26,py27,py32,py33,pypy
+envlist=py27-pyflakes,py27-pep8,py26,py27,py32,py33,pypy
 
 [testenv]
 commands=py.test dice