Added total (t) and rearranged stuff

* Removed parse and evaluate functions
* Moved operators back to dice/elements.py
* Added total operator (needs testing)
* Removed alternative single and parse used in tests
* Raise ImportWarnings for all PyParsing modifications

Author: borntyping

dice/__init__.py

@@ -24,22 +24,19 @@
     'expression',
     help="the expression to parse and roll")
 
-def parse(string, grammar):
-    """Returns an AST parsed from an expression"""
-    return grammar.parseString(string, parseAll=True)
 
-def evaluate(string, grammar, **options):
-    """Parse and then evaluate a string with a grammar"""
-    return [e.evaluate(**options) for e in parse(string, grammar)]
-
-def roll(string, verbose=False):
+def roll(string, single=True, verbose=False):
     """Parses and evaluates an expression"""
-    return evaluate(string, grammar=dice.grammar.expression, verbose=verbose)
+    ast = dice.grammar.expression.parseString(string, parseAll=True)
+    result = [element.evaluate(verbose=verbose) for element in ast]
+    if single:
+        return dice.utilities.single(result)
+    return result
+
 
 def main(argv=None):
     args = parser.parse_args(argv)
     result = roll(args.expression, verbose=args.verbose)
-    result = dice.utilities.single(result)
     if args.verbose:
         print("Result:", end=" ")
     return result

dice/elements.py

@@ -3,10 +3,10 @@
 from __future__ import absolute_import, print_function, unicode_literals
 
 import random
+import operator
 
 from dice.utilities import classname
 
-
 class Element(object):
     def evaluate(self, verbose=False):
         """Evaluate the current object - a no-op by default"""
@@ -100,3 +100,55 @@ def evaluate(self, verbose=False):
 
     def roll(self):
         return self.evaluate(verbose=False)
+
+
+class Operator(Element):
+    @classmethod
+    def parse(cls, string, location, tokens):
+        return cls(operands=tokens)
+
+    def __init__(self, operands):
+        self.operands = operands
+
+    def __repr__(self):
+        return "{0}({1})".format(
+            classname(self),
+            ', '.join(map(repr, self.operands)))
+
+    def evaluate(self):
+        raise NotImplementedError(
+            "Operator subclass has no evaluate()")
+
+    def evaluate_operands(self):
+        self.operands = map(self.evaluate_object, self.operands)
+        return self.operands
+
+
+class FunctionOperator(Operator):
+    @property
+    def function(self):
+        raise NotImplementedError(
+            "FunctionOperator subclass has no function")
+
+    def evaluate(self, verbose=False):
+        return self.function(*self.evaluate_operands())
+
+
+class Div(FunctionOperator):
+    function = operator.floordiv
+
+
+class Mul(FunctionOperator):
+    function = operator.mul
+
+
+class Sub(FunctionOperator):
+    function = operator.sub
+
+
+class Add(FunctionOperator):
+    function = operator.add
+
+
+class Total(FunctionOperator):
+    function = sum

dice/grammar.py

@@ -8,11 +8,10 @@
 
 from __future__ import absolute_import, print_function, unicode_literals
 
-from pyparsing import (Forward, Literal, OneOrMore, StringStart, StringEnd,
-    Suppress, Word, nums, opAssoc)
+from pyparsing import (CaselessLiteral, Forward, Literal, OneOrMore,
+    StringStart, StringEnd, Suppress, Word, nums, opAssoc)
 
-from dice.elements import Integer, Dice
-from dice.operators import Mul, Div, Sub, Add
+from dice.elements import Integer, Dice, Total, Mul, Div, Sub, Add
 from dice.utilities import patch_pyparsing
 
 # Set PyParsing options
@@ -89,5 +88,7 @@ def parse_operator(expr, arity, association, action=None):
     (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),
 ]) + StringEnd()
 expression.setName("expression")

dice/operators.py

@@ -1,12 +1 @@
 """Tests for the dice package"""
-
-from __future__ import absolute_import, print_function
-
-from dice import evaluate
-
-def single(iterable):
-    return iterable[0] if len(iterable) == 1 else list(iterable)
-
-def parse(grammar, string):
-    """Parses a string with a grammar, returning and printing the result"""
-    return single(evaluate(string, grammar))

dice/tests/__init__.py

@@ -1,19 +1,10 @@
 from __future__ import absolute_import
 
-import py.test
-
 from dice.elements import Integer, Roll, Dice
 
-@py.test.fixture
-def dice_constructors():
-    return Dice(2, 6), "2d6", (2, 6)
-
 def test_integer():
     assert isinstance(Integer(1), int)
 
-def test_roll():
-    assert isinstance(Dice(2, 6).roll(), Roll)
-
 def test_dice_from_iterable():
     d = Dice.from_iterable((2, 6))
     assert d.amount == 2 and d.sides == 6
@@ -22,21 +13,7 @@ def test_dice_from_string():
     d = Dice.from_string("2d6")
     assert d.amount == 2 and d.sides == 6
 
-#@py.test.fixture
-#def bag():
-#    return Bag("1d2", "2d4", "4d6", "6d8", "8d10")
-#
-#def test_dice_from_object(dice_constructors):
-#    for obj in dice_constructors:
-#        d = Bag.dice_from_object(obj)
-#        assert d.amount == 2 and d.sides == 6
-#
-#def test_dice_from_object_exception():
-#    with py.test.raises(TypeError):
-#        Bag.dice_from_object(NotImplemented)
-#
-#def test_bag_length(dice_constructors):
-#    assert len(Bag(*dice_constructors)) == len(dice_constructors)
-#
-#def test_bag_str(bag):
-#    assert re.match("[d,\d]*", str(bag))
+def test_roll():
+    amount, sides = 6, 6
+    assert len(Roll.roll(amount, sides)) == amount
+    assert (1 * sides) <= sum(Roll.roll(amount, sides)) <= (amount * sides)

dice/tests/test_elements.py

@@ -1,62 +1,65 @@
 from __future__ import absolute_import, unicode_literals, division
 
 from dice.elements import Integer, Roll
-from dice.grammar import integer, expression
-from dice.tests import parse
+from dice import roll
 
 class TestInteger(object):
-    def test_parse(self):
-        assert parse(integer, "1337") == 1337
-        assert parse(expression, "1337") == 1337
+    def test_value(self):
+        assert roll("1337") == 1337
 
     def test_type(self):
-        assert isinstance(parse(integer, "1"), int)
-        assert isinstance(parse(integer, "1"), Integer)
+        assert isinstance(roll("1"), int)
+        assert isinstance(roll("1"), Integer)
 
 
 class TestDice(object):
-    def test_dice_type(self):
-        for dice in ("d6", "1d6"):
-            assert isinstance(parse(expression, dice), Roll)
-
     def test_dice_value(self):
-        for dice in ("d6", "1d6"):
-            assert 0 < int(parse(expression, dice)) <= 6
-
-    def test_dice_result(self):
-        for result in parse(expression, "6d6"):
-            assert 0 < result <= 6
-
+        assert 0 < int(roll('d6')) <= 6
+        assert 0 < int(roll('1d6')) <= 6
 
-class TestExpression(object):
-    def test_expression(self):
-        assert parse(expression, "2d6")
+    def test_dice_type(self):
+        assert isinstance(roll('d6'), Roll)
+        assert isinstance(roll('1d6'), Roll)
 
-    def test_sub_expression(self):
-        assert parse(expression, "(2d6)d(2d6)")
+    def test_dice_values(self):
+        for die in roll("6d6"):
+            assert 0 < die <= 6
 
 
-class TestExpressionMaths(object):
+class TestFunctionOperators(object):
     def test_add(self):
-        assert parse(expression, "2 + 2") == 4
+        assert roll("2 + 2") == 4
 
     def test_sub(self):
-        assert parse(expression, "2 - 2") == 0
+        assert roll("2 - 2") == 0
 
     def test_mul(self):
-        assert parse(expression, "2 * 2") == 4
+        assert roll("2 * 2") == 4
 
     def test_div(self):
-        assert parse(expression, "2 / 2") == 1
+        assert roll("2 / 2") == 1
 
+    def test_total(self):
+        assert (6 * 1) <= roll("6d6t") <= (6 * 6)
+
+
+def TestOperatorPrecedence(object):
     def test_operator_precedence_1(self):
-        assert parse(expression, "16 / 8 * 4 + 2 - 1") == 9
+        assert roll("16 / 8 * 4 + 2 - 1") == 9
 
     def test_operator_precedence_2(self):
-        assert parse(expression, "16 - 8 + 4 * 2 / 1") == 16
+        assert roll("16 - 8 + 4 * 2 / 1") == 16
 
     def test_operator_precedence_3(self):
-        assert parse(expression, "10 - 3 + 2") == 9
+        assert roll("10 - 3 + 2") == 9
 
     def test_operator_precedence_4(self):
-        assert parse(expression, "1 + 2 * 3") == 7
+        assert roll("1 + 2 * 3") == 7
+
+
+class TestExpression(object):
+    def test_expression(self):
+        assert isinstance(roll("2d6"), Roll)
+
+    def test_sub_expression(self):
+        assert isinstance(roll("(2d6)d(2d6)"), Roll)

dice/tests/test_grammar.py

@@ -1,6 +1,12 @@
 from __future__ import absolute_import
 
-from dice import main
+from dice import roll, main
+from dice.elements import Integer, Roll
+
+
+def test_roll():
+    assert isinstance(roll('2d6'), (Integer, Roll, list))
+
 
 def test_main():
-    assert main(["2d6"]) is not None
+    assert isinstance(main(['2d6']), (Integer, Roll, list))

dice/tests/test_main.py

@@ -8,9 +8,11 @@ def classname(obj):
     """Returns the name of an objects class"""
     return obj.__class__.__name__
 
+
 def single(iterable):
     """Returns a single item if the iterable has only one item"""
-    return iterable[0] if len(iterable) == 1 else list(iterable)
+    return iterable[0] if len(iterable) == 1 else iterable
+
 
 def patch_pyparsing(packrat=True, arity=True, verbose=True):
     """Applies monkey-patches to pyparsing"""
@@ -23,20 +25,26 @@ def patch_pyparsing(packrat=True, arity=True, verbose=True):
     if verbose:
         enable_pyparsing_verbose_stacktrace()
 
+
 def enable_pyparsing_packrat():
     """Enables pyparsing's packrat parsing, which is much faster for the type
     of parsing being done in this library"""
+    warnings.warn("Enabled pyparsing packrat parsing", ImportWarning)
     pyparsing.ParserElement.enablePackrat()
 
+
 def enable_pyparsing_verbose_stacktrace():
     """Enables verbose stacktraces in pyparsing"""
+    warnings.warn("Enabled pyparsing verbose stacktrace", ImportWarning)
     pyparsing.ParserElement.verbose_stacktrace = True
 
+
 def _trim_arity(func, maxargs=None):
     def wrapper(string, location, tokens):
         return func(string, location, tokens)
     return wrapper
 
+
 def disable_pyparsing_arity_trimming():
     """When pyparsing encounters a TypeError when calling a parse action, it
     will keep trying the call the function with one less argument each time