Example #1
0
def test_attributes_with_variables():
    p = init_parser(
        dedent(
            """
            :attrs:value1,someattr1=somevalue1,someattr2=somevalue2

            [{attrs}]
            This is text
            """
        )
    )
    p.parse()

    assert listasdict(p.nodes) == [
        {
            "type": "paragraph",
            "args": ["value1"],
            "kwargs": {"someattr1": "somevalue1", "someattr2": "somevalue2"},
            "content": {
                "type": "sentence",
                "content": [
                    {
                        "type": "text",
                        "value": "This is text",
                    }
                ],
            },
        },
    ]
Example #2
0
def test_parse_paragraphs_starting_with_a_macro():
    p = init_parser("[link](http://some.where,text) is the link I want")
    p.parse()

    assert listasdict(p.nodes) == [
        {
            "type": "paragraph",
            "args": [],
            "kwargs": {},
            "content": {
                "type": "sentence",
                "content": [
                    {
                        "type": "link",
                        "text": "text",
                        "target": "http://some.where",
                    },
                    {
                        "type": "text",
                        "value": " is the link I want",
                    },
                ],
            },
        },
    ]
Example #3
0
File: test_toc.py Project: xrmx/mau
def test_create_toc_ignore_headers(header_anchor_mock):
    header_anchor_mock.side_effect = lambda text, level: f"{text}-XXXXXX"

    p = init_parser(
        dedent("""
            = Header 1
            ==! Header 1.1
            ==! Header 1.2
            = Header 2
            ==! Header 2.1
            ===! Header 2.1.1
            """))
    p.parse()

    assert listasdict(p.toc) == [
        {
            "type": "toc_entry",
            "level": 1,
            "text": "Header 1",
            "anchor": "Header 1-XXXXXX",
            "children": [],
        },
        {
            "type": "toc_entry",
            "level": 1,
            "text": "Header 2",
            "anchor": "Header 2-XXXXXX",
            "children": [],
        },
    ]
Example #4
0
def test_curly_braces_in_escaped_verbatim():
    p = init_parser(r"This is \`{attr}\`", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is \\`5\\`\n",
    }]
Example #5
0
def test_plain_text():
    p = init_parser("This is text", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is text\n",
    }]
Example #6
0
def test_escape_backtick():
    p = init_parser(r"This is `\``")
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is `\``\n",
    }]
Example #7
0
def test_replace_variable():
    p = init_parser("This is number {attr}", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is number 5\n",
    }]
Example #8
0
def test_replace_variable_with_namespace():
    p = init_parser("This is number {config.attr}", {"config": {"attr": "5"}})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is number 5\n",
    }]
Example #9
0
def test_replace_boolean():
    p = init_parser("This flag is {flag}", {"flag": True})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This flag is True\n",
    }]
Example #10
0
def test_open_verbatim():
    p = init_parser("This is `{attr}", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is `5\n",
    }]
Example #11
0
def test_escape_curly_braces():
    p = init_parser(r"This is \{attr\}", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is {attr}\n",
    }]
Example #12
0
def test_open_curly():
    p = init_parser("This is {attr", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is {attr\n",
    }]
Example #13
0
def test_escape_curly_braces_in_verbatim():
    p = init_parser(r"This is `\{attr\}`", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This is `\\{attr\\}`\n",
    }]
Example #14
0
def test_escape_other_chars():
    p = init_parser(r"This \_is\_ \text", {"attr": "5"})
    p.parse()

    assert listasdict(p.nodes) == [{
        "type": "text",
        "value": "This \\_is\\_ \\text\n",
    }]
Example #15
0
def test_parse_variable_definition_value_can_be_any_text():
    p = init_parser(":attr:[footnote](http://some.domain/path)")
    p.parse()

    assert listasdict(p.nodes) == []
    assert p.variables == {
        "mau": {},
        "attr": "[footnote](http://some.domain/path)"
    }
Example #16
0
def test_command_without_arguments():
    p = init_parser("::somecommand:")
    p.parse()

    assert listasdict(p.nodes) == [
        {
            "type": "command",
            "name": "somecommand",
            "kwargs": {},
        },
    ]
Example #17
0
def test_footnote_ref():
    p = init_parser(
        dedent("""
            This is a sentence[footnote](with a note)
            """))

    p.parse()
    ast = listasdict(p.nodes)
    result = visitlist(ast, footnotes=p.footnotes)

    assert result == ["This is a sentence[^footnote1]\n"]
Example #18
0
def test_parse_multi_line_comments():
    p = init_parser(
        dedent("""
            ////
            This is a
            multiline
            comment
            ////
            """))
    p.parse()

    assert listasdict(p.nodes) == []
Example #19
0
def test_command():
    p = init_parser("::somecommand:arg1, arg2, name1=value1, name2=value2")
    p.parse()

    assert listasdict(p.nodes) == [
        {
            "type": "command",
            "name": "somecommand",
            "args": ["arg1", "arg2"],
            "kwargs": {"name1": "value1", "name2": "value2"},
        },
    ]
Example #20
0
def test_footnote():
    p = init_parser(
        dedent("""
            This is a sentence[footnote](with a note)
            """))

    p.parse()
    ast = listasdict(p.nodes)

    result = visitlist(ast, footnotes=[i.asdict() for i in p.footnotes])

    assert result == ["This is a sentencefootnote:[with a note]\n"]
Example #21
0
def test_parse_macro_footnote_with_other_text_around(footnote_anchors_mock):
    footnote_anchors_mock.return_value = ("refXYZ", "defXYZ")

    source = "text[footnote](Some text) other text"

    expected = [{
        "type":
        "sentence",
        "content": [
            {
                "type": "text",
                "value": "text"
            },
            {
                "type": "footnote_ref",
                "number": 1,
                "refanchor": "refXYZ",
                "defanchor": "defXYZ",
            },
            {
                "type": "text",
                "value": " other text"
            },
        ],
    }]

    p = _test(source, expected)

    assert listasdict(p.footnotes) == [{
        "type":
        "footnote_def",
        "number":
        1,
        "refanchor":
        "refXYZ",
        "defanchor":
        "defXYZ",
        "content": [{
            "type": "sentence",
            "content": [
                {
                    "type": "text",
                    "value": "Some text"
                },
            ],
        }],
    }]
Example #22
0
def test_parse_macro_footnote_includes_round_brakets(footnote_anchors_mock):
    footnote_anchors_mock.return_value = ("refXYZ", "defXYZ")

    source = r'text[footnote]("Some code(\)") other text'

    expected = [{
        "type":
        "sentence",
        "content": [
            {
                "type": "text",
                "value": "text"
            },
            {
                "type": "footnote_ref",
                "number": 1,
                "refanchor": "refXYZ",
                "defanchor": "defXYZ",
            },
            {
                "type": "text",
                "value": " other text"
            },
        ],
    }]

    p = _test(source, expected)

    assert listasdict(p.footnotes) == [{
        "type":
        "footnote_def",
        "number":
        1,
        "refanchor":
        "refXYZ",
        "defanchor":
        "defXYZ",
        "content": [{
            "type": "sentence",
            "content": [
                {
                    "type": "text",
                    "value": '"Some code()"'
                },
            ],
        }],
    }]
Example #23
0
File: test_toc.py Project: xrmx/mau
def test_parse_header_not_in_toc(header_anchor_mock):
    header_anchor_mock.return_value = "XXXXXX"

    source = """
    =! Title of the section
    """

    expected = [{
        "type": "header",
        "kwargs": {},
        "value": "Title of the section",
        "level": 1,
        "anchor": "XXXXXX",
    }]

    p = _test(source, expected)

    assert listasdict(p.toc) == []
Example #24
0
def test_variables_can_contain_markers():
    p = init_parser(
        dedent("""
            A very {bold} text
            Some code: {dictdef}
            """),
        {
            "bold": "*bold*",
            "dictdef": "`adict = {'a':5}`"
        },
    )
    p.parse()

    assert listasdict(p.nodes) == [{
        "type":
        "text",
        "value":
        "A very *bold* text\nSome code: `adict = {'a':5}`\n",
    }]
Example #25
0
def test_parse_macro_footnote_can_start_with_different_number(
        footnote_anchors_mock):
    footnote_anchors_mock.return_value = ("refXYZ", "defXYZ")

    p = init_parser(
        "[footnote](Some text _and style_ and *more style* here)",
        footnotes_start_with=6,
    )
    result = p.parse()

    assert listasdict(p.nodes) == [{
        "type":
        "sentence",
        "content": [{
            "type": "footnote_ref",
            "number": 6,
            "refanchor": "refXYZ",
            "defanchor": "defXYZ",
        }],
    }]
Example #26
0
def test_parse_paragraphs_is_a_macro_only():
    p = init_parser("[link](http://some.where,text)")
    p.parse()

    assert listasdict(p.nodes) == [
        {
            "type": "paragraph",
            "args": [],
            "kwargs": {},
            "content": {
                "type": "sentence",
                "content": [
                    {
                        "type": "link",
                        "text": "text",
                        "target": "http://some.where",
                    },
                ],
            },
        },
    ]
Example #27
0
def test_macro_footnote(footnote_anchors_mock):
    footnote_anchors_mock.return_value = ("refXYZ", "defXYZ")

    source = "[footnote](Some text _and style_ and *more style* here)"

    expected = [{
        "type":
        "sentence",
        "content": [{
            "type":
            "footnote_ref",
            "number":
            1,
            "refanchor":
            "refXYZ",
            "defanchor":
            "defXYZ",
            "content": [{
                "type":
                "sentence",
                "content": [
                    {
                        "type": "text",
                        "value": "Some text "
                    },
                    {
                        "type": "style",
                        "value": "underscore",
                        "content": {
                            "type": "sentence",
                            "content": [
                                {
                                    "type": "text",
                                    "value": "and style"
                                },
                            ],
                        },
                    },
                    {
                        "type": "text",
                        "value": " and "
                    },
                    {
                        "type": "style",
                        "value": "star",
                        "content": {
                            "type": "sentence",
                            "content": [
                                {
                                    "type": "text",
                                    "value": "more style"
                                },
                            ],
                        },
                    },
                    {
                        "type": "text",
                        "value": " here"
                    },
                ],
            }],
        }],
    }]

    p = _test(source, expected)

    assert listasdict(p.footnote_defs) == [{
        "type":
        "footnote_def",
        "number":
        1,
        "refanchor":
        "refXYZ",
        "defanchor":
        "defXYZ",
        "content": [{
            "type":
            "sentence",
            "content": [
                {
                    "type": "text",
                    "value": "Some text "
                },
                {
                    "type": "style",
                    "value": "underscore",
                    "content": {
                        "type": "sentence",
                        "content": [
                            {
                                "type": "text",
                                "value": "and style"
                            },
                        ],
                    },
                },
                {
                    "type": "text",
                    "value": " and "
                },
                {
                    "type": "style",
                    "value": "star",
                    "content": {
                        "type": "sentence",
                        "content": [
                            {
                                "type": "text",
                                "value": "more style"
                            },
                        ],
                    },
                },
                {
                    "type": "text",
                    "value": " here"
                },
            ],
        }],
    }]
Example #28
0
def test_parse_variable_definition_with_namespace():
    p = init_parser(":meta.attr:42")
    p.parse()

    assert listasdict(p.nodes) == []
    assert p.variables == {"meta": {"attr": "42"}}
Example #29
0
def test_parse_variable_definition_without_value_is_loaded_as_boolean():
    p = init_parser(":attr:")
    p.parse()

    assert listasdict(p.nodes) == []
    assert p.variables == {"attr": True}
Example #30
0
def test_parse_macro_footnote_commas_mau_v2(footnote_anchors_mock, ):
    footnote_anchors_mock.return_value = ("refXYZ", "defXYZ")

    source = r'text[footnote]("Some text, that should not, be split") other text'

    _test = parser_test_factory(TextParser)

    expected = [{
        "type":
        "sentence",
        "content": [
            {
                "type": "text",
                "value": "text"
            },
            {
                "type":
                "footnote_ref",
                "number":
                1,
                "refanchor":
                "refXYZ",
                "defanchor":
                "defXYZ",
                "content": [{
                    "type":
                    "sentence",
                    "content": [
                        {
                            "type": "text",
                            "value": "Some text, that should not, be split",
                        },
                    ],
                }],
            },
            {
                "type": "text",
                "value": " other text"
            },
        ],
    }]

    p = _test(source, expected)

    assert listasdict(p.footnote_defs) == [{
        "type":
        "footnote_def",
        "number":
        1,
        "refanchor":
        "refXYZ",
        "defanchor":
        "defXYZ",
        "content": [{
            "type":
            "sentence",
            "content": [
                {
                    "type": "text",
                    "value": "Some text, that should not, be split",
                },
            ],
        }],
    }]