pub struct Parse<'c> {
pub smart: bool,
pub default_info_string: Option<String>,
pub relaxed_tasklist_matching: bool,
pub tasklist_in_table: bool,
pub relaxed_autolinks: bool,
pub ignore_setext: bool,
pub broken_link_callback: Option<Arc<dyn BrokenLinkCallback + 'c>>,
pub leave_footnote_definitions: bool,
pub escaped_char_spans: bool,
}Expand description
Options for parser functions.
Fields§
§smart: boolPunctuation (quotes, full-stops and hyphens) are converted into ‘smart’ punctuation.
let mut options = Options::default();
assert_eq!(markdown_to_html("'Hello,' \"world\" ...", &options),
"<p>'Hello,' "world" ...</p>\n");
options.parse.smart = true;
assert_eq!(markdown_to_html("'Hello,' \"world\" ...", &options),
"<p>‘Hello,’ “world” …</p>\n");default_info_string: Option<String>The default info string for fenced code blocks.
let mut options = Options::default();
assert_eq!(markdown_to_html("```\nfn hello();\n```\n", &options),
"<pre><code>fn hello();\n</code></pre>\n");
options.parse.default_info_string = Some("rust".into());
assert_eq!(markdown_to_html("```\nfn hello();\n```\n", &options),
"<pre><code class=\"language-rust\">fn hello();\n</code></pre>\n");relaxed_tasklist_matching: boolWhether or not a simple x or X is used for tasklist or any other symbol is allowed.
tasklist_in_table: boolWhether tasklist items can be parsed in table cells. At present, the tasklist item must be the only content in the cell. Both tables and tasklists much be enabled for this to work.
let mut options = Options::default();
options.extension.table = true;
options.extension.tasklist = true;
assert_eq!(markdown_to_html("| val |\n| - |\n| [ ] |\n", &options),
"<table>\n<thead>\n<tr>\n<th>val</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>[ ]</td>\n</tr>\n</tbody>\n</table>\n");
options.parse.tasklist_in_table = true;
assert_eq!(markdown_to_html("| val |\n| - |\n| [ ] |\n", &options),
"<table>\n<thead>\n<tr>\n<th>val</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>\n<input type=\"checkbox\" disabled=\"\" /> </td>\n</tr>\n</tbody>\n</table>\n");relaxed_autolinks: boolRelax parsing of autolinks, allow links to be detected inside brackets
and allow all url schemes. It is intended to allow a very specific type of autolink
detection, such as [this http://and.com that] or {http://foo.com}, on a best can basis.
let mut options = Options::default();
options.extension.autolink = true;
assert_eq!(markdown_to_html("[https://foo.com]", &options),
"<p>[https://foo.com]</p>\n");
options.parse.relaxed_autolinks = true;
assert_eq!(markdown_to_html("[https://foo.com]", &options),
"<p>[<a href=\"https://foo.com\">https://foo.com</a>]</p>\n");ignore_setext: boolIgnore setext headings in input.
let mut options = Options::default();
let input = "setext heading\n---";
assert_eq!(markdown_to_html(input, &options),
"<h2>setext heading</h2>\n");
options.parse.ignore_setext = true;
assert_eq!(markdown_to_html(input, &options),
"<p>setext heading</p>\n<hr />\n");broken_link_callback: Option<Arc<dyn BrokenLinkCallback + 'c>>In case the parser encounters any potential links that have a broken
reference (e.g [foo] when there is no [foo]: url entry at the
bottom) the provided callback will be called with the reference name,
both in normalized form and unmodified, and the returned pair will be
used as the link destination and title if not None.
let cb = |link_ref: BrokenLinkReference| match link_ref.normalized {
"foo" => Some(ResolvedReference {
url: "https://www.rust-lang.org/".to_string(),
title: "The Rust Language".to_string(),
}),
_ => None,
};
let mut options = Options::default();
options.parse.broken_link_callback = Some(Arc::new(cb));
let output = markdown_to_html(
"# Cool input!\nWow look at this cool [link][foo]. A [broken link] renders as text.",
&options,
);
assert_eq!(output,
"<h1>Cool input!</h1>\n<p>Wow look at this cool \
<a href=\"https://www.rust-lang.org/\" title=\"The Rust Language\">link</a>. \
A [broken link] renders as text.</p>\n");leave_footnote_definitions: boolLeave footnote definitions in place in the document tree, rather than reordering them to the end. This will also cause unreferenced footnote definitions to remain in the tree, rather than being removed.
Comrak’s default formatters expect this option to be turned off, so use with care if you use the default formatters.
let mut options = Options::default();
options.extension.footnotes = true;
let arena = Arena::new();
let input = concat!(
"Remember burning a CD?[^cd]\n",
"\n",
"[^cd]: In the Old Days, a 4x burner was considered good.\n",
"\n",
"[^dvd]: And DVD-RWs? Those were something else.\n",
"\n",
"Me neither.",
);
fn node_kinds<'a>(doc: Node<'a>) -> Vec<&'static str> {
doc.descendants().map(|n| n.data().value.xml_node_name()).collect()
}
let root = parse_document(&arena, input, &options);
assert_eq!(
node_kinds(root),
&["document", "paragraph", "text", "footnote_reference", "paragraph", "text",
"footnote_definition", "paragraph", "text"],
);
options.parse.leave_footnote_definitions = true;
let root = parse_document(&arena, input, &options);
assert_eq!(
node_kinds(root),
&["document", "paragraph", "text", "footnote_reference", "footnote_definition",
"paragraph", "text", "footnote_definition", "paragraph", "text", "paragraph", "text"],
);escaped_char_spans: boolLeave escaped characters in an Escaped node in the document tree.
let mut options = Options::default();
let arena = Arena::new();
let input = "Notify user \\@example";
fn node_kinds<'a>(doc: Node<'a>) -> Vec<&'static str> {
doc.descendants().map(|n| n.data().value.xml_node_name()).collect()
}
let root = parse_document(&arena, input, &options);
assert_eq!(
node_kinds(root),
&["document", "paragraph", "text"],
);
options.parse.escaped_char_spans = true;
let root = parse_document(&arena, input, &options);
assert_eq!(
node_kinds(root),
&["document", "paragraph", "text", "escaped", "text", "text"],
);Note that enabling the escaped_char_spans render option will cause
this option to be enabled.
Implementations§
Trait Implementations§
Source§impl<'c, 'arbitrary: 'c> Arbitrary<'arbitrary> for Parse<'c>
impl<'c, 'arbitrary: 'c> Arbitrary<'arbitrary> for Parse<'c>
Source§fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>
fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>
Self from the given unstructured data. Read moreSource§fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>
fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>
Self from the entirety of the given
unstructured data. Read moreSource§fn size_hint(depth: usize) -> (usize, Option<usize>)
fn size_hint(depth: usize) -> (usize, Option<usize>)
Unstructured this type
needs to construct itself. Read moreSource§fn try_size_hint(
depth: usize,
) -> Result<(usize, Option<usize>), MaxRecursionReached>
fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>
Unstructured this type
needs to construct itself. Read more