asciidoc-parser 0.15.2

Parser for AsciiDoc format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::{blocks::Block, tests::prelude::*};

track_file!("docs/modules/text/pages/monospace.adoc");

non_normative!(
    r#"
= Monospace

In AsciiDoc, a span of text enclosed in a single pair of backticks (`{backtick}`) is displayed using a fixed-width (i.e., monospaced) font.
Monospace text formatting is typically used to represent text shown in computer terminals or code editors (often referred to as a codespan).

The monospace presentation of text maps to the formatted text type known as *monospaced* in the AsciiDoc language.

"#
);

#[test]
fn constrained() {
    verifies!(
        r#"
== Constrained

Here's an example:

.Constrained monospace syntax
[#ex-constrain]
----
include::example$text.adoc[tag=mono]
----

The result of <<ex-constrain>> is rendered below.

====
include::example$text.adoc[tag=mono]
====

"#
    );

    let doc = Parser::default().parse(
        "\"`Wait!`\" Indigo plucked a small vial from her desk's top drawer and held it toward us.\nThe vial's label read: `E=mc^2^`; the `E` represents _energy_,\nbut also pure _genius!_",
    );

    let mut blocks = doc.nested_blocks();

    let block1 = blocks.next().unwrap();
    let Block::Simple(sb1) = block1 else {
        panic!("Unexpected block type: {block1:?}");
    };

    assert_eq!(
        sb1.content().rendered(),
        "&#8220;Wait!&#8221; Indigo plucked a small vial from her desk&#8217;s top drawer and held it toward us.\nThe vial&#8217;s label read: <code>E=mc<sup>2</sup></code>; the <code>E</code> represents <em>energy</em>,\nbut also pure <em>genius!</em>"
    );

    assert!(blocks.next().is_none());
}

#[test]
fn unconstrained() {
    verifies!(
        r#"
== Unconstrained

As with other types of text formatting, if the text is bounded by word characters on either side, it must be enclosed in a double pair of backtick characters (`{backtick}{backtick}`) in order for the formatting to be applied.

Here's an example:

----
The command will re``link`` all packages.
----

"#
    );

    let doc = Parser::default().parse("The command will re``link`` all packages.");

    let mut blocks = doc.nested_blocks();

    let block1 = blocks.next().unwrap();
    let Block::Simple(sb1) = block1 else {
        panic!("Unexpected block type: {block1:?}");
    };

    assert_eq!(
        sb1.content().rendered(),
        "The command will re<code>link</code> all packages."
    );

    assert!(blocks.next().is_none());
}

#[test]
fn mixed_formatting() {
    verifies!(
        r#"
== Mixed Formatting

Monospaced text can also be formatted in bold or italic or both, as long as the markup pairs are entered in the right order.
The monospace markup must be the outermost formatting mark, then the bold marks, then the italic marks.

.Order of inline formatting syntax
[#ex-mix]
----
`*_monospaced bold italic_*`
----

The result of <<ex-mix>> is rendered below.

====
`*_monospaced bold italic_*`
====

"#
    );

    let doc = Parser::default().parse("`*_monospaced bold italic_*`");

    let mut blocks = doc.nested_blocks();

    let block1 = blocks.next().unwrap();
    let Block::Simple(sb1) = block1 else {
        panic!("Unexpected block type: {block1:?}");
    };

    assert_eq!(
        sb1.content().rendered(),
        "<code><strong><em>monospaced bold italic</em></strong></code>"
    );

    assert!(blocks.next().is_none());
}

non_normative!(
    r#"
== Literal Monospace

To learn how to make monospace text that's not otherwise formatted, see xref:literal-monospace.adoc[].
"#
);