Struct Parse

Fields

smart: bool

Punctuation (quotes, full-stops and hyphens) are converted into 'smart' punctuation.

# use comrak::{markdown_to_html, Options};
let mut options = Options::default();
assert_eq!(markdown_to_html("'Hello,' \"world\" ...", &options),
           "<p>'Hello,' &quot;world&quot; ...</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.

# use comrak::{markdown_to_html, Options};
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: bool

Whether or not a simple x or X is used for tasklist or any other symbol is allowed.

tasklist_in_table: bool

Whether 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.

# use comrak::{markdown_to_html, Options};
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: bool

Relax 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.

# use comrak::{markdown_to_html, Options};
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: bool

Ignore setext headings in input.

# use comrak::{markdown_to_html, Options};
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.

# use std::{str, sync::Arc};
# use comrak::{markdown_to_html, options::BrokenLinkReference, Options, ResolvedReference};
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: bool

Leave 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.

# use comrak::{Arena, parse_document, Node, Options};
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: bool

Leave escaped characters in an Escaped node in the document tree.

# use comrak::{Arena, parse_document, Node, Options};
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.

sourcepos_chars: bool

When enabled, the [column][crate::nodes::LineColumn::column] values in [Sourcepos][crate::nodes::Sourcepos] are counted as Unicode characters (i.e. chars) rather than as UTF-8 bytes.

By default, column values follow cmark behaviour: each byte of a multi-byte UTF-8 character counts as a separate column. Enabling this option converts those byte-based columns to character-based columns after parsing, so that a 3-byte character such as 好 occupies only one column position instead of three.

# use comrak::{Arena, parse_document, Options};
let arena = Arena::new();
let mut options = Options::default();

// Default (byte-based): "好" spans columns 1-3
let root = parse_document(&arena, "好", &options);
let sp = root.first_child().unwrap().data().sourcepos;
assert_eq!(sp.start.column, 1);
assert_eq!(sp.end.column, 3);

// Char-based: "好" occupies only column 1
options.parse.sourcepos_chars = true;
let root = parse_document(&arena, "好", &options);
let sp = root.first_child().unwrap().data().sourcepos;
assert_eq!(sp.start.column, 1);
assert_eq!(sp.end.column, 1);