def parse_elements(rulename, elements):
machine = StateMachine(rulename)
machine_start = State(START_STATE)
machine_end = State(FINAL_STATE)
elements = elements_splitter.split_into_tokens(elements)
start_edges, end_states, states = recursive_parse_elements(elements)
for state in states:
machine.add_state(state)
for start_edge in start_edges:
machine_start.add_edge(start_edge)
for end_state in end_states:
end_state.add_edge(Edge('', FINAL_STATE))
machine.add_state(machine_start)
machine.add_state(machine_end)
return machine
def test_ending_quoted_elements(self):
elements = 'abc def ghi "jkl mno"'
expected = ['abc', 'def', 'ghi', '"jkl mno"']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_starting_quoted_elements(self):
elements = '"abc def" ghi jkl mno'
expected = ['"abc def"', 'ghi', 'jkl', 'mno']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_nested_bracketed_elements(self):
elements = 'abc def [ghi [jkl mno] pqr] stu'
expected = ['abc', 'def', ['[', 'ghi', ['[', 'jkl', 'mno', ']'], 'pqr', ']'], 'stu']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_single_multipart_bracketed_element(self):
elements = '[abc def]'
expected = [['[', 'abc', 'def', ']']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_bracketed_elements(self):
elements = 'abc def [ghi jkl] mno'
expected = ['abc', 'def', ['[', 'ghi', 'jkl', ']'], 'mno']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_starting_parenthetized_elements(self):
elements = '((abc def) ghi) jkl mno pqr stu'
expected = [[['abc', 'def'], 'ghi'], 'jkl', 'mno', 'pqr', 'stu']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_single_nested_multipart_parenthetized_element(self):
elements = '(((abc def)))'
expected = [[[['abc', 'def']]]]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_N_repetition_with_parentheses(self):
elements = '10(abc def)'
expected = [['10', ['abc', 'def']]]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_N_minus_repetition(self):
elements = '*5abc'
expected = [['*5', 'abc']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_single_elements(self):
elements = 'abc'
self.assertEqual(elements_splitter.split_into_tokens(elements), ['abc'])
def test_single_multipart_bracketed_element_with_parentheses(self):
elements = '[abc (def ghi)]'
expected = [['[', 'abc', ['def', 'ghi'], ']']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_ending_bracketed_elements(self):
elements = 'abc def ghi jkl [[mno pqr] stu]'
expected = ['abc', 'def', 'ghi', 'jkl', ['[', ['[', 'mno', 'pqr', ']'], 'stu', ']']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_starting_bracketed_elements(self):
elements = '[[abc def] ghi] jkl mno pqr stu'
expected = [['[', ['[', 'abc', 'def', ']'], 'ghi', ']'], 'jkl', 'mno', 'pqr', 'stu']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_parenthetized_elements(self):
elements = 'abc def (ghi jkl) mno'
expected = ['abc', 'def', ['ghi', 'jkl'], 'mno']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_single_parenthetized_element(self):
elements = '(abc)'
expected = [['abc']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_multi_or(self):
elements = 'abc / def / ghi'
expected = ['abc', '/', 'def', '/', 'ghi']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_nested_parenthetized_elements(self):
elements = 'abc def (ghi (jkl mno) pqr) stu'
expected = ['abc', 'def', ['ghi', ['jkl', 'mno'], 'pqr'], 'stu']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_parenthetized_or(self):
elements = 'abc / (def / ghi)'
expected = ['abc', '/', ['def', '/', 'ghi']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_ending_parenthetized_elements(self):
elements = 'abc def ghi jkl ((mno pqr) stu)'
expected = ['abc', 'def', 'ghi', 'jkl', [['mno', 'pqr'], 'stu']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_simple_elements(self):
elements = 'abc def ghi'
self.assertEqual(elements_splitter.split_into_tokens(elements), ['abc', 'def', 'ghi'])
def test_empty_elements(self):
elements = ''
self.assertEqual(elements_splitter.split_into_tokens(elements), [])
def test_bracketed_or(self):
elements = 'abc / [def / ghi]'
expected = ['abc', '/', ['[', 'def', '/', 'ghi', ']']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_single_nested_bracketed_element(self):
elements = '[[[abc]]]'
expected = [['[', ['[', ['[', 'abc', ']'], ']'], ']']]
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
def test_quoted_elements(self):
elements = 'abc def "*([ghi jkl])*" mno'
expected = ['abc', 'def', '"*([ghi jkl])*"', 'mno']
self.assertEqual(elements_splitter.split_into_tokens(elements), expected)
