Improved evaluation

Author: borntyping

dice/__init__.py

@@ -10,13 +10,13 @@
 
 __all__ = ['roll', 'ParseException']
 __author__ = "Sam Clements <[email protected]>"
-__version__ = '0.3.2'
+__version__ = '0.4.2'
 
 
 def roll(string, single=True, verbose=False):
     """Parses and evaluates a dice expression"""
     ast = dice.grammar.expression.parseString(string, parseAll=True)
-    result = [element.evaluate(verbose=verbose) for element in ast]
+    result = [element.evaluate_cached(verbose=verbose) for element in ast]
     if single:
         return dice.utilities.single(result)
     return result

dice/command.py

@@ -23,4 +23,4 @@ def main(argv=None):
     result = dice.roll(args['<expression>'], verbose=args['--verbose'])
     if args['--verbose']:
         print("Result:", end=" ")
-    return result
+    return str(result)

dice/elements.py

@@ -9,26 +9,34 @@
 
 
 class Element(object):
-    def evaluate(self, verbose=False):
+    verbose = True
+
+    def evaluate(self):
         """Evaluate the current object - a no-op by default"""
         return self
 
     def evaluate_object(self, obj, cls=None):
-        """Evaluates Elements, and optionally coerces objects to a class"""
+        """Evaluates elements, and coerces objects to a class if needed"""
         if isinstance(obj, Element):
-            obj = obj.evaluate()
+            obj = obj.evaluate_cached()
         if cls is not None:
             obj = cls(obj)
         return obj
 
-    def print_evaluation(self, result):
-        """Prints an explanation of an evaluation"""
-        print("Evaluating:", str(self), "->", str(result))
+    def evaluate_cached(self, verbose=None):
+        """Wraps evaluate(), caching results"""
+        if not hasattr(self, 'result'):
+            self.result = self.evaluate()
+            if self.verbose:
+                print("Evaluating:", str(self), "->", str(self.result))
+        return self.result
 
 
 class Integer(int, Element):
     """A wrapper around the int class"""
 
+    verbose = False
+
     @classmethod
     def parse(cls, string, location, tokens):
         return cls(tokens[0])
@@ -50,7 +58,7 @@ def __repr__(self):
             classname(self), str(self), self.sides)
 
     def __str__(self):
-        return ', '.join(map(str, self))
+        return '[' + ', '.join(map(str, self)) + ']'
 
     def __int__(self):
         return sum(self)
@@ -79,28 +87,17 @@ def from_string(cls, string):
     def __init__(self, amount, sides):
         self.amount = amount
         self.sides = sides
-        self.result = None
 
     def __repr__(self):
         return "Dice({0!r}, {1!r})".format(self.amount, self.sides)
 
     def __str__(self):
         return "{0!s}d{1!s}".format(self.amount, self.sides)
 
-    def evaluate(self, verbose=False):
+    def evaluate(self):
         self.amount = self.evaluate_object(self.amount, Integer)
         self.sides = self.evaluate_object(self.sides, Integer)
-
-        if self.result is None:
-            self.result = Roll(self.amount, self.sides)
-
-        if verbose:
-            self.print_evaluation(self.result)
-
-        return self.result
-
-    def roll(self):
-        return self.evaluate(verbose=False)
+        return Roll(self.amount, self.sides)
 
 
 class Operator(Element):
@@ -114,42 +111,37 @@ def __init__(self, operands):
     def __repr__(self):
         return "{0}({1})".format(
             classname(self),
-            ', '.join(map(repr, self.operands)))
+            ', '.join(map(str, 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
-
+        return self.function(*self.operands)
 
-class FunctionOperator(Operator):
     @property
     def function(self):
-        raise NotImplementedError(
-            "FunctionOperator subclass has no function")
+        raise NotImplementedError("Operator subclass has no function")
+
 
-    def evaluate(self, verbose=False):
-        return self.function(*self.evaluate_operands())
+class IntegerOperator(Operator):
+    def evaluate_object(self, obj):
+        return super(IntegerOperator, self).evaluate_object(obj, Integer)
 
 
-class Div(FunctionOperator):
+class Div(IntegerOperator):
     function = operator.floordiv
 
 
-class Mul(FunctionOperator):
+class Mul(IntegerOperator):
     function = operator.mul
 
 
-class Sub(FunctionOperator):
+class Sub(IntegerOperator):
     function = operator.sub
 
 
-class Add(FunctionOperator):
+class Add(IntegerOperator):
     function = operator.add
 
 
-class Total(FunctionOperator):
+class Total(Operator):
     function = sum

dice/tests/test_command.py

@@ -4,7 +4,6 @@
 
 from dice import roll
 from dice.command import main
-from dice.elements import Integer, Roll
 
 
 def test_roll():
@@ -13,7 +12,7 @@ def test_roll():
 
 
 def test_main():
-    assert isinstance(main(['2d6']), (Integer, Roll, list))
+    assert isinstance(main(['2d6']), str)
 
 
 def test_main_verbose():

dice/tests/test_elements.py

@@ -17,10 +17,6 @@ def test_dice_from_string():
     assert d.amount == 2 and d.sides == 6
 
 
-def test_dice_roll():
-    assert isinstance(Dice(2, 6).roll(), Roll)
-
-
 def test_roll():
     amount, sides = 6, 6
     assert len(Roll.roll(amount, sides)) == amount

dice/tests/test_grammar.py

@@ -36,6 +36,7 @@ def test_sub(self):
 
     def test_mul(self):
         assert roll('2 * 2') == 4
+        assert roll('1d6 * 2') % 2 == 0
 
     def test_div(self):
         assert roll('2 / 2') == 1

setup.py

@@ -5,7 +5,7 @@
 
 setup(
     name             = 'dice',
-    version          = '0.3.2',
+    version          = '0.4.0',
 
     author           = "Sam Clements",
     author_email     = "[email protected]",