home · contact · privacy
Add basic reality bubble mechanism.
[plomrogue2-experiments] / new / plomrogue / parser.py
1 import unittest
2 from plomrogue.errors import ArgError
3 from plomrogue.mapping import YX
4
5
6 class Parser:
7
8     def __init__(self, game=None):
9         self.game = game
10
11     def tokenize(self, msg):
12         """Parse msg string into tokens.
13
14         Separates by ' ' and '\n', but allows whitespace in tokens quoted by
15         '"', and allows escaping within quoted tokens by a prefixed backslash.
16         """
17         tokens = []
18         token = ''
19         quoted = False
20         escaped = False
21         for c in msg:
22             if quoted:
23                 if escaped:
24                     token += c
25                     escaped = False
26                 elif c == '\\':
27                     escaped = True
28                 elif c == '"':
29                     quoted = False
30                 else:
31                     token += c
32             elif c == '"':
33                 quoted = True
34             elif c in {' ', '\n'}:
35                 if len(token) > 0:
36                     tokens += [token]
37                     token = ''
38             else:
39                 token += c
40         if len(token) > 0:
41             tokens += [token]
42         return tokens
43
44     def parse(self, msg):
45         """Parse msg as call to function, return function with args tuple.
46
47         Respects function signature defined in function's .argtypes attribute.
48         """
49         tokens = self.tokenize(msg)
50         if len(tokens) == 0:
51             return None, ()
52         func = self.game.get_command(tokens[0])
53         argtypes = ''
54         if hasattr(func, 'argtypes'):
55             argtypes = func.argtypes
56         if func is None:
57             return None, ()
58         if len(argtypes) == 0:
59             if len(tokens) > 1:
60                 raise ArgError('Command expects no argument(s).')
61             return func, ()
62         if len(tokens) == 1:
63             raise ArgError('Command expects argument(s).')
64         args_candidates = tokens[1:]
65         args = self.argsparse(argtypes, args_candidates)
66         return func, args
67
68     def parse_yx_tuple(self, yx_string, range_=None):
69         """Parse yx_string as yx_tuple, return result.
70
71         The range_ argument may be 'nonneg' (non-negative, including
72         0) or 'pos' (positive, excluding 0).
73
74         """
75
76         def get_axis_position_from_argument(axis, token):
77             if len(token) < 3 or token[:2] != axis + ':' or \
78                     not (token[2:].isdigit() or token[2] == '-'):
79                 raise ArgError('Non-int arg for ' + axis + ' position.')
80             n = int(token[2:])
81             if n < 1 and range_ == 'pos':
82                 raise ArgError('Arg for ' + axis + ' position < 1.')
83             elif n < 0 and range_ == 'nonneg':
84                 raise ArgError('Arg for ' + axis + ' position < 0.')
85             return n
86
87         tokens = yx_string.split(',')
88         if len(tokens) != 2:
89             raise ArgError('Wrong number of yx-tuple arguments.')
90         y = get_axis_position_from_argument('Y', tokens[0])
91         x = get_axis_position_from_argument('X', tokens[1])
92         return YX(y, x)
93
94     def argsparse(self, signature, args_tokens):
95         """Parse into / return args_tokens as args defined by signature.
96
97         Expects signature to be a ' '-delimited sequence of any of the
98         strings 'bool', 'int:nonneg', 'yx_tuple', 'yx_tuple:nonneg',
99         'yx_tuple:pos', 'string', 'seq:int:nonneg', 'string:' + an
100         option type string accepted by self.game.get_string_options,
101         defining the respective argument types.
102
103         """
104         tmpl_tokens = signature.split()
105         if len(tmpl_tokens) != len(args_tokens):
106             raise ArgError('Number of arguments (' + str(len(args_tokens)) +
107                            ') not expected number (' + str(len(tmpl_tokens))
108                            + ').')
109         args = []
110         string_string = 'string'
111         for i in range(len(tmpl_tokens)):
112             tmpl = tmpl_tokens[i]
113             arg = args_tokens[i]
114             if tmpl == 'bool':
115                 if arg not in {'True', 'False'}:
116                     raise ArgError('Argument must be "True" or "False".')
117                 args += [True if arg == 'True' else False]
118             elif tmpl == 'int:nonneg':
119                 if not arg.isdigit():
120                     raise ArgError('Argument must be non-negative integer.')
121                 args += [int(arg)]
122             elif tmpl == 'yx_tuple:nonneg':
123                 args += [self.parse_yx_tuple(arg, 'nonneg')]
124             elif tmpl == 'yx_tuple:pos':
125                 args += [self.parse_yx_tuple(arg, 'pos')]
126             elif tmpl == 'yx_tuple':
127                 args += [self.parse_yx_tuple(arg)]
128             elif tmpl == 'seq:int:nonneg':
129                 if arg == ',':
130                     args += [[]]
131                     continue
132                 sub_tokens = arg.split(',')
133                 if len(sub_tokens) < 1:
134                     raise ArgError('Argument must be non-empty sequence.')
135                 seq = []
136                 for tok in sub_tokens:
137                     if not tok.isdigit():
138                         raise ArgError('Argument sequence must only contain '
139                                        'non-negative integers.')
140                     seq += [int(tok)]
141                 args += [seq]
142             elif tmpl == string_string:
143                 args += [arg]
144             elif tmpl[:len(string_string) + 1] == string_string + ':':
145                 if not hasattr(self.game, 'get_string_options'):
146                     raise ArgError('No string option directory.')
147                 string_option_type = tmpl[len(string_string) + 1:]
148                 options = self.game.get_string_options(string_option_type)
149                 if options is None:
150                     raise ArgError('Unknown string option type.')
151                 if arg not in options:
152                     msg = 'Argument #%s must be one of: %s' % (i + 1, options)
153                     raise ArgError(msg)
154                 args += [arg]
155             else:
156                 raise ArgError('Unknown argument type: %s' % tmpl)
157         return args
158
159
160 class TestParser(unittest.TestCase):
161
162     def test_tokenizer(self):
163         p = Parser()
164         self.assertEqual(p.tokenize(''), [])
165         self.assertEqual(p.tokenize(' '), [])
166         self.assertEqual(p.tokenize('abc'), ['abc'])
167         self.assertEqual(p.tokenize('a b\nc  "d"'), ['a', 'b', 'c', 'd'])
168         self.assertEqual(p.tokenize('a "b\nc d"'), ['a', 'b\nc d'])
169         self.assertEqual(p.tokenize('a"b"c'), ['abc'])
170         self.assertEqual(p.tokenize('a\\b'), ['a\\b'])
171         self.assertEqual(p.tokenize('"a\\b"'), ['ab'])
172         self.assertEqual(p.tokenize('a"b'), ['ab'])
173         self.assertEqual(p.tokenize('a"\\"b'), ['a"b'])
174
175     def test_unhandled(self):
176         p = Parser()
177         self.assertEqual(p.parse(''), (None, ()))
178         self.assertEqual(p.parse(' '), (None, ()))
179         #self.assertEqual(p.parse('x'), (None, ()))
180
181     def test_argsparse(self):
182         from functools import partial
183         p = Parser()
184         assertErr = partial(self.assertRaises, ArgError, p.argsparse)
185         assertErr('', ['foo'])
186         assertErr('string', [])
187         assertErr('string string', ['foo'])
188         self.assertEqual(p.argsparse('string', ('foo',)), ['foo'])
189         self.assertEqual(p.argsparse('string string', ('foo', 'bar')),
190                          ['foo', 'bar'])
191         assertErr('int:nonneg', [''])
192         assertErr('int:nonneg', ['x'])
193         assertErr('int:nonneg', ['-1'])
194         assertErr('int:nonneg', ['0.1'])
195         self.assertEqual(p.argsparse('int:nonneg', ('0',)), [0])
196         assertErr('yx_tuple', ['x'])
197         assertErr('yx_tuple', ['Y:1.1,X:1'])
198         self.assertEqual(p.argsparse('yx_tuple', ('Y:1,X:-2',)), [(1, -2)])
199         assertErr('yx_tuple:nonneg', ['Y:0,X:-1'])
200         assertErr('yx_tuple:nonneg', ['Y:-1,X:0'])
201         assertErr('yx_tuple:nonneg', ['Y:1,X:1.1'])
202         self.assertEqual(p.argsparse('yx_tuple:nonneg', ('Y:1,X:2',)),
203                          [(1, 2)])
204         assertErr('yx_tuple:pos', ['Y:0,X:1'])
205         assertErr('yx_tuple:pos', ['Y:1,X:0'])
206         assertErr('seq:int:nonneg', [''])
207         self.assertEqual(p.argsparse('seq:int:nonneg', [',']), [[]])
208         assertErr('seq:int:nonneg', ['a'])
209         assertErr('seq:int:nonneg', ['a,1'])
210         assertErr('seq:int:nonneg', [',1'])
211         assertErr('seq:int:nonneg', ['1,'])
212         self.assertEqual(p.argsparse('seq:int:nonneg', ('1,2,3',)),
213                          [[1, 2, 3]])