Corrected parsing

Author: Bernardo-MG

README.rst

@@ -100,11 +100,11 @@ And then use it to parse a dice notation expression::
     parser = DiceParser()
     dice = parser.parse('1d6+2')
 
-The result can be accessed just by calling the 'roll' method as many times as
+The result can be accessed just by calling the 'value' method as many times as
 needed, which will generate a new random value each time it is called::
 
-    print(dice.roll())
-    print(dice.roll())
+    print(dice.value())
+    print(dice.value())
 
 Testing
 -------

dice_notation/algebra.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from abc import ABCMeta, abstractmethod
-from random import randint
+from dice_notation.dice import Rollable
 
 """
 Algebraic classes.
@@ -13,7 +12,7 @@
 __license__ = 'MIT'
 
 
-class BinaryOperation(object):
+class BinaryOperation(Rollable):
     """
     A binary operation. Matching an operator with two operands.
     """
@@ -32,8 +31,8 @@ def __repr__(self):
         return '<class %s>(left=%r, right=%r, operator=%r)' % \
                (self.__class__.__name__, self._left, self._right, self._operator)
 
-    def value(self):
-        return self._operation(self._left.value(), self._right.value())
+    def roll(self):
+        return self._operation(self._left.roll(), self._right.roll())
 
     @property
     def left(self):
@@ -75,7 +74,7 @@ def operator(self, operator):
         self._operator = operator
 
 
-class Number(object):
+class Number(Rollable):
     """
     A numeric constant
     """
@@ -91,5 +90,5 @@ def __repr__(self):
         return '<class %s>(value=%r)' % \
                (self.__class__.__name__, self._value)
 
-    def value(self):
+    def roll(self):
         return self._value

dice_notation/parser/dice.py

@@ -27,4 +27,4 @@ def parse(self, input):
 
         expression = listener.expression()
         self._logger.debug("Parsed expression %s", expression)
-        return expression.value()
+        return expression

tests/parser/dice/test_dice_parser_dice_rollable.py

@@ -27,23 +27,22 @@ def test_positive(self):
         """
         Tests that positive numbers can be parsed.
         """
-        result = self.parser.parse("5")
+        result = self.parser.parse("5").roll()
 
         self.assertEqual(5, result)
 
     def test_zero(self):
         """
         Tests that the zero value can be parsed.
         """
-        result = self.parser.parse("0")
+        result = self.parser.parse("0").roll()
 
         self.assertEqual(0, result)
 
     def test_negative(self):
         """
         Tests that negative numbers can be parsed.
         """
-        result = self.parser.parse("-5")
+        result = self.parser.parse("-5").roll()
 
-        # TODO: currently not supported
-        # self.assertEqual(-5, result)
+        self.assertEqual(-5, result)

tests/parser/number/test_dice_parser_number.py

@@ -27,15 +27,15 @@ def test_add(self):
         """
         Tests that additions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1+2")
+        result = self.parser.parse("1+2").roll()
 
         self.assertEqual(3, result)
 
     def test_add_toNegative(self):
         """
         Tests that additions to a negative value can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("-1+2")
+        result = self.parser.parse("-1+2").roll()
 
         self.assertEqual(1, result)
 
@@ -55,14 +55,14 @@ def test_longAdd(self):
         """
         Tests that long additions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1+2+3")
+        result = self.parser.parse("1+2+3").roll()
 
         self.assertEqual(6, result)
 
     def test_longerAdd(self):
         """
         Tests that longer additions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1+2+3+4+5")
+        result = self.parser.parse("1+2+3+4+5").roll()
 
         self.assertEqual(15, result)

tests/parser/number/test_dice_parser_number_add.py

@@ -29,14 +29,14 @@ def test_addAndSub(self):
         """
         Tests that additions followed by subtractions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1+2-3")
+        result = self.parser.parse("1+2-3").roll()
 
         self.assertEqual(0, result)
 
     def test_subAndAdd(self):
         """
         Tests that subtractions followed by additions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("3-1+2")
+        result = self.parser.parse("3-1+2").roll()
 
         self.assertEqual(4, result)

tests/parser/number/test_dice_parser_number_binary_op_mixed.py

@@ -13,42 +13,6 @@
 __license__ = 'MIT'
 
 
-class TestRollable(unittest.TestCase):
-    """
-    Tests that numeric expressions return instances of Rollable.
-    """
-
-    def setUp(self):
-        """
-        Initializes parser.
-        """
-        self.parser = DiceParser()
-
-    def test_number_rollable(self):
-        """
-        Tests that parsing numbers returns a Rollable.
-        """
-        result = self.parser.parse("1")
-
-        self.assertTrue(isinstance(result, Rollable))
-
-    def test_add_rollable(self):
-        """
-        Tests that parsing numeric additions returns a Rollable.
-        """
-        result = self.parser.parse("1+2")
-
-        self.assertTrue(isinstance(result, Rollable))
-
-    def test_sub_rollable(self):
-        """
-        Tests that parsing numeric subtractions returns a Rollable.
-        """
-        result = self.parser.parse("1-2")
-
-        self.assertTrue(isinstance(result, Rollable))
-
-
 class TestRoll(unittest.TestCase):
     """
     Tests that rolling the result from parsing numeric expressions returns the expected value.
@@ -64,22 +28,22 @@ def test_number_roll(self):
         """
         Tests that rolling a parsed number returns the expected value.
         """
-        result = self.parser.parse("1")
+        result = self.parser.parse("1").roll()
 
-        self.assertEqual(1, result.roll())
+        self.assertEqual(1, result)
 
     def test_add_roll(self):
         """
         Tests that rolling a parsed numeric addition returns the expected value.
         """
-        result = self.parser.parse("1+2")
+        result = self.parser.parse("1+2").roll()
 
-        self.assertEqual(3, result.roll())
+        self.assertEqual(3, result)
 
     def test_sub_roll(self):
         """
         Tests that rolling a parsed numeric subtraction returns the expected value.
         """
-        result = self.parser.parse("1-2")
+        result = self.parser.parse("1-2").roll()
 
-        self.assertEqual(-1, result.roll())
+        self.assertEqual(-1, result)

tests/parser/number/test_dice_parser_number_rollable.py

@@ -13,34 +13,6 @@
 __license__ = 'MIT'
 
 
-class TestRollableMixedBinaryOp(unittest.TestCase):
-    """
-    Tests that mixed numeric binary operation expressions return instances of Rollable.
-    """
-
-    def setUp(self):
-        """
-        Initializes parser.
-        """
-        self.parser = DiceParser()
-
-    def test_addAndSub_rollable(self):
-        """
-        Tests that parsing numeric additions followed by subtractions returns a Rollable.
-        """
-        result = self.parser.parse("1+2-3")
-
-        self.assertTrue(isinstance(result, Rollable))
-
-    def test_subAndAdd_rollable(self):
-        """
-        Tests that parsing numeric subtractions followed by additions returns a Rollable.
-        """
-        result = self.parser.parse("3-1+2")
-
-        self.assertTrue(isinstance(result, Rollable))
-
-
 class TestRollMixedBinaryOp(unittest.TestCase):
     """
     Tests that rolling the result from parsing mixed numeric binary operation expressions returns the expected value.
@@ -56,14 +28,14 @@ def test_addAndSub_roll(self):
         """
         Tests that rolling a parsed numeric additions followed by subtractions returns the expected value.
         """
-        result = self.parser.parse("1+2-3")
+        result = self.parser.parse("1+2-3").roll()
 
-        self.assertEqual(0, result.roll())
+        self.assertEqual(0, result)
 
     def test_subAndAdd_roll(self):
         """
         Tests that rolling a parsed numeric subtractions followed by additions returns the expected value.
         """
-        result = self.parser.parse("3-1+2")
+        result = self.parser.parse("3-1+2").roll()
 
-        self.assertEqual(4, result.roll())
+        self.assertEqual(4, result)

tests/parser/number/test_dice_parser_number_rollable_mixed.py

@@ -27,34 +27,33 @@ def test_sub_positive(self):
         """
         Tests that subtractions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("2-1")
+        result = self.parser.parse("2-1").roll()
 
         self.assertEqual(1, result)
 
     def test_sub_negative(self):
         """
         Tests that subtractions ending in a negative value can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1-2")
+        result = self.parser.parse("1-2").roll()
 
         self.assertEqual(-1, result)
 
     def test_sub_zero(self):
         """
         Tests that subtractions ending in zero can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1-1")
+        result = self.parser.parse("1-1").roll()
 
         self.assertEqual(0, result)
 
     def test_sub_negatives(self):
         """
         Tests that subtractions of negative values can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("-1-1")
+        result = self.parser.parse("-1-1").roll()
 
-        # TODO: Currently not supported
-        # self.assertEqual(-2, result)
+        self.assertEqual(-2, result)
 
 
 class TestSubLong(unittest.TestCase):
@@ -72,7 +71,7 @@ def test_longSub(self):
         """
         Tests that long subtractions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1-2-3")
+        result = self.parser.parse("1-2-3").roll()
 
         # TODO: Maybe it should be "-1-2-3"
 
@@ -82,7 +81,7 @@ def test_longerSub(self):
         """
         Tests that longer subtractions can be parsed, and the result is the expected one.
         """
-        result = self.parser.parse("1-2-3-4-5")
+        result = self.parser.parse("1-2-3-4-5").roll()
 
         # TODO: Maybe it should be "-1-2-3-4-5"