Renamed nodes to expressions

Author: Bernardo-MG

dice_notation/parser/dice.py

@@ -4,8 +4,8 @@
 from operator import add, sub
 
 from dice_notation.parser.common import PlyParser
-from dice_notation.parser.node import BinaryOperationNode, ConstantNode, \
-    DiceNode
+from dice_notation.parser.notation import BinaryOperationExpression, ConstantExpression, \
+    DiceExpression
 
 """
 Dice notation parsers.
@@ -60,7 +60,7 @@ def p_statement_expr(self, p):
 
     def p_expression_dice(self, p):
         'expression : DIGIT DSEPARATOR DIGIT'
-        p[0] = DiceNode(p[1], p[3])
+        p[0] = DiceExpression(p[1], p[3])
         self._logger.debug("Dice %s", p[0])
 
     def p_expression_binop(self, p):
@@ -70,17 +70,17 @@ def p_expression_binop(self, p):
         """
         # print [repr(p[i]) for i in range(0,4)]
         if p[2] == '+':
-            p[0] = BinaryOperationNode(add, p[1], p[3])
+            p[0] = BinaryOperationExpression(add, p[1], p[3])
         elif p[2] == '-':
-            p[0] = BinaryOperationNode(sub, p[1], p[3])
+            p[0] = BinaryOperationExpression(sub, p[1], p[3])
         self._logger.debug("Binary operation %s", p[0])
 
     def p_expression_digit(self, p):
         'expression : DIGIT'
-        if isinstance(p[1], ConstantNode):
+        if isinstance(p[1], ConstantExpression):
             p[0] = p[1]
         else:
-            p[0] = ConstantNode(p[1])
+            p[0] = ConstantExpression(p[1])
         self._logger.debug("Constant %s", p[0])
 
     def p_error(self, p):

dice_notation/parser/node.py dice_notation/parser/notation.pydice_notation/parser/node.py renamed to dice_notation/parser/notation.py

@@ -5,18 +5,19 @@
 from dice_notation.dice import RollableDice, Rollable
 
 """
-Dice notation nodes.
+Dice notation classes.
 
-Used to generate the parsed tree from a dice notation expression.
+Used to generate the parsed tree from a dice notation expression. These
+expressions will be nodes in that tree.
 
-All the nodes are rollable, to allow generating a roll from any point of the
+All the classes are rollable, to allow generating a roll from any point of the
 expression.
 """
 
 
-class ConstantNode(Rollable):
+class ConstantExpression(Rollable):
     """
-    Node containing a constant value.
+    Expression for a constant value.
 
     It just wraps any value, allowing it to interface with the other nodes.
 
@@ -25,30 +26,30 @@ class ConstantNode(Rollable):
     """
 
     def __init__(self, constant):
-        super(ConstantNode, self).__init__()
+        super(ConstantExpression, self).__init__()
         self._constant = constant
         # If it received a constant node this is unwrapped
-        # TODO: Maybe the problem should be fixed somewhere else
-        while isinstance(self._constant, ConstantNode):
+        # TODO: Maybe this problem should be fixed somewhere else
+        while isinstance(self._constant, ConstantExpression):
             self._constant = constant.constant
 
     def __add__(self, other):
-        return ConstantNode(other + self.constant)
+        return ConstantExpression(other + self.constant)
 
     def __sub__(self, other):
-        return ConstantNode(self.constant - other)
+        return ConstantExpression(self.constant - other)
 
     def __radd__(self, other):
-        return ConstantNode(self.constant + other)
+        return ConstantExpression(self.constant + other)
 
     def __rsub__(self, other):
-        return ConstantNode(other - self.constant)
+        return ConstantExpression(other - self.constant)
 
     def __lt__(self, other):
         return self.constant < other
 
     def __le__(self, other):
-        if isinstance(other, ConstantNode):
+        if isinstance(other, ConstantExpression):
             return self.constant <= other.constant
         elif isinstance(other, (int, float)):
             return self.constant <= other
@@ -65,7 +66,7 @@ def __gt__(self, other):
         return self.constant > other
 
     def __ge__(self, other):
-        if isinstance(other, ConstantNode):
+        if isinstance(other, ConstantExpression):
             return self.constant >= other.constant
         elif isinstance(other, (int, float)):
             return self.constant >= other
@@ -101,25 +102,27 @@ def roll(self):
         return self.constant
 
 
-class DiceNode(RollableDice):
+class DiceExpression(RollableDice):
     """
-    Node containing a dice.
+    Expression for a dice.
+
+    It is mostly just its parent class, only adding comparison methods.
     """
 
     def __init__(self, quantity, sides):
-        super(DiceNode, self).__init__(quantity=quantity, sides=sides)
+        super(DiceExpression, self).__init__(quantity=quantity, sides=sides)
 
     def __add__(self, other):
-        return ConstantNode(other + self.roll())
+        return ConstantExpression(other + self.roll())
 
     def __sub__(self, other):
-        return ConstantNode(self.roll() - other)
+        return ConstantExpression(self.roll() - other)
 
     def __radd__(self, other):
-        return ConstantNode(self.roll() + other)
+        return ConstantExpression(self.roll() + other)
 
     def __rsub__(self, other):
-        return ConstantNode(other - self.roll())
+        return ConstantExpression(other - self.roll())
 
     def __str__(self):
         return '%sd%s' % (self.quantity, self.sides)
@@ -129,15 +132,15 @@ def __repr__(self):
                (self.__class__.__name__, self.quantity, self.sides)
 
 
-class BinaryOperationNode(Rollable):
+class BinaryOperationExpression(Rollable):
     """
-    Node for a binary operation.
+    Exprssion for a binary operation.
 
     Acquiring its value will execute a function with two parameters.
     """
 
     def __init__(self, function, left, right):
-        super(BinaryOperationNode, self).__init__()
+        super(BinaryOperationExpression, self).__init__()
         self._logger = logging.getLogger(self.__class__.__name__)
         self._function = function
         self._left = left
@@ -146,28 +149,28 @@ def __init__(self, function, left, right):
     def __add__(self, other):
         value = self.operate()
         self._logger.debug("%s + %s", value, other)
-        return ConstantNode(other + value)
+        return ConstantExpression(other + value)
 
     def __sub__(self, other):
         value = self.operate()
         self._logger.debug("%s - %s", other, value)
-        return ConstantNode(value - other)
+        return ConstantExpression(value - other)
 
     def __radd__(self, other):
         value = self.operate()
         self._logger.debug("(rear) %s + %s", value, other)
-        return ConstantNode(value + other)
+        return ConstantExpression(value + other)
 
     def __rsub__(self, other):
         value = self.operate()
         self._logger.debug("(rear) %s - %s", other, value)
-        return ConstantNode(other - value)
+        return ConstantExpression(other - value)
 
     def __lt__(self, other):
         return self.operate() < other
 
     def __le__(self, other):
-        if isinstance(other, ConstantNode):
+        if isinstance(other, ConstantExpression):
             return self.operate() <= other.constant
         elif isinstance(other, (int, float)):
             return self.operate() <= other
@@ -184,7 +187,7 @@ def __gt__(self, other):
         return self.operate() > other
 
     def __ge__(self, other):
-        if isinstance(other, ConstantNode):
+        if isinstance(other, ConstantExpression):
             return self.operate() >= other.constant
         elif isinstance(other, (int, float)):
             return self.operate() >= other

tests/parser/test_dice_parser_node.py tests/parser/test_dice_parser_notation.pytests/parser/test_dice_parser_node.py renamed to tests/parser/test_dice_parser_notation.py

@@ -3,7 +3,7 @@
 import unittest
 
 from dice_notation.parser.dice import DiceParser
-from dice_notation.parser.node import ConstantNode
+from dice_notation.parser.notation import ConstantExpression
 
 """
 Dice parser tests for purely numeric expressions.
@@ -30,4 +30,4 @@ def test_longSub_singleWrap(self):
         """
         result = self.parser.parse("1-2-3-4-5").operate()
 
-        self.assertFalse(isinstance(result.constant, ConstantNode))
+        self.assertFalse(isinstance(result.constant, ConstantExpression))