Seperated AST creation and evaluation

To many breaking or major changes for a full changelog!

Plenty of cleanup is still needed.

Author: borntyping

dice/__init__.py

@@ -2,35 +2,43 @@
 
 from __future__ import absolute_import, print_function, unicode_literals
 
-import sys
 import argparse
 
 import dice.grammar
 import dice.utilities
 
-__all__ = ['roll', 'main', 'Dice', 'Roll', 'Bag', 'ParseException']
+__all__ = ['parse', 'roll', 'main', 'ParseException']
 __author__ = "Sam Clements <[email protected]>"
 __version__ = "0.2.0"
 
 from pyparsing import ParseException
-from dice.elements import Dice, Roll, Bag
 
 parser = argparse.ArgumentParser()
 parser.add_argument(
     '-v', '--version', action='version',
     version='dice v{0} by {1}'.format(__version__, __author__))
-parser.add_argument(
-    '-s', '--single', action='store_true', dest='single',
-    help="if a single element is returned, extract it from the list")
 parser.add_argument(
     'expression',
     help="the expression to parse and roll")
 
-def roll(string, single=False):
-    result = dice.grammar.notation.parseString(string, parseAll=True)
-    return dice.utilities.single(result) if single else result
+def _(obj):
+    print(obj)
+    return obj
+
+def parse(string, grammar):
+    """Returns an AST parsed from an expression"""
+    return _(grammar.parseString(string, parseAll=True))
+
+def evaluate(string, grammar):
+    """Parse and then evaluate a string with a grammar"""
+    return _([element.evaluate() for element in parse(string, grammar)])
 
-def main(*argv):
-    args = parser.parse_args(sys.argv if len(argv) == 0 else argv)
+def roll(string):
+    """Parses and evaluates an expression"""
+    return evaluate(string, dice.grammar.expression)
 
-    return roll(args.expression, single=args.single)
+def main(argv=None):
+    args = parser.parse_args(argv)
+    result = roll(args.expression)
+    print("Result:", dice.utilities.single(result))
+    return result

dice/elements.py

@@ -1,43 +1,61 @@
 """Objects used in the evaluation of the parse tree"""
 
-from __future__ import absolute_import, unicode_literals, division
+from __future__ import absolute_import, print_function, unicode_literals
 
 import random
-import copy
-
-import six
 
 from dice.utilities import classname
 
-class Integer(int):
+
+class Element(object):
+    def evaluate(self, verbose=False):
+        """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"""
+        if isinstance(obj, Element):
+            obj = obj.evaluate()
+        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))
+
+
+class Integer(int, Element):
     """A wrapper around the int class"""
 
     @classmethod
     def parse(cls, string, location, tokens):
         return cls(tokens[0])
 
-class Roll(list):
+
+class Roll(list, Element):
     """A result from rolling a group of dice"""
 
     @staticmethod
     def roll(amount, sides):
         return [random.randint(1, sides) for i in range(amount)]
 
-    def __init__(self, dice):
-        super(Roll, self).__init__(self.roll(dice.amount, dice.sides))
-        self.sides = dice.sides
+    def __init__(self, amount, sides):
+        super(Roll, self).__init__(self.roll(amount, sides))
+        self.sides = sides
 
     def __repr__(self):
-        return "{0}({1}, sides={0})".format(
+        return "{0}({1}, sides={2})".format(
             classname(self), str(self), self.sides)
 
     def __str__(self):
-        return ', '.join(self)
+        return ', '.join(map(str, self))
 
     def __int__(self):
         return sum(self)
 
-class Dice(object):
+
+class Dice(Element):
     """A group of dice, all with the same number of sides"""
 
     @classmethod
@@ -58,43 +76,27 @@ def from_string(cls, string):
         return cls(int(amount), int(sides))
 
     def __init__(self, amount, sides):
-        self.amount, self.sides = int(amount), int(sides)
+        self.amount = amount
+        self.sides = sides
+        self.result = None
 
     def __repr__(self):
-        return "Dice('{0}d{1}')".format(self.amount, self.sides)
+        return "Dice({0!r}, {1!r})".format(self.amount, self.sides)
 
     def __str__(self):
-        return "{0}d{1}".format(self.amount, self.sides)
-
-    def __int__(self):
-        # TODO: Remove this when dice are evaluated
-        return int(self.roll())
-
-    def roll(self, cls=Roll):
-        return cls(self)
+        return "{0!s}d{1!s}".format(self.amount, self.sides)
 
-class Bag(list):
-    """A collection of dice objects"""
+    def evaluate(self, verbose=False):
+        self.amount = self.evaluate_object(self.amount, Integer)
+        self.sides = self.evaluate_object(self.sides, Integer)
 
-    @staticmethod
-    def dice_from_object(obj, cls=Dice):
-        if isinstance(obj, cls):
-            return copy.copy(obj)
-        elif isinstance(obj, six.string_types):
-            return cls.from_string(obj)
-        elif isinstance(obj, (tuple, list)):
-            return cls.from_iterable(obj)
-        raise TypeError("Dice object cannot be created from " + repr(obj))
-
-    def __init__(self, *dice_list):
-        for d in dice_list:
-            self.append(self.dice_from_object(d))
+        if self.result is None:
+            self.result = Roll(self.amount, self.sides)
 
-    def __repr__(self):
-        return "Bag({0})".format(','.join(map(repr, self)))
+        if verbose:
+            self.print_evaluation(self.result)
 
-    def __str__(self):
-        return ', '.join(map(str, self))
+        return self.result
 
     def roll(self):
-        return [d.roll() for d in self]
+        return self.evaluate(verbose=False)

dice/grammar.py

@@ -6,16 +6,13 @@
 module for more information.
 """
 
-from __future__ import absolute_import, unicode_literals, division
-from __future__ import print_function
-
-from functools import wraps
-from operator import add, sub, mul, floordiv as div
+from __future__ import absolute_import, print_function, unicode_literals
 
 from pyparsing import (Forward, Literal, OneOrMore, StringStart, StringEnd,
-    Suppress, Word, delimitedList, nums, opAssoc)
+    Suppress, Word, nums, opAssoc)
 
 from dice.elements import Integer, Dice
+from dice.operators import Mul, Div, Sub, Add
 from dice.utilities import patch_pyparsing
 
 # Set PyParsing options
@@ -78,27 +75,19 @@ def parse_operator(expr, arity, association, action=None):
     expression <<= last
     return expression
 
-
 # An integer value
-integer = Word(nums).setParseAction(Integer.parse).setName("integer")
-
-def integer_operation(func):
-    @wraps(func)
-    def operate(string, location, tokens):
-        return func(*map(int, tokens))
-    return operate
+integer = Word(nums)
+integer.setParseAction(Integer.parse)
+integer.setName("integer")
 
 # An expression in dice notation
-expression = operatorPrecedence(integer, [
+expression = StringStart() + operatorPrecedence(integer, [
     (Literal('d').suppress(), 2, opAssoc.LEFT, Dice.parse_binary),
     (Literal('d').suppress(), 1, opAssoc.RIGHT, Dice.parse_unary),
 
-    (Literal('/').suppress(), 2, opAssoc.LEFT, integer_operation(div)),
-    (Literal('*').suppress(), 2, opAssoc.LEFT, integer_operation(mul)),
-    (Literal('-').suppress(), 2, opAssoc.LEFT, integer_operation(sub)),
-    (Literal('+').suppress(), 2, opAssoc.LEFT, integer_operation(add)),
-]).setName("expression")
-
-# Multiple expressions can be separated with delimiters
-notation = StringStart() + delimitedList(expression, ';') + StringEnd()
-notation.setName("notation")
+    (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),
+]) + StringEnd()
+expression.setName("expression")

dice/operators.py

@@ -0,0 +1,55 @@
+"""Operator elements"""
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+import operator
+
+from dice.elements import Element
+from dice.utilities import classname
+
+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):
+        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

dice/tests/__init__.py

@@ -2,9 +2,11 @@
 
 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(grammar.parseString(string, parseAll=True))
+    return single(evaluate(string, grammar))

dice/tests/test_elements.py

@@ -1,19 +1,13 @@
 from __future__ import absolute_import
 
-import re
-
 import py.test
 
-from dice.elements import Integer, Roll, Dice, Bag
+from dice.elements import Integer, Roll, Dice
 
 @py.test.fixture
 def dice_constructors():
     return Dice(2, 6), "2d6", (2, 6)
 
-@py.test.fixture
-def bag():
-    return Bag("1d2", "2d4", "4d6", "6d8", "8d10")
-
 def test_integer():
     assert isinstance(Integer(1), int)
 
@@ -28,17 +22,21 @@ def test_dice_from_string():
     d = Dice.from_string("2d6")
     assert d.amount == 2 and d.sides == 6
 
-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))
+#@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))