use pest::consumes_to;
use pest::parses_to;
use crate::pest_rst::{RstParser, Rule};
#[test]
fn plain() {
parses_to! {
parser: RstParser,
input: "line\n",
rule: Rule::paragraph,
tokens: [
paragraph(0, 4, [
str(0, 4)
])
]
};
}
#[test]
fn emph_only() {
parses_to! {
parser: RstParser,
input: "*emphasis*",
rule: Rule::emph_outer,
tokens: [
emph(1, 9, [str_nested(1, 9)])
]
};
}
#[test]
fn emph() {
parses_to! {
parser: RstParser,
input: "line *with markup*\n",
rule: Rule::paragraph,
tokens: [
paragraph(0, 18, [
str(0, 5),
emph(6, 17, [str_nested(6, 17)]),
])
]
};
}
#[test]
fn title() {
parses_to! {
parser: RstParser,
input: "\
Title
=====
",
rule: Rule::title,
tokens: [
title(0, 12, [ title_single(0, 12, [
line(0, 6, [ str(0, 5) ]),
adornments(6, 11),
]) ])
]
};
}
#[test]
fn title_overline() {
parses_to! {
parser: RstParser,
input: "\
-----
Title
-----
",
rule: Rule::title,
tokens: [
title(0, 17, [ title_double(0, 17, [
adornments(0, 5),
line(6, 12, [ str(6, 11) ]),
]) ])
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn two_targets() {
parses_to! {
parser: RstParser,
input: "\
.. _a: http://example.com
.. _`b_`: https://example.org
",
rule: Rule::document,
tokens: [
target(0, 26, [
target_name_uq(4, 5),
link_target(7, 25),
]),
target(26, 56, [
target_name_qu(31, 33),
link_target(36, 55),
]),
]
};
}
#[test]
fn inline_code_literal_with_underscore() {
parses_to! {
parser: RstParser,
input: "``NAME_WITH_UNDERSCORE``",
rule: Rule::inline,
tokens: [
literal(2, 22),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn admonitions() {
parses_to! {
parser: RstParser,
input: "\
.. note::
Just next line
.. admonition:: In line title
Next line
.. danger:: Just this line
",
rule: Rule::document,
tokens: [
admonition_gen(0, 27, [
admonition_type(3, 7),
paragraph(13, 27, [ str(13, 27) ]),
]),
admonition(28, 71, [
line(43, 58, [ str(43, 57) ]),
paragraph(62, 71, [ str(62, 71) ]),
]),
admonition_gen(73, 100, [
admonition_type(76, 82),
line(84, 100, [ str(84, 99) ]),
]),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn literal_block() {
parses_to! {
parser: RstParser,
input: "\
::
print('x')
# second line
The end
",
rule: Rule::document,
tokens: [
literal_block(0, 36, [
literal_lines(7, 36, [
literal_line(7, 18),
literal_line_blank(18, 19),
literal_line(22, 36),
]),
]),
paragraph(37, 44, [ str(37, 44) ]),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn code_directive() {
parses_to! {
parser: RstParser,
input: "\
.. code::
Single line
.. code-block:: python
print('x')
# second line
The end
",
rule: Rule::document,
tokens: [
code_directive(0, 26, [
literal_lines(14, 26, [ literal_line(14, 26) ]),
]),
code_directive(27, 83, [
source(43, 49),
literal_lines(54, 83, [
literal_line(54, 65),
literal_line_blank(65, 66),
literal_line(69, 83),
]),
]),
paragraph(84, 91, [ str(84, 91) ]),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn raw() {
parses_to! {
parser: RstParser,
input: "\
.. raw:: html
hello <span>world</span>
.. raw:: html
hello <pre>world
parse</pre> this
The end
",
rule: Rule::document,
tokens: [
raw_directive(0, 43, [
raw_output_format(9, 13),
raw_block(18, 43, [
raw_line(18, 43),
]),
]),
raw_directive(44, 100, [
raw_output_format(53, 57),
raw_block(62, 100, [
raw_line(62, 79),
raw_line_blank(79, 80),
raw_line(83, 100),
]),
]),
paragraph(101, 108, [ str(101, 108) ]),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn comments() {
parses_to! {
parser: RstParser,
input: "\
.. This is a comment
..
This as well.
..
_so: is this!
..
[and] this!
..
this:: too!
..
|even| this:: !
.. With a title..
and a blank line...
followed by a non-blank line
and another one.
..
.. Comments can also be
run-in like this
",
rule: Rule::document,
tokens: [
block_comment(0, 22, [
comment_line(3, 21),
]),
block_comment(22, 43, [
comment_line(28, 42),
]),
block_comment(43, 63, [
comment_line(49, 63),
]),
block_comment(63, 81, [
comment_line(69, 81),
]),
block_comment(81, 99, [
comment_line(87, 99),
]),
block_comment(99, 121, [
comment_line(105, 121),
]),
block_comment(121, 216, [
comment_line(124, 139),
comment_line_blank(139, 140),
comment_line(143, 163),
comment_line(166, 195),
comment_line_blank(195, 196),
comment_line(199, 216),
]),
block_comment(216, 219),
block_comment(219, 263, [
comment_line(222, 243),
comment_line(246, 263),
]),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn substitutions() {
parses_to! {
parser: RstParser,
input: "\
A |subst| in-line
.. |subst| replace:: substitution
.. |subst2| replace:: it can also
be hanging
",
rule: Rule::document,
tokens: [
paragraph(0, 17, [
str(0, 2),
substitution_name(3, 8),
str(9, 17),
]),
substitution_def(19, 52, [
substitution_name(23, 28),
replace(30, 52, [ paragraph(40, 52, [str(40, 52)]) ]),
]),
substitution_def(53, 101, [
substitution_name(57, 63),
replace(65, 101, [ paragraph(75, 101, [
str(75, 86), ws_newline(86, 87),
str(88, 100),
]) ]),
]),
]
};
}
#[test]
fn substitution_in_literal() {
parses_to! {
parser: RstParser,
input: "Just ``|code|``, really ``*code* |only|``",
rule: Rule::document,
tokens: [
paragraph(0, 41, [
str(0, 5),
literal(7, 13),
str(15, 24),
literal(26, 39),
]),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn substitution_image() {
parses_to! {
parser: RstParser,
input: "\
.. |subst| image:: thing.png
:target: foo.html
",
rule: Rule::document,
tokens: [
substitution_def(0, 50, [
substitution_name(4, 9),
image(11, 50, [
line(18, 29, [ str(18, 28) ]),
image_option(32, 50, [
image_opt_name(33, 39),
line(40, 50, [ str(40, 49) ]),
]),
]),
]),
]
};
}
#[allow(clippy::cognitive_complexity)]
#[test]
fn nested_lists() {
parses_to! {
parser: RstParser,
input: "\
paragraph
- item 1
- item 2
more text
more text 2
more text 3
- nested item 1
- nested item 2
- nested item 3
",
rule: Rule::document,
tokens: [
paragraph(0, 9, [ str(0, 9) ]),
bullet_list(11, 131, [
bullet_item(11, 21, [
line(14, 21, [ str(14, 20) ]),
]),
bullet_item(21, 131, [
line(24, 31, [ str(24, 30) ]),
paragraph(34, 74, [
str(34, 43), ws_newline(43, 44),
str(47, 58), ws_newline(58, 59),
str(62, 73),
]),
bullet_list(77, 131, [
bullet_item( 77, 93, [ line( 79, 93, [str( 79, 92)]) ]),
bullet_item( 96, 112, [ line( 98, 112, [str( 98, 111)]) ]),
bullet_item(115, 131, [ line(117, 131, [str(117, 130)]) ]),
]),
]),
]),
]
}
}