Refactor parser code.

[plomrogue2] / plomrogue / parser.py

diff --git a/plomrogue/parser.py b/plomrogue/parser.py
index a1b56b571b650431d297badf3f0e4573da731359..51f5cc20390ac71c50b5b1baae7f53fcd7c12bdd 100644 (file)
--- a/plomrogue/parser.py
+++ b/plomrogue/parser.py
@@ -1,4 +1,3 @@
-import unittest
 from plomrogue.errors import ArgError
 from plomrogue.mapping import YX
 
@@ -7,6 +6,7 @@ class Parser:
 
     def __init__(self, game=None):
         self.game = game
+        self.string_options = {}
 
     def tokenize(self, msg):
         """Parse msg string into tokens.
@@ -45,16 +45,23 @@ class Parser:
         """Parse yx_string as yx_tuple, return result.
 
         The range_ argument may be 'nonneg' (non-negative, including
-        0) or 'pos' (positive, excluding 0).
+        0) or 'pos' (positive, excluding 0) or 'all'.
 
         """
 
         def get_axis_position_from_argument(axis, token):
-            if len(token) < 3 or token[:2] != axis + ':' or \
-                    not (token[2:].isdigit() or token[2] == '-'):
-                raise ArgError('Non-int arg for ' + axis + ' position.')
-            n = int(token[2:])
-            if n < 1 and range_ == 'pos':
+            if token[:2] != axis + ':':
+                raise ArgError('invalid YX tuple formatting')
+            n_string = token[2:]
+            if n_string.strip() != n_string:
+                raise ArgError('invalid YX tuple formatting')
+            try:
+                n = int(n_string)
+            except ValueError:
+                raise ArgError('non-int value for ' + axis + ' position')
+            if range_ == 'all':
+                return n
+            if n < 1 and range == 'pos':
                 raise ArgError('Arg for ' + axis + ' position < 1.')
             elif n < 0 and range_ == 'nonneg':
                 raise ArgError('Arg for ' + axis + ' position < 0.')
@@ -67,11 +74,23 @@ class Parser:
         x = get_axis_position_from_argument('X', tokens[1])
         return YX(y, x)
 
-    def parse(self, msg):
+    def parse(self, msg, replace_newline=True):
         """Parse msg as call to function, return function with args tuple.
 
         Respects function signature defined in function's .argtypes attribute.
+
+        Refuses messages with any but a small list of acceptable characters.
+
         """
+        import string
+        if replace_newline:
+            msg = msg.replace('\n', ' ')  # Inserted by some tablet keyboards.
+        legal_chars = string.digits + string.ascii_letters +\
+            string.punctuation + ' ' + 'ÄäÖöÜüߧ' + 'éèáàô' + '–…'
+        for c in msg:
+            if not c in legal_chars:
+                raise ArgError('Command/message contains illegal character(s), '
+                               'may only contain ones of: %s' % legal_chars)
         tokens = self.tokenize(msg)
         if len(tokens) == 0:
             return None, ()
@@ -95,8 +114,8 @@ class Parser:
         tmpl_tokens = signature.split()
         if len(tmpl_tokens) != len(args_tokens):
             raise ArgError('Number of arguments (' + str(len(args_tokens)) +
-                           ') not expected number (' + str(len(tmpl_tokens))
-                           + ').')
+                           ') not expected number (' + str(len(tmpl_tokens)) +
+                           ').')
         args = []
         string_string = 'string'
         for i in range(len(tmpl_tokens)):
@@ -110,6 +129,15 @@ class Parser:
                 if not arg.isdigit() or int(arg) < 1:
                     raise ArgError('Argument must be positive integer.')
                 args += [int(arg)]
+            elif tmpl == 'int':
+                try:
+                    args += [int(arg)]
+                except ValueError:
+                    raise ArgError('Argument must be integer.')
+            elif tmpl == 'bool':
+                if not arg.isdigit() or int(arg) not in (0, 1):
+                    raise ArgError('Argument must be 0 or 1.')
+                args += [bool(int(arg))]
             elif tmpl == 'char':
                 try:
                     ord(arg)
@@ -120,15 +148,15 @@ class Parser:
                 args += [self.parse_yx_tuple(arg, 'nonneg')]
             elif tmpl == 'yx_tuple:pos':
                 args += [self.parse_yx_tuple(arg, 'pos')]
+            elif tmpl == 'yx_tuple':
+                args += [self.parse_yx_tuple(arg, 'all')]
             elif tmpl == string_string:
                 args += [arg]
             elif tmpl[:len(string_string) + 1] == string_string + ':':
-                if not hasattr(self.game, 'get_string_options'):
-                    raise ArgError('No string option directory.')
                 string_option_type = tmpl[len(string_string) + 1:]
-                options = self.game.get_string_options(string_option_type)
-                if options is None:
-                    raise ArgError('Unknown string option type.')
+                if not string_option_type in self.string_options.keys():
+                    raise ArgError('Unknown string option type: %s' % string_option_type)
+                options = self.string_options[string_option_type]
                 if arg not in options:
                     msg = 'Argument #%s must be one of: %s' % (i + 1, options)
                     raise ArgError(msg)