Struct Parse 

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,
    pub sourcepos_chars: bool,
}

Options for parser functions.

Fields

smart: bool

Punctuation (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,' &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.

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.

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.

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.

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

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.

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 values in 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.

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);

Trait Implementations

impl<'c> Clone for Parse<'c>

fn clone(&self) -> Parse<'c>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'c> Debug for Parse<'c>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'c> Default for Parse<'c>

fn default() -> Parse<'c>

Returns the “default value” for a type.