def _test_single(self, parser_element, input_output):
p = parser.Parser(parser_element)
print "Parser:", parser_element
for input, output in input_output:
print "Input:", input
result = p.parse(input)
print "Expected: %r" % output
print "Result: %r" % result
self.assertEqual(result, output)
def _test_multiple(self, parser_element, input_outputs, must_finish=True):
p = parser.Parser(parser_element)
for input, outputs in input_outputs:
results = p.parse_multiple(input, must_finish)
self.assertEqual(len(results), len(outputs))
for index, result, output in zip(xrange(len(results)), results, outputs):
if isinstance(result, list): result = tuple(result)
if isinstance(output, list): output = tuple(output)
self.assertEqual(result, output)
def _test_multiple(self, parser_element, input_outputs, must_finish=True):
p = parser.Parser(parser_element)
print "Parser:", parser_element
for input, outputs in input_outputs:
print "Input:", input
results = p.parse_multiple(input, must_finish)
self.assertEqual(len(results), len(outputs))
for index, result, output in zip(xrange(len(results)), results,
outputs):
if isinstance(result, list): result = tuple(result)
if isinstance(output, list): output = tuple(output)
print "Expected: %r" % output
print "Result %d: %r" % (index, result)
self.assertEqual(result, output)
class Compound(elements_.Alternative):
_log = logging.getLogger("compound.parse")
_parser = parser_.Parser(stuff, _log)
def __init__(self,
spec,
extras=None,
actions=None,
name=None,
value=None,
value_func=None,
elements=None,
default=None):
self._spec = spec
self._value = value
self._value_func = value_func
if extras is None: extras = {}
if actions is None: actions = {}
if elements is None: elements = {}
# Convert extras argument from sequence to mapping.
if isinstance(extras, (tuple, list)):
mapping = {}
for element in extras:
if not isinstance(element, elements_.ElementBase):
self._log.error("Invalid extras item: %s" % element)
raise TypeError("Invalid extras item: %s" % element)
if not element.name:
self._log.error("Extras item does not have a name: %s" %
element)
raise TypeError("Extras item does not have a name: %s" %
element)
if element.name in mapping:
self._log.warning(
"Multiple extras items with the same name: %s" %
element)
mapping[element.name] = element
extras = mapping
elif not isinstance(extras, dict):
self._log.error("Invalid extras argument: %s" % extras)
raise TypeError("Invalid extras argument: %s" % extras)
# Temporary transition code so that both "elements" and "extras"
# are supported as keyword arguments.
if extras and elements:
extras = dict(extras)
extras.update(elements)
elif elements:
extras = elements
self._extras = extras
# This solution is non-ideal as "stuff" is a global instance.
stuff.set_elements(extras)
stuff.set_actions(actions)
element = self._parser.parse(spec)
if not element:
self._log.error("Invalid compound spec: %r" % spec)
raise SyntaxError("Invalid compound spec: %r" % spec)
elements_.Alternative.__init__(self, (element, ),
name=name,
default=default)
def __str__(self):
arguments = ["%r" % self._spec]
if self.name: arguments.append("name=%r" % self.name)
arguments = ", ".join(arguments)
return "%s(%s)" % (self.__class__.__name__, arguments)
def value(self, node):
if self._value_func is not None:
# Prepare *extras* dict for passing to value_func().
extras = {"_node": node}
for name, element in self._extras.iteritems():
extra_node = node.get_child_by_name(name, shallow=True)
if extra_node:
extras[name] = extra_node.value()
elif element.has_default():
extras[name] = element.default
try:
value = self._value_func(node, extras)
except Exception, e:
self._log.warning("Exception from value_func: %s" % e)
raise
return value
elif self._value is not None:
return self._value
def _test_single(self, parser_element, input_output):
p = parser.Parser(parser_element)
for input, output in input_output:
result = p.parse(input)
self.assertEqual(result, output)
