Пример #1
0
    def test_18_hookNoParam(self):
        @meta.hook(parsing.Parser)
        def my_hook(self):
            self.the_hook = True
            return True

        bnf = dsl.EBNF("""
            the_rule = [ #my_hook ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res)
        self.assertIsInstance(res['the_rule'], parsing.Hook)
        self.assertTrue(res['the_rule'].name == "my_hook")
        dummyData = parsing.Parser()
        dummyData.set_rules(res)
        dummyData.the_hook = False
        res = dummyData.eval_rule('the_rule')
        self.assertTrue(res)
        self.assertTrue(dummyData.the_hook)
        bnf = dsl.EBNF("""
            the_rule = [ #my_hook() ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res)
        self.assertIsInstance(res['the_rule'], parsing.Hook)
        self.assertTrue(res['the_rule'].name == "my_hook")
        dummyData = parsing.Parser()
        dummyData.set_rules(res)
        dummyData.the_hook = False
        res = dummyData.eval_rule('the_rule')
        self.assertTrue(res)
        self.assertTrue(dummyData.the_hook)
Пример #2
0
 def test_18_hookNoParam(self):
     bnf = dsl.EBNF("""
         the_rule = [ #hook ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Hook)
Пример #3
0
    def test_24_hookAndCapture(self):
        @meta.hook(parsing.Parser)
        def my_hook_multi(self, n1, n2, n3):
            self.test.assertTrue(self.value(n1) == "456")
            self.test.assertTrue(self.value(n2) == '"toto"')
            self.test.assertTrue(self.value(n3) == "blabla")
            return True

        bnf = dsl.EBNF("""

            N = [ Base.num ]

            S = [ Base.string ]

            I = [ Base.id ]

            the_rule = [ N:nth S:t I:i
                         #my_hook_multi(nth, t, i)
            ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res)
        self.assertIsInstance(res['the_rule'], parsing.Seq)
        self.assertTrue(res['the_rule'][-1].name == "my_hook_multi")
        dummyData = parsing.Parser("""
            456    "toto"        blabla
            """)
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        eval_res = dummyData.eval_rule('the_rule')
        self.assertTrue(eval_res)
Пример #4
0
    def test_28_errors(self):
        with self.assertRaises(TypeError):

            @meta.hook(parsing.Parser, "num")
            def check5(self):
                pass

        with self.assertRaises(TypeError):

            @meta.rule(parsing.Parser, "Base.read_char")
            def check6(self):
                pass

        with self.assertRaises(TypeError):

            @meta.hook(parsing.Parser, "plop")
            def check7(self):
                pass

            bnf = dsl.EBNF("""
                main = [ #plop ]
            """)
            res = bnf.get_rules()
            p = parsing.Parser("")
            p.set_rules(res)
            p.eval_rule('main')
Пример #5
0
    def test_25_list_id(self):
        @meta.hook(parsing.Parser)
        def in_list(self, ls, ident):
            if not hasattr(ls, 'list'):
                ls.list = []
            ls.list.append(self.value(ident))
            return True

        bnf = dsl.EBNF("""

            I = [ id ]

            list = [ [I : i #in_list(_, i) ]+ ]
        """)
        res = bnf.get_rules()
        self.assertTrue('list' in res)
        dummyData = parsing.Parser("""
            a     b c   d        e   f
        """)
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        eval_res = dummyData.eval_rule('list')
        self.assertTrue(eval_res)
        self.assertTrue(eval_res.list[0] == "a")
        self.assertTrue(eval_res.list[1] == "b")
        self.assertTrue(eval_res.list[2] == "c")
        self.assertTrue(eval_res.list[3] == "d")
        self.assertTrue(eval_res.list[4] == "e")
        self.assertTrue(eval_res.list[5] == "f")
Пример #6
0
    def test_27_nodescope(self):
        @meta.hook(parsing.Parser)
        def put(self, ast):
            # A.put visible in subrules
            ast.put = True
            return True

        @meta.hook(parsing.Parser)
        def check1(self):
            self.test.assertTrue('A' in self.rule_nodes)
            # _ is from rule1, not main
            self.test.assertFalse(hasattr(self.rule_nodes['_'], 'put'))
            # return of rule1 with .toto == True
            self.rule_nodes['_'].toto = True
            return True

        @meta.hook(parsing.Parser)
        def check2(self):
            self.test.assertTrue('A' in self.rule_nodes)
            self.test.assertTrue('B' in self.rule_nodes)
            return False

        @meta.hook(parsing.Parser)
        def check3(self):
            self.test.assertTrue('A' in self.rule_nodes)
            # B no more living (alternative)
            self.test.assertFalse('B' in self.rule_nodes)
            return True

        @meta.hook(parsing.Parser)
        def toto(self):
            self.test.assertTrue(hasattr(self.rule_nodes['r'], 'toto'))
            self.test.assertTrue(hasattr(self.rule_nodes['r'], 'bla'))
            return True

        @meta.hook(parsing.Parser)
        def check4(self):
            self.rule_nodes['_'].bla = True
            return True

        bnf = dsl.EBNF("""
            main =
            [ __scope__:A #put(_)
                rule1:r #toto eof
            ]

            rule1 =
            [
                #check1 __scope__:B #check2
                | #check3 #check4
            ]
        """)
        res = bnf.get_rules()
        self.assertTrue('main' in res)
        self.assertTrue('rule1' in res)
        dummyData = parsing.Parser("")
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        eval_res = dummyData.eval_rule('main')
Пример #7
0
 def test_16_lookaheadRule(self):
     bnf = dsl.EBNF("""
         the_rule = [ !!a ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.LookAhead)
     self.assertEqual(res['the_rule'].pt.name, 'a')
Пример #8
0
 def test_14_negatedRule(self):
     bnf = dsl.EBNF("""
         the_rule = [ !a ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Neg)
     self.assertEqual(res['the_rule'].pt.name, 'a')
Пример #9
0
 def test_17_lookaheadRepeatedRule(self):
     bnf = dsl.EBNF("""
         the_rule = [ !!a+ ]
     """)
     with self.assertRaises(error.Diagnostic) as pe:
         r = bnf.get_rules()
     self.assertEqual(pe.exception.logs[0].msg,
                      "Cannot repeat a lookahead rule", "Bad message")
Пример #10
0
 def test_13_complementedRepeatedRule(self):
     bnf = dsl.EBNF("""
         the_rule = [ ~a+ ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Rep1N)
     self.assertIsInstance(res['the_rule'].pt, parsing.Complement)
     self.assertEqual(res['the_rule'].pt.pt.name, 'a')
Пример #11
0
 def test_10_repoption(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ a? ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.RepOptional)
     self.assertTrue(res['the_rule'].pt.name == 'a')
Пример #12
0
 def test_06_char(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ 'a' ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Char)
     self.assertTrue(res['the_rule'].char == 'a')
Пример #13
0
 def test_07_string(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ "bonjour le monde" ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Text)
     self.assertTrue(res['the_rule'].text == "bonjour le monde")
Пример #14
0
 def test_01_one_rule(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ a ]
     """)
     res = bnf.get_rules()
     self.assertIn('the_rule', res)
     self.assertIsInstance(res['the_rule'], parsing.Rule)
     self.assertEqual(res['the_rule'].name, 'a')
Пример #15
0
 def test_12_rep1N(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ [a "toto"]+ ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Rep1N)
     self.assertTrue(res['the_rule'].pt[0].name == 'a')
     self.assertTrue(res['the_rule'].pt[1].text == "toto")
Пример #16
0
 def test_11_rep0N(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ a* ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res, "failed to fetch the rule name")
     self.assertIsInstance(res['the_rule'], parsing.Rep0N)
     self.assertIsInstance(res['the_rule'].pt, parsing.Rule)
     self.assertTrue(res['the_rule'].pt.name == 'a')
Пример #17
0
 def test_08_range(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ 'a'..'z' ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Range)
     self.assertTrue(res['the_rule'].begin == 'a')
     self.assertTrue(res['the_rule'].end == 'z')
Пример #18
0
 def test_04_one_alt(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ a | b ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Alt)
     self.assertIsInstance(res['the_rule'][0], parsing.Rule)
     self.assertTrue(res['the_rule'][0].name == "a")
     self.assertIsInstance(res['the_rule'][1], parsing.Rule)
     self.assertTrue(res['the_rule'][1].name == "b")
Пример #19
0
 def test_03_more_rules(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ a b c]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Seq)
     self.assertIsInstance(res['the_rule'][0], parsing.Rule)
     self.assertTrue(res['the_rule'][0].name == "a")
     self.assertIsInstance(res['the_rule'][1], parsing.Rule)
     self.assertTrue(res['the_rule'][1].name == "b")
     self.assertIsInstance(res['the_rule'][2], parsing.Rule)
     self.assertTrue(res['the_rule'][2].name == "c")
Пример #20
0
    def test_20_hookOneParamChar(self):
        @meta.hook(parsing.Parser)
        def my_hook_char(self, txt):
            self.test.assertEqual(txt, "\t", 'failed to receive "\t" in hook')
            return True

        bnf = dsl.EBNF("""
            the_rule = [ #my_hook_char('\t') ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res, "failed to fetch the rule name")
        self.assertIsInstance(res['the_rule'], parsing.Hook)
        self.assertTrue(res['the_rule'].name == "my_hook_char")
        dummyData = parsing.Parser()
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        res = dummyData.eval_rule('the_rule')
        self.assertTrue(res)
Пример #21
0
    def test_22_hookOneParamId(self):
        @meta.hook(parsing.Parser)
        def my_hook_id(self, n):
            self.test.assertIsInstance(n, parsing.Node)
            return True

        bnf = dsl.EBNF("""
            the_rule = [ #my_hook_id(_) ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res)
        self.assertIsInstance(res['the_rule'], parsing.Hook)
        self.assertTrue(res['the_rule'].name == "my_hook_id")
        dummyData = parsing.Parser()
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        res = dummyData.eval_rule('the_rule')
        self.assertTrue(res)
Пример #22
0
 def test_02_two_rules(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule=[a b c]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res, "failed to fetch the rule name")
     self.assertIsInstance(res['the_rule'], parsing.Seq,
                           "failed in ParserTree type for node Seq")
     self.assertIsInstance(res['the_rule'][0], parsing.Rule,
                           "failed in ParserTree type for node Rule")
     self.assertTrue(res['the_rule'][0].name == "a",
                     "failed in name of rule 'a'")
     self.assertIsInstance(res['the_rule'][1], parsing.Rule,
                           "failed in ParserTree type for node Rule")
     self.assertTrue(res['the_rule'][1].name == "b",
                     "failed in name of rule 'b'")
Пример #23
0
    def test_26_set(self):
        class dummyList(parsing.Node):
            def __init__(self):
                self._ls = []

            def append(self, x):
                self._ls.append(x)

            def __getitem__(self, n):
                return self._ls[n]

        @meta.hook(parsing.Parser)
        def in_list(self, ls, ident):
            if type(ls) is parsing.Node:
                ls.set(dummyList())
            ls.append(self.value(ident))
            return True

        bnf = dsl.EBNF("""

            I = [ id ]

            list = [ [I : i #in_list(_, i) ]+ ]
        """)
        res = bnf.get_rules()
        self.assertTrue('list' in res)
        self.assertTrue('I' in res)
        dummyData = parsing.Parser("""
            a     b c   d        e   f
        """)
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        eval_res = dummyData.eval_rule('list')
        self.assertTrue(eval_res)
        self.assertTrue(eval_res[0] == "a")
        self.assertTrue(eval_res[1] == "b")
        self.assertTrue(eval_res[2] == "c")
        self.assertTrue(eval_res[3] == "d")
        self.assertTrue(eval_res[4] == "e")
        self.assertTrue(eval_res[5] == "f")
Пример #24
0
    def test_23_hookParams(self):
        @meta.hook(parsing.Parser)
        def my_hook_params(self, n, num, txt):
            self.test.assertIsInstance(n, parsing.Node)
            self.test.assertTrue(num == 123456)
            self.test.assertTrue(txt == "cool")
            return True

        bnf = dsl.EBNF("""
            the_rule = [ #my_hook_params(_, 123456, "cool") ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res)
        self.assertIsInstance(res['the_rule'], parsing.Hook)
        self.assertTrue(res['the_rule'].name == "my_hook_params")
        dummyData = parsing.Parser()
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        res = dummyData.eval_rule('the_rule')
        self.assertTrue(res)
Пример #25
0
    def test_21_hookOneParamNum(self):
        @meta.hook(parsing.Parser)
        def my_hook_num(self, num):
            self.test.assertEqual(num, 123456,
                                  'failed to receive 123456 in hook')
            self.test.assertTrue(num == 123456)
            return True

        bnf = dsl.EBNF("""
            the_rule = [ #my_hook_num(123456) ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res, "failed to fetch the rule name")
        self.assertIsInstance(res['the_rule'], parsing.Hook)
        self.assertTrue(res['the_rule'].name == "my_hook_num")
        dummyData = parsing.Parser()
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        res = dummyData.eval_rule('the_rule')
        self.assertTrue(res)
Пример #26
0
    def test_25_directive(self):
        class dummyDir(parsing.DirectiveWrapper):
            def begin(self, parser, a: int, b: int, c: int):
                parser.test.assertTrue(a == 1)
                parser.test.assertTrue(b == 2)
                parser.test.assertTrue(c == 3)
                # for workflow checking
                parser.workflow = 1
                return True

            def end(self, parser, a: int, b: int, c: int):
                parser.test.assertTrue(a == 1)
                parser.test.assertTrue(b == 2)
                parser.test.assertTrue(c == 3)
                # for workflow checking
                parser.test.assertTrue(parser.workflow == 2)
                return True

        @meta.hook(parsing.Parser)
        def my_hook(self):
            # for workflow checking
            self.test.assertTrue(self.workflow == 1)
            self.workflow = 2
            return True

        dsl.EBNF.set_directives({'toto.dummyDir': dummyDir})
        bnf = dsl.EBNF("""
            the_rule = [ @toto.dummyDir(1, 2, 3) test ]

            test = [ #my_hook Base.eof ]
        """)
        res = bnf.get_rules()
        self.assertTrue('the_rule' in res, "failed to fetch the rule name")
        dummyData = parsing.Parser()
        dummyData.set_rules(res)
        dummyData.test = self
        #with dummyData as s:
        res = dummyData.eval_rule('the_rule')
        self.assertTrue(res)
Пример #27
0
 def test_09_complexe(self):
     """
     Test default
     """
     bnf = dsl.EBNF("""
         the_rule = [ 'a'..'z' "tutu" 'a' | a b | z ]
     """)
     res = bnf.get_rules()
     self.assertTrue('the_rule' in res)
     self.assertIsInstance(res['the_rule'], parsing.Alt)
     self.assertIsInstance(res['the_rule'][0], parsing.Seq)
     self.assertIsInstance(res['the_rule'][0][0], parsing.Range)
     self.assertTrue(res['the_rule'][0][0].begin == 'a')
     self.assertTrue(res['the_rule'][0][0].end == 'z')
     self.assertIsInstance(res['the_rule'][0][1], parsing.Text)
     self.assertEqual(res['the_rule'][0][1].text, "tutu")
     self.assertIsInstance(res['the_rule'][0][2], parsing.Char)
     self.assertTrue(res['the_rule'][0][2].char == 'a')
     self.assertIsInstance(res['the_rule'][1], parsing.Seq)
     self.assertIsInstance(res['the_rule'][1][0], parsing.Rule)
     self.assertTrue(res['the_rule'][1][0].name == "a")
     self.assertTrue(res['the_rule'][1][1].name == "b")
     self.assertIsInstance(res['the_rule'][2], parsing.Rule)
     self.assertTrue(res['the_rule'][2].name == "z")