def test_ab_concat_offset(self) -> None:
a_parser = CharParser('a')
b_parser = CharParser('b')
ab_combo = combinator.AND(a_parser, b_parser)
exp_a_only = ParseResult(1, 'a')
exp_b_only = ParseResult(2, 'b')
a_only = a_parser('ab', idx=0)
assert exp_a_only == a_only
b_only = b_parser('ab', idx=1)
assert exp_b_only == b_only
exp_a_result = ParseResult()
exp_ab_result_0 = ParseResult(2, 'ab')
exp_ab_result_1 = ParseResult()
a_result = ab_combo('a', idx=0)
assert exp_a_result == a_result
ab_result_0 = ab_combo('ab', idx=0)
assert exp_ab_result_0 == ab_result_0
ab_result_1 = ab_combo('ab', idx=1)
assert exp_ab_result_1 == ab_result_1
def test_concatenation(self) -> None:
a_parser = CharParser('a')
b_parser = CharParser('b')
# this combinator can recognise 'ab'
ab_combo = combinator.AND(a_parser, b_parser)
# expected outputs
exp_outputs = [
ParseResult(), # ''
ParseResult(), # 'a'
ParseResult(2, 'ab'), # 'ab'
ParseResult(), # 'aa'
ParseResult(), # 'aaa'
ParseResult(2, 'ab'), # 'aba'
]
#from pudb import set_trace; set_trace()
results = []
for inp in self.inp_strings:
results.append(ab_combo(inp))
print('%s results for each string :' % str(ab_combo))
for n, r in enumerate(results):
print(n, r)
assert len(results) == len(exp_outputs)
for n, (exp, out) in enumerate(zip(exp_outputs, results)):
print("[%d / %d] : comparing %s -> %s" % \
(n, len(results), str(exp), str(out))
)
assert exp == out
def test_kleene_dot_char(self) -> None:
p = CharParser('a')
ks = combinator.KleeneDot(p)
# expected outputs
exp_outputs = [
ParseResult(0, ''), # ''
ParseResult(1, 'a'), # 'a'
ParseResult(2, 'aa'), # 'aa'
ParseResult(3, 'aaa'), # 'aaa'
ParseResult(4, 'aaaa'), # 'aaaa'
ParseResult(3, 'aaa'), # 'aaabcdefg'
]
# Parse the strings
results = []
for inp in self.inp_strings_alpha:
results.append(ks(inp))
print('%s results for each string :' % str(ks))
for n, r in enumerate(results):
print(n, r, repr(ks), self.inp_strings_alpha[n])
assert len(results) == len(exp_outputs)
for n, (exp, out) in enumerate(zip(exp_outputs, results)):
print("[%d / %d] : comparing %s -> %s" % \
(n, len(results), str(exp), str(out))
)
assert exp == out
def test_zero_or_more(self) -> None:
c = CharParser('a')
comb = combinator.ZeroOrMore(c)
# expected outputs
exp_outputs = [
ParseResult(1, ''), # ''
ParseResult(1, 'a'), # 'a'
ParseResult(2, 'aa'), # 'aa'
ParseResult(3, 'aaa'), # 'aaa'
ParseResult(4, 'aaaa'), # 'aaaa'
ParseResult(3, 'aaa'), # 'aaabcdefg'
]
# Parse the strings
results = []
for inp in self.inp_strings_num:
results.append(comb(inp))
print('%s results for each string :' % str(ks))
for n, r in enumerate(results):
print(n, r, repr(comb), self.inp_strings_num[n])
assert len(results) == len(exp_outputs)
for n, (exp, out) in enumerate(zip(exp_outputs, results)):
print("[%d / %d] : comparing %s -> %s" % \
(n, len(results), str(exp), str(out))
)
assert exp == out
def test_left_combinator(self) -> None:
tag_parser = CharParser("<")
iden_parser = Identifier()
left_combo = Left(tag_parser, iden_parser)
expected_result = ParseResult(1, "<")
parse_result = left_combo(self.test_element)
assert parse_result == expected_result
def test_right_combinator(self) -> None:
tag_parser = CharParser("<")
iden_parser = Identifier()
right_combo = Right(tag_parser, iden_parser)
#expected_result = ParseResult(2, "/>")
expected_result = ParseResult(14, "some-element/")
parse_result = right_combo(self.test_element)
assert parse_result == expected_result
def test_tag_open_combinator(self) -> None:
tag_parser = CharParser("<")
iden_parser = Identifier()
tag_open_combinator = AND(tag_parser, iden_parser)
# NOTE: this is what the combinator outputs, but I am not quite happy
# with it...
expected_result = ParseResult(14, "<some-element/")
parse_result = tag_open_combinator(self.test_element)
assert parse_result == expected_result
def test_kleene_star_char(self) -> None:
p = CharParser('a')
ks = combinator.KleeneStar(p)
# expected outputs
exp_outputs = [
ParseResult(0, ''), # ''
ParseResult(0, ''), # 'a'
ParseResult(0, ''), # 'aa'
ParseResult(0, ''), # 'aaa'
ParseResult(0, ''), # 'aaaa'
ParseResult(0, ''), # 'aaabcdefg'
]
# 'a'
exp_outputs[1].add(1, 'a')
# 'aa'
exp_outputs[2].add(2, 'aa')
# 'aaa'
exp_outputs[3].add(3, 'aaa')
# 'aaaa'
exp_outputs[4].add(4, 'aaaa')
# 'aaabcdefg'
exp_outputs[5].add(3, 'aaa')
# Parse the strings
results = []
for inp in self.inp_strings_alpha:
results.append(ks(inp))
print('%s results for each string :' % str(ks))
for n, r in enumerate(results):
print(n, r, repr(ks), self.inp_strings_alpha[n])
assert len(results) == len(exp_outputs)
for n, (exp, out) in enumerate(zip(exp_outputs, results)):
print("[%d / %d] : comparing %s -> %s" % \
(n, len(results), str(exp), str(out))
)
assert exp == out
# if we turn on partial match then we should get 'aaa' as the
# result for the input string 'aaabcdefg'
exp_partial_match = ParseResult(0, '')
exp_partial_match.add(3, 'aaa')
ks.accept_partial = True
partial_match_result = ks(self.inp_strings_alpha[5])
assert exp_partial_match == partial_match_result
def test_word_space_word(self) -> None:
# Test ZZ* S ZZ*
s_parser = CharParser(' ')
z_parser = AlphaParser()
# Make some combinators
word_parser = combinator.KleeneStar(z_parser)
word_parser = combinator.AND(z_parser, word_parser)
word_plus_space_parser = combinator.AND(word_parser, s_parser)
word_space_word_parser = combinator.AND(word_plus_space_parser,
word_parser)
parser_output = []
for inp in self.inp_strings:
parser_output.append(word_space_word_parser(inp))
for n, r in enumerate(parser_output):
print(n, r)
def test_parse_char(self) -> None:
exp_outputs_1 = [
ParseResult(),
ParseResult(1, self.inp_strings_1[1][0]),
ParseResult(1, self.inp_strings_1[2][0]),
ParseResult(1, self.inp_strings_1[3][0]),
ParseResult(1, self.inp_strings_1[4][0]),
ParseResult()
]
cparser = CharParser('a')
parser_outputs = []
for i in self.inp_strings_1:
parser_outputs.append(cparser(i, idx=0))
# display
for n, o in enumerate(parser_outputs):
print('Input %d [%s] produced : %s' %
(n, self.inp_strings_1[n], str(o)))
assert len(parser_outputs) == len(exp_outputs_1)
for exp_out, test_out in zip(exp_outputs_1, parser_outputs):
assert exp_out == test_out
def __init__(self) -> None:
self.quote = CharParser("\"")
self.alpha = AlphaSpaceParser()
self.left = AND(ZeroOrMoreCombinator(self.alpha), self.quote)
self.quoted_str = AND(self.quote, self.left)