Added binary operation parsing method

Author: Bernardo-MG

dice_notation/algebra.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+from abc import ABCMeta, abstractmethod
+from random import randint
+
+"""
+Algebraic classes.
+
+These allow working with algebraic operations for dice notation.
+"""
+
+__author__ = 'Benardo Martínez Garrido'
+__license__ = 'MIT'
+
+
+class BinaryOperation(object):
+    """
+    A binary operation. Matching an operator with two operands.
+    """
+
+    def __init__(self, left, right, operator, operation):
+        super(BinaryOperation, self).__init__()
+        self._left = left
+        self._right = right
+        self._operator = operator
+        self._operation = operation
+
+    def __str__(self):
+        return '%s%s%s' % (self._left, self._operator, self._right)
+
+    def __repr__(self):
+        return '<class %s>(left=%r, right=%r, operator=%r)' % \
+               (self.__class__.__name__, self._left, self._right, self._operator)
+
+    @property
+    def left(self):
+        """
+        The left operand.
+
+        :return: the left operand
+        """
+        return self._left
+
+    @left.setter
+    def left(self, left):
+        self._left = left
+
+    @property
+    def right(self):
+        """
+        The right operand.
+
+        :return: the right operand
+        """
+        return self._right
+
+    @right.setter
+    def right(self, right):
+        self._right = right
+
+    @property
+    def operator(self):
+        """
+        The operator.
+
+        :return: the operator
+        """
+        return self._operator
+
+    @operator.setter
+    def operator(self, operator):
+        self._operator = operator

dice_notation/dice.py

@@ -67,11 +67,11 @@ def __init__(self, quantity, sides):
         self._sides = sides
 
     def __str__(self):
-        return '%sd%s' % (self.quantity, self.sides)
+        return '%sd%s' % (self._quantity, self._sides)
 
     def __repr__(self):
         return '<class %s>(quantity=%r, sides=%r)' % \
-               (self.__class__.__name__, self.quantity, self.sides)
+               (self.__class__.__name__, self._quantity, self._sides)
 
     @property
     def quantity(self):

dice_notation/parser/DiceNotationListener.py

@@ -3,6 +3,7 @@
 
 import logging
 from dice_notation.dice import Dice
+from dice_notation.algebra import BinaryOperation
 
 # This class defines a complete listener for a parse tree produced by DiceNotationParser.
 class DiceNotationListener(ParseTreeListener):
@@ -12,7 +13,7 @@ def __init__(self):
         self._logger = logging.getLogger("DiceNotationListener")
         self._nodes = []
 
-    def getExpression(self):
+    def expression(self):
         expression = None
 
         self._logger.debug("Checking stack %s for parsed expression", self._nodes)
@@ -24,6 +25,34 @@ def getExpression(self):
 
         return expression
 
+    def binary_operation(self, operators):
+        operands = []
+
+        # There are as many operands as operators plus one
+        for i in range(0, len(operators)):
+            operands.append(self._nodes.pop())
+
+        for operator in operators:
+            left = operands.pop()
+            right = operands.pop()
+
+            if("+" == operator):
+                func = lambda a, b: a + b
+            elif("-" == operator):
+                func = lambda a, b: a - b
+            elif("*" == operator):
+                func = lambda a, b: a * b
+            elif("/" == operator):
+                func = lambda a, b: a / b
+            else:
+                func = None
+                self._logger.error("The %s operator is invalid", operator)
+            operation = BinaryOperation(left, right, operator, func)
+            self._logger.debug("Parsed operation %s", operation)
+            operands.append(operation)
+
+        return operands.pop()
+
     # Enter a parse tree produced by DiceNotationParser#notation.
     def enterNotation(self, ctx):
         self._logger.debug("Entering notation %s", ctx.getText())

dice_notation/parser/dice.py

@@ -25,6 +25,6 @@ def parse(self, input):
         listener = DiceNotationListener()
         walker.walk(listener, tree)
 
-        expression = listener.getExpression()
+        expression = listener.expression()
         self._logger.debug("Parsed expression %s", expression)
         return expression