def match(self, text_iterator: TextIterator):
for df in self._objList:
text_iterator.skip_whitespace()
if df.match(text_iterator):
self._chosen = df
return True
return False
def match(self, text_iterator: TextIterator):
try:
start_pos = text_iterator.current_pos().copy()
if self._object.match(text_iterator):
self._found_obj = self._object
self._start_pos = self._object.get_start_pos().copy()
self._last_pos = self._object.get_last_pos().copy()
return True
except StopIteration:
log.debug("GObject:match - StopIteration")
text_iterator.set_current_pos(start_pos)
return True
def test_underscore_name(self):
obj = GName()
text = "\naBBa"
text_iterator = TextIterator(text)
self.assertTrue(obj.match(text_iterator))
self.assertEqual("aBBa", obj.get_name())
self.assertEqual((1, 3), obj.get_last_pos().tuple())
def test_two_chars(self):
obj = GWord("aB")
text = "aBBa"
text_iterator = TextIterator(text)
self.assertTrue(obj.match(text_iterator))
self.assertEqual((0, 0), obj.get_start_pos().tuple())
self.assertEqual((0, 1), obj.get_last_pos().tuple())
def test_single_line(self):
text = "asdf"
text_iterator = TextIterator(text)
gany = GAny()
self.assertTrue(gany.match(text_iterator))
pos = gany.get_last_pos()
self.assertEqual("asdf", gany.get_text())
self.assertEqual((0, 3), pos.tuple())
def test_one_letter_name(self):
obj = GName()
text = "a"
text_iterator = TextIterator(text)
self.assertTrue(obj.match(text_iterator))
self.assertEqual("a", obj.get_name())
self.assertEqual((0, 0), obj.get_start_pos().tuple())
self.assertEqual((0, 0), obj.get_last_pos().tuple())
def test_empty_braces(self):
exp = BracketExp("(", ")")
text = "()"
text_iterator = TextIterator(text)
self.assertTrue(exp.match(text_iterator))
pos = exp.get_last_pos()
self.assertEqual((1, 0), pos.tuple())
body = exp.get_body().get_text()
self.assertEqual("", body)
def test_3_words(self):
defs = GSequence([GWord("def"), GWord("def"), GWord("def")])
lines = ["def def", " def"]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
self.assertEqual((1, len(lines[1]) - 1),
defs.get_last_pos().tuple(),
"Position should be in last line")
def test_def_name(self):
defs = GSequence([GWord("def"), GName()])
lines = ["def Test_Fun123", ""]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
pos = defs.get_last_pos()
self.assertEqual((0, 14), pos.tuple())
self.assertEqual("Test_Fun123", defs.get_definitions()[1].get_name())
def test_fun_arguments(self):
exp = BracketExp("(", ")")
exp.set_recursive_definitions([exp, GAny()])
text = "(a,b,c)"
text_iterator = TextIterator(text)
self.assertTrue(exp.match(text_iterator))
pos = exp.get_last_pos()
self.assertEqual((1, 0), pos.tuple())
body = exp.get_body().get_text()
self.assertEqual("a,b,c", body)
def test_single_word(self):
a = GWord("A")
b = GWord("B")
obj = GChoice([a, b])
text = "B"
text_iterator = TextIterator(text)
self.assertTrue(obj.match(text_iterator))
pos = obj.get_last_pos()
self.assertEqual(1, pos[0])
self.assertEqual(b, obj.get_chosen())
def test_def_fun_incomplete(self):
defs = GSequence([GWord("def"), GName()])
lines = ["def Test_Fun123(a: Integer)", ""]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
pos = defs.get_last_pos().tuple()
self.assertEqual(0, pos[0])
self.assertEqual(len("def Test_Fun123") - 1, pos[1])
self.assertEqual("Test_Fun123", defs.get_definitions()[1].get_name())
def find_last_pos(self, text_iterator: TextIterator) -> Position:
self._name = ''
last_pos = None
it = iter(text_iterator)
try:
while text_iterator.is_valid_pos():
prev_pos = text_iterator.current_pos().copy()
char = next(it)
if not GName.is_name_char(char):
text_iterator.set_current_pos(prev_pos)
break
last_pos = prev_pos
self._name += char
except StopIteration:
log.debug("GName:StopIteration")
if len(self._name) > 0:
log.debug("Found GName: {} ending at pos {}".format(self._name, last_pos))
return last_pos
return None
def test_bracket_exp_def(self):
bracket_exp = BracketExp("(", ")")
defs = GSequence([GWord("def"), bracket_exp])
# defs.set_recursive_definitions([defs])
lines = ["def(a, b, c) "]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
pos = defs.get_last_pos().tuple()
self.assertEqual((0, len(lines[0]) - 2), pos)
self.assertEqual("a, b, c", bracket_exp.get_body().get_text())
def find_last_pos(self, text_iterator: TextIterator):
pos = None
for i in range(0, len(self._word)):
pos = text_iterator.current_pos().copy()
v = next(text_iterator)
if v != self._word[i]:
log.debug("Word: {} mismatch at pos {}".format(
self._word, pos))
return None
log.debug("Found word: {} at pos: {}".format(self._word, pos))
return pos
def test_bracket_exp3(self):
defs = GSequence(
[GWord("def"),
GName(), BracketExp("(", ")"),
GType()])
lines = ["def TestFun_123(a, b, c) :Unit"]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
pos = defs.get_last_pos()
self.assertEqual(len(lines), pos[0])
def test_optional_invalid(self):
defs = GSequence([
GWord("def"),
GName(),
GOptional(GWord(":")),
GName(),
GWord("{")
])
lines = ["def test {"]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertFalse(defs.match(text_iterator))
def test_sequence(self):
int_choose = GWord("int")
float_choose = GWord("float")
tchoice = GChoice([int_choose, float_choose])
def_choice = GChoice([GWord(";"), GWord("= 1;")])
name = GName()
seq = GSequence([tchoice, name, def_choice])
text = "int num;"
text_iterator = TextIterator(text)
self.assertTrue(seq.match(text_iterator))
self.assertEqual("num", name.get_name())
self.assertEqual(int_choose, tchoice.get_chosen())
def test_nested_bracket_exps(self):
defs = GSequence([
GWord("def"),
GName(),
BracketExp("(", ")"),
BracketExp("{", "}")
])
nestedFun = "def hello() { print(\"hello\") }"
lines = ["def TestFun_123(a, b, c) {", nestedFun, "}"]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
pos = defs.get_last_pos()
self.assertEqual(len(lines), pos[0])
def test_optional_type(self):
defs = GSequence([
GWord("def"),
GName(),
GOptional(GWord(":")),
GName(),
GWord("{")
])
lines = ["def test: test_name {"]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
pos = defs.get_last_pos().tuple()
self.assertEqual((0, 20), pos)
def test_bracket_exp2(self):
defs = GSequence([
GWord("def"),
GName(),
BracketExp("(", ")"),
BracketExp("{", "}")
])
defs.set_recursive_definitions([defs])
lines = [
"def TestFun_123(a, b, c) {", " print(123) ", "print(456)", "}"
]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertTrue(defs.match(text_iterator))
pos = defs.get_last_pos()
self.assertEqual(len(lines), pos[0])
def match(self, text_iterator: TextIterator):
try:
text_iterator.skip_whitespace()
self._start_pos = text_iterator.current_pos().copy()
self._text = ''
while not text_iterator.is_after_end():
if text_iterator.is_valid_pos():
self._text += next(text_iterator)
if text_iterator.current_pos().r > self._start_pos.r:
break
self._last_pos = text_iterator.current_pos().copy()
except StopIteration:
log.debug("GAny - StopIteration")
return len(self._text) > 0
def match(self, text_iterator: TextIterator):
log.debug("match start")
start_pos = text_iterator.current_pos().copy()
if self._find_matching_braces(text_iterator):
content_start = self._start_pos.copy().move(
1, text_iterator.get_lines())
content_end = self._last_pos.copy().move(-1,
text_iterator.get_lines())
inside_text = text_iterator.get_substr(content_start, content_end)
log.debug("Parsing inside definition: {}\n".format(inside_text))
if self._definitions is not None:
self._body = GObject.parse_definitions(inside_text,
self._definitions)
self._body.set_recursive_definitions(self._definitions)
else:
self._body = GWord(inside_text)
return True
text_iterator.set_current_pos(start_pos)
return False
def test_empty_text(self):
text = ""
text_iterator = TextIterator(text)
gany = GAny()
self.assertFalse(gany.match(text_iterator))
self.assertEqual("", gany.get_text())
def test_one_char(self):
obj = GWord("a")
text = "a"
text_iterator = TextIterator(text)
self.assertTrue(obj.match(text_iterator))
self.assertEqual((0, 0), obj.get_last_pos().tuple())
def test_spaces(self):
obj = GName()
text = " \t test_name"
text_iterator = TextIterator(text)
self.assertTrue(obj.match(text_iterator))
self.assertEqual((0, len(text) - 1), obj.get_last_pos().tuple())
def test_3_words_invalid(self):
defs = GSequence([GWord("def"), GWord("def"), GWord("def")])
lines = ["def def", " abc"]
text = "\n".join(lines)
text_iterator = TextIterator(text)
self.assertFalse(defs.match(text_iterator))
def __init__(self, text):
self._text_iterator = TextIterator(text)
self._definitions = [ClassDefinition(), GSequence([GAny()])]
for df in self._definitions:
df.set_recursive_definitions(self._definitions)
