test_ebnf.py 11.7 KB
Newer Older
1 2
#!/usr/bin/python3

3
"""test_ebnf.py - tests of the ebnf module of DHParser 
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
                             

Author: Eckhart Arnold <arnold@badw.de>

Copyright 2017 Bavarian Academy of Sciences and Humanities

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

23
from functools import partial
24 25 26
import os
import sys
sys.path.append(os.path.abspath('../../'))
27
from DHParser.parsers import full_compilation, Retrieve, WHITESPACE_KEYWORD, nil_scanner
28
from DHParser.ebnf import EBNFGrammar, EBNFTransform, EBNFCompiler
29
from DHParser.dsl import compileEBNF, compileDSL
30 31 32 33 34


WRITE_LOGS = True


35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
class TestDirectives:
    mini_language = """
        expression =  term  { ("+" | "-") term }
        term       =  factor  { ("*" | "/") factor }
        factor     =  constant | "("  expression  ")"
        constant   =  digit { digit } [ //~ ]
        digit      = /0/ | /1/ | /2/ | /3/ | /4/ | /5/ | /6/ | /7/ | /8/ | /9/ 
        """

    def test_whitespace_linefeed(self):
        lang = "@ whitespace = linefeed\n" + self.mini_language
        MinilangParser = compileEBNF(lang)
        parser = MinilangParser()
        assert parser
        syntax_tree = parser.parse("3 + 4 * 12")
50
        # parser.log_parsing_history("WSP")
51 52
        assert not syntax_tree.collect_errors()
        syntax_tree = parser.parse("3 + 4 \n * 12")
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
        # parser.log_parsing_history("WSPLF")
        assert not syntax_tree.collect_errors()
        syntax_tree = parser.parse("3 + 4 \n \n * 12")
        assert syntax_tree.collect_errors()
        syntax_tree = parser.parse("3 + 4 \n\n * 12")
        assert syntax_tree.collect_errors()

    def test_whitespace_vertical(self):
        lang = "@ whitespace = vertical\n" + self.mini_language
        parser = compileEBNF(lang)()
        assert parser
        syntax_tree = parser.parse("3 + 4 * 12")
        assert not syntax_tree.collect_errors()
        syntax_tree = parser.parse("3 + 4 \n * 12")
        assert not syntax_tree.collect_errors()
        syntax_tree = parser.parse("3 + 4 \n \n * 12")
        assert not syntax_tree.collect_errors()
        syntax_tree = parser.parse("3 + 4 \n\n * 12")
71 72
        assert not syntax_tree.collect_errors()

73 74
    def test_whitespace_horizontal(self):
        lang = "@ whitespace = horizontal\n" + self.mini_language
75 76 77 78 79 80 81
        parser = compileEBNF(lang)()
        assert parser
        syntax_tree = parser.parse("3 + 4 * 12")
        assert not syntax_tree.collect_errors()
        syntax_tree = parser.parse("3 + 4 \n * 12")
        assert syntax_tree.collect_errors()

82

83
class TestEBNFParser:
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
    test_json = {
        "list_": {
            "match": {
                1: "hund",
                2: "hund, katze,maus",
                3: "hund , katze"
            },
            "fail": {
                1: "123",
                2: '"literal"',
                3: "/regexp/"
            }
        }
    }

di68kap's avatar
di68kap committed
99

100 101 102 103 104 105 106 107 108 109 110 111 112 113
    def setup(self):
        self.EBNF = EBNFGrammar()

    def test_literal(self):
        snippet = '"literal" '
        result = self.EBNF.parse(snippet, 'literal')
        assert not result.error_flag
        assert str(result) == snippet
        assert result.find(lambda node: str(node) == WHITESPACE_KEYWORD)

        result = self.EBNF.parse(' "literal"', 'literal')
        assert result.error_flag  # literals catch following, but not leading whitespace


di68kap's avatar
di68kap committed
114 115


116 117 118 119
class TestPopRetrieve:
    mini_language = """
        document       = { text | codeblock }
        codeblock      = delimiter { text | (!:delimiter delimiter_sign) } ::delimiter
120
        delimiter      = delimiter_sign  # never use delimiter between capture and retrieve!!!
121 122 123
        delimiter_sign = /`+/
        text           = /[^`]+/ 
        """
124
    mini_lang2 = """
125
        @retrieve_counterpart = braces
126
        document       = { text | codeblock }
127 128 129
        codeblock      = braces { text | opening_braces | (!:braces closing_braces) } ::braces
        braces         = opening_braces
        opening_braces = /\{+/
130
        closing_braces = /\}+/
131
        text           = /[^{}]+/
132
        """
133 134 135

    def setup(self):
        self.minilang_parser = compileEBNF(self.mini_language)()
136
        self.minilang_parser2 = compileEBNF(self.mini_lang2)()
137

138 139 140 141 142 143 144 145
    @staticmethod
    def opening_delimiter(node, name):
        return node.tag_name == name and not isinstance(node.parser, Retrieve)

    @staticmethod
    def closing_delimiter(node):
        return isinstance(node.parser, Retrieve)

146 147
    def test_compile_mini_language(self):
        assert self.minilang_parser
148
        assert self.minilang_parser2
149 150 151 152 153

    def test_single_line(self):
        teststr = "Anfang ```code block `` <- keine Ende-Zeichen ! ``` Ende"
        syntax_tree = self.minilang_parser.parse(teststr)
        assert not syntax_tree.collect_errors()
154 155
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="delimiter"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
156
        assert delim == pop
157 158 159 160 161 162 163 164 165 166 167 168 169 170
        if WRITE_LOGS:
            syntax_tree.log("test_PopRetrieve_single_line", '.cst')

    def test_multi_line(self):
        teststr = """
            Anfang ```code block `` <- keine Ende-Zeichen ! ``` Ebde

            Absatz ohne ``` codeblock, aber
            das stellt sich erst am Ende herause...

            Mehrzeliger ```code block
            """
        syntax_tree = self.minilang_parser.parse(teststr)
        assert not syntax_tree.collect_errors()
171 172
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="delimiter"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
173
        assert delim == pop
174 175
        if WRITE_LOGS:
            syntax_tree.log("test_PopRetrieve_multi_line", '.cst')
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202

    def test_single_line_complement(self):
        teststr = "Anfang {{{code block }} <- keine Ende-Zeichen ! }}} Ende"
        syntax_tree = self.minilang_parser2.parse(teststr)
        assert not syntax_tree.collect_errors()
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="braces"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
        assert len(delim) == len(pop) and delim != pop
        if WRITE_LOGS:
            syntax_tree.log("test_PopRetrieve_single_line", '.cst')

    def test_multi_line_complement(self):
        teststr = """
            Anfang {{{code block {{ <- keine Ende-Zeichen ! }}} Ende

            Absatz ohne {{{ codeblock, aber
            das stellt sich erst am Ende heraus...

            Mehrzeliger }}}code block
            """
        syntax_tree = self.minilang_parser2.parse(teststr)
        assert not syntax_tree.collect_errors()
        delim = str(next(syntax_tree.find(partial(self.opening_delimiter, name="braces"))))
        pop = str(next(syntax_tree.find(self.closing_delimiter)))
        assert len(delim) == len(pop) and delim != pop
        if WRITE_LOGS:
            syntax_tree.log("test_PopRetrieve_multi_line", '.cst')
203 204


205 206 207 208 209
class TestSemanticValidation:
    def check(self, minilang, bool_filter=lambda x: x):
        grammar = EBNFGrammar()
        st = grammar.parse(minilang)
        assert not st.collect_errors()
210
        EBNFTransform(st)
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
        assert bool_filter(st.collect_errors())

    def test_illegal_nesting(self):
        self.check('impossible = { [ "an optional requirement" ] }')

    def test_illegal_nesting_option_required(self):
        self.check('impossible = [ §"an optional requirement" ]')

    def test_illegal_nesting_oneormore_option(self):
        self.check('impossible = { [ "no use"] }+')

    def test_legal_nesting(self):
        self.check('possible = { [ "+" ] "1" }', lambda x: not x)


class TestCompilerErrors:
    def test_error_propagation(self):
228
        ebnf = "@ literalws = wrongvalue  # testing error propagation\n"
229
        result, messages, st = full_compilation(ebnf, None, EBNFGrammar(), EBNFTransform,
230 231 232 233
                                                EBNFCompiler('ErrorPropagationTest'))
        assert messages


234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
class TestSelfHosting:
    def test_self(self):
        grammar = r"""
            # EBNF-Grammar in EBNF
            
            @ comment    =  /#.*(?:\n|$)/                    # comments start with '#' and eat all chars up to and including '\n'
            @ whitespace =  /\s*/                            # whitespace includes linefeed
            @ literalws  =  right                            # trailing whitespace of literals will be ignored tacitly
            
            syntax     =  [~//] { definition | directive } §EOF
            definition =  symbol §"=" expression
            directive  =  "@" §symbol §"=" ( regexp | literal | list_ )
            
            expression =  term { "|" term }
            term       =  { factor }+
            factor     =  [flowmarker] [retrieveop] symbol !"="   # negative lookahead to be sure it's not a definition
                        | [flowmarker] literal
                        | [flowmarker] regexp
                        | [flowmarker] group
                        | [flowmarker] regexchain
                        | [flowmarker] oneormore
                        | repetition
                        | option
            
            flowmarker =  "!"  | "&"  | "§" |                # '!' negative lookahead, '&' positive lookahead, '§' required
                          "-!" | "-&"                        # '-' negative lookbehind, '-&' positive lookbehind
            retrieveop =  "::" | ":"                         # '::' pop, ':' retrieve
            
            group      =  "(" expression §")"
            regexchain =  ">" expression §"<"                # compiles "expression" into a singular regular expression
            oneormore  =  "{" expression "}+"
            repetition =  "{" expression §"}"
            option     =  "[" expression §"]"
            
            link       = regexp | symbol | literal           # semantic restriction: symbol must evaluate to a regexp or chain
            
            symbol     =  /(?!\d)\w+/~                       # e.g. expression, factor, parameter_list
            literal    =  /"(?:[^"]|\\")*?"/~                # e.g. "(", '+', 'while'
                        | /'(?:[^']|\\')*?'/~                # whitespace following literals will be ignored tacitly.
            regexp     =  /~?\/(?:[^\/]|(?<=\\)\/)*\/~?/~    # e.g. /\w+/, ~/#.*(?:\n|$)/~
                                                             # '~' is a whitespace-marker, if present leading or trailing
                                                             # whitespace of a regular expression will be ignored tacitly.
            list_      =  /\w+/~ { "," /\w+/~ }              # comma separated list of symbols, e.g. BEGIN_LIST, END_LIST,
                                                             # BEGIN_QUOTE, END_QUOTE ; see CommonMark/markdown.py for an exmaple
            EOF =  !/./        
            """
        compiler_name = "EBNF"
        compiler = EBNFCompiler(compiler_name, grammar)
        parser = EBNFGrammar()
        result, errors, syntax_tree = full_compilation(grammar, None, parser,
                                                       EBNFTransform, compiler)
        assert not errors, str(errors)
        # compile the grammar again using the result of the previous
        # compilation as parser
        compileDSL(grammar, nil_scanner, result, EBNFTransform, compiler)



292
if __name__ == "__main__":
293
    from run import runner
294
    runner("", globals())