#47 Ensure ParseError is returned for parse TypeError

 * also expose ParseError and PARSE_ERRORS in the API

Author: pombredanne

boolean/__init__.py

@@ -16,6 +16,8 @@
 
 from boolean.boolean import Expression
 from boolean.boolean import Symbol
+from boolean.boolean import ParseError
+from boolean.boolean import PARSE_ERRORS
 
 from boolean.boolean import AND
 from boolean.boolean import NOT

boolean/boolean.py

@@ -60,14 +60,14 @@
 
 PARSE_ERRORS = {
     PARSE_UNKNOWN_TOKEN: 'Unknown token',
-    PARSE_UNBALANCED_CLOSING_PARENS: 'Bad closing parenthesis',
+    PARSE_UNBALANCED_CLOSING_PARENS: 'Unbalanced parenthesis',
     PARSE_INVALID_EXPRESSION: 'Invalid expression',
 }
 
 
 class ParseError(Exception):
     """
-    Raised when the parser or tokemizer encounters a syntax error. Instances of
+    Raised when the parser or tokenizer encounters a syntax error. Instances of
     this class have attributes token_type, token_string, position, error_code to
     access the details of the error. str() of the exception instance returns a
     formatted message.
@@ -80,21 +80,16 @@ def __init__(self, token_type=None, token_string='', position=-1, error_code=0):
         self.error_code = error_code
 
     def __str__(self, *args, **kwargs):
-        ttype = ''
-        if self.token_type:
-            ttype = TOKEN_TYPES.get(self.token_type) or repr(self.token_type)
-            ttype = ' for token type: %r' % (ttype)
-
         tstr = ''
         if self.token_string:
-            tstr = ' with value: %r' % (self.token_string)
+            tstr = ' for token: %r' % (self.token_string)
 
         pos = ''
         if self.position > 0:
             pos = ' at position: %d' % (self.position)
         emsg = PARSE_ERRORS.get(self.error_code, 'Unknown parsing error')
 
-        return '{emsg){ttype}{tstr}(pos}.'.format(ttype=ttype, tstr=tstr, pos=pos, emsg=emsg)
+        return '{emsg}{tstr}{pos}.'.format(tstr=tstr, pos=pos, emsg=emsg)
 
 
 class BooleanAlgebra(object):
@@ -225,32 +220,36 @@ def parse(self, expr, simplify=False):
             elif token == TOKEN_RPAR:
                 while True:
                     if ast[0] is None:
-                        raise ParseError(token, tokstr, position,
-                                         PARSE_UNBALANCED_CLOSING_PARENS)
+                        raise ParseError(token, tokstr, position, PARSE_UNBALANCED_CLOSING_PARENS)
                     if ast[1] is TOKEN_LPAR:
                         ast[0].append(ast[2])
                         ast = ast[0]
                         break
+                    if isinstance(ast[1], int):
+                        raise ParseError(token, tokstr, position, PARSE_UNBALANCED_CLOSING_PARENS)
                     subex = ast[1](*ast[2:])
                     ast[0].append(subex)
                     ast = ast[0]
             else:
                 raise ParseError(token, tokstr, position, PARSE_UNKNOWN_TOKEN)
 
-        while True:
-            if ast[0] is None:
-                if ast[1] is None:
-
-                    if len(ast) != 3:
-                        raise ParseError(error_code=PARSE_INVALID_EXPRESSION)
-                    parsed = ast[2]
+        try:
+            while True:
+                if ast[0] is None:
+                    if ast[1] is None:
+    
+                        if len(ast) != 3:
+                            raise ParseError(error_code=PARSE_INVALID_EXPRESSION)
+                        parsed = ast[2]
+                    else:
+                        parsed = ast[1](*ast[2:])
+                    break
                 else:
-                    parsed = ast[1](*ast[2:])
-                break
-            else:
-                subex = ast[1](*ast[2:])
-                ast[0].append(subex)
-                ast = ast[0]
+                    subex = ast[1](*ast[2:])
+                    ast[0].append(subex)
+                    ast = ast[0]
+        except TypeError:
+            raise ParseError(error_code=PARSE_INVALID_EXPRESSION)
 
         if simplify:
             return parsed.simplify()

boolean/test_boolean.py

@@ -19,6 +19,7 @@
 
 
 from boolean import BooleanAlgebra
+from boolean import ParseError
 from boolean import Symbol
 from boolean import TOKEN_NOT
 from boolean import TOKEN_AND
@@ -265,6 +266,28 @@ def build_symbol(current_dotted):
         )
         self.assertEqual(expected, expr)
 
+    def test_parse_raise_ParseError(self):
+        algebra = BooleanAlgebra()
+        invalid_expressions = [
+            'l-a AND none',
+            '(l-a + AND l-b',
+            '(l-a + AND l-b)',
+            '(l-a AND l-b',
+            '(l-a + AND l-b))',
+            '(l-a  AND l-b))',
+            'l-a AND',
+            'OR l-a',
+            '+ l-a',
+        ]
+
+        for expr in invalid_expressions:
+            print(expr)
+            try:
+                algebra.parse(expr)
+                self.fail("Exception should be raised when parsing '%s'" % expr)
+            except ParseError:
+                pass
+
 
 class BaseElementTestCase(unittest.TestCase):