Struct comrak::ExtensionOptionsBuilder

pub struct ExtensionOptionsBuilder { /* private fields */ }

Builder for ExtensionOptions.

Implementations

impl ExtensionOptionsBuilder

pub fn strikethrough(&mut self, value: bool) -> &mut Self

Enables the strikethrough extension from the GFM spec.

let mut options = Options::default();
options.extension.strikethrough = true;
assert_eq!(markdown_to_html("Hello ~world~ there.\n", &options),
           "<p>Hello <del>world</del> there.</p>\n");

pub fn tagfilter(&mut self, value: bool) -> &mut Self

Enables the tagfilter extension from the GFM spec.

let mut options = Options::default();
options.extension.tagfilter = true;
options.render.unsafe_ = true;
assert_eq!(markdown_to_html("Hello <xmp>.\n\n<xmp>", &options),
           "<p>Hello &lt;xmp>.</p>\n&lt;xmp>\n");

pub fn table(&mut self, value: bool) -> &mut Self

Enables the table extension from the GFM spec.

let mut options = Options::default();
options.extension.table = true;
assert_eq!(markdown_to_html("| a | b |\n|---|---|\n| c | d |\n", &options),
           "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n\
            <tbody>\n<tr>\n<td>c</td>\n<td>d</td>\n</tr>\n</tbody>\n</table>\n");

pub fn autolink(&mut self, value: bool) -> &mut Self

Enables the autolink extension from the GFM spec.

let mut options = Options::default();
options.extension.autolink = true;
assert_eq!(markdown_to_html("Hello www.github.com.\n", &options),
           "<p>Hello <a href=\"http://www.github.com\">www.github.com</a>.</p>\n");

pub fn tasklist(&mut self, value: bool) -> &mut Self

Enables the task list items extension from the GFM spec.

Note that the spec does not define the precise output, so only the bare essentials are rendered.

let mut options = Options::default();
options.extension.tasklist = true;
options.render.unsafe_ = true;
assert_eq!(markdown_to_html("* [x] Done\n* [ ] Not done\n", &options),
           "<ul>\n<li><input type=\"checkbox\" checked=\"\" disabled=\"\" /> Done</li>\n\
           <li><input type=\"checkbox\" disabled=\"\" /> Not done</li>\n</ul>\n");

pub fn superscript(&mut self, value: bool) -> &mut Self

Enables the superscript Comrak extension.

let mut options = Options::default();
options.extension.superscript = true;
assert_eq!(markdown_to_html("e = mc^2^.\n", &options),
           "<p>e = mc<sup>2</sup>.</p>\n");

pub fn header_ids(&mut self, value: Option<String>) -> &mut Self

Enables the header IDs Comrak extension.

let mut options = Options::default();
options.extension.header_ids = Some("user-content-".to_string());
assert_eq!(markdown_to_html("# README\n", &options),
           "<h1><a href=\"#readme\" aria-hidden=\"true\" class=\"anchor\" id=\"user-content-readme\"></a>README</h1>\n");

pub fn footnotes(&mut self, value: bool) -> &mut Self

Enables the footnotes extension per cmark-gfm.

For usage, see src/tests.rs. The extension is modelled after Kramdown.

let mut options = Options::default();
options.extension.footnotes = true;
assert_eq!(markdown_to_html("Hi[^x].\n\n[^x]: A greeting.\n", &options),
           "<p>Hi<sup class=\"footnote-ref\"><a href=\"#fn-x\" id=\"fnref-x\" data-footnote-ref>1</a></sup>.</p>\n<section class=\"footnotes\" data-footnotes>\n<ol>\n<li id=\"fn-x\">\n<p>A greeting. <a href=\"#fnref-x\" class=\"footnote-backref\" data-footnote-backref data-footnote-backref-idx=\"1\" aria-label=\"Back to reference 1\">↩</a></p>\n</li>\n</ol>\n</section>\n");

pub fn description_lists(&mut self, value: bool) -> &mut Self

Enables the description lists extension.

Each term must be defined in one paragraph, followed by a blank line, and then by the details. Details begins with a colon.

Not (yet) compatible with render.sourcepos.

First term

: Details for the **first term**

Second term

: Details for the **second term**

    More details in second paragraph.

let mut options = Options::default();
options.extension.description_lists = true;
assert_eq!(markdown_to_html("Term\n\n: Definition", &options),
           "<dl><dt>Term</dt>\n<dd>\n<p>Definition</p>\n</dd>\n</dl>\n");

pub fn front_matter_delimiter(&mut self, value: Option<String>) -> &mut Self

Enables the front matter extension.

Front matter, which begins with the delimiter string at the beginning of the file and ends at the end of the next line that contains only the delimiter, is passed through unchanged in markdown output and omitted from HTML output.

---
layout: post
title: Formatting Markdown with Comrak
---

# Shorter Title

etc.

let mut options = Options::default();
options.extension.front_matter_delimiter = Some("---".to_owned());
assert_eq!(
    markdown_to_html("---\nlayout: post\n---\nText\n", &options),
    markdown_to_html("Text\n", &Options::default()));

use comrak::parse_document;
let mut options = Options::default();
options.extension.front_matter_delimiter = Some("---".to_owned());
let arena = Arena::new();
let input ="---\nlayout: post\n---\nText\n";
let root = parse_document(&arena, input, &options);
let mut buf = Vec::new();
format_commonmark(&root, &options, &mut buf);
assert_eq!(&String::from_utf8(buf).unwrap(), input);

pub fn multiline_block_quotes(&mut self, value: bool) -> &mut Self

Enables the multiline block quote extension.

Place >>> before and after text to make it into a block quote.

Paragraph one

>>>
Paragraph two

- one
- two
>>>

let mut options = Options::default();
options.extension.multiline_block_quotes = true;
assert_eq!(markdown_to_html(">>>\nparagraph\n>>>", &options),
           "<blockquote>\n<p>paragraph</p>\n</blockquote>\n");

pub fn math_dollars(&mut self, value: bool) -> &mut Self

Enables math using dollar syntax.

Inline math $1 + 2$ and display math $$x + y$$

$$
x^2
$$

let mut options = Options::default();
options.extension.math_dollars = true;
assert_eq!(markdown_to_html("$1 + 2$ and $$x = y$$", &options),
           "<p><span data-math-style=\"inline\">1 + 2</span> and <span data-math-style=\"display\">x = y</span></p>\n");
assert_eq!(markdown_to_html("$$\nx^2\n$$\n", &options),
           "<p><span data-math-style=\"display\">\nx^2\n</span></p>\n");

pub fn math_code(&mut self, value: bool) -> &mut Self

Enables math using code syntax.

Inline math $`1 + 2`$

```math
x^2
```

let mut options = Options::default();
options.extension.math_code = true;
assert_eq!(markdown_to_html("$`1 + 2`$", &options),
           "<p><code data-math-style=\"inline\">1 + 2</code></p>\n");
assert_eq!(markdown_to_html("```math\nx^2\n```\n", &options),
           "<pre><code class=\"language-math\" data-math-style=\"display\">x^2\n</code></pre>\n");

pub fn shortcodes(&mut self, value: bool) -> &mut Self

Available on crate feature shortcodes only.

Phrases wrapped inside of ‘:’ blocks will be replaced with emojis.

let mut options = Options::default();
assert_eq!(markdown_to_html("Happy Friday! :smile:", &options),
           "<p>Happy Friday! :smile:</p>\n");

options.extension.shortcodes = true;
assert_eq!(markdown_to_html("Happy Friday! :smile:", &options),
           "<p>Happy Friday! 😄</p>\n");

pub fn build(&self) -> Result<ExtensionOptions, ExtensionOptionsBuilderError>

Builds a new ExtensionOptions.

Errors

If a required field has not been initialized.

Trait Implementations

impl Clone for ExtensionOptionsBuilder

fn clone(&self) -> ExtensionOptionsBuilder

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for ExtensionOptionsBuilder

fn default() -> Self

Returns the “default value” for a type.