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)