Struct `RenderPlugins`

struct RenderPlugins<'p> { ... }

Plugins for alternative rendering.

Fields

codefence_syntax_highlighter: Option<&'p dyn SyntaxHighlighterAdapter>

Provide a syntax highlighter adapter implementation for syntax highlighting of codefence blocks.

# use comrak::{markdown_to_html, Options, Plugins, markdown_to_html_with_plugins};
# use comrak::adapters::SyntaxHighlighterAdapter;
use std::collections::HashMap;
use std::io::{self, Write};
let options = Options::default();
let mut plugins = Plugins::default();
let input = "```rust\nfn main<'a>();\n```";

assert_eq!(markdown_to_html_with_plugins(input, &options, &plugins),
           "<pre><code class=\"language-rust\">fn main&lt;'a&gt;();\n</code></pre>\n");

pub struct MockAdapter {}
impl SyntaxHighlighterAdapter for MockAdapter {
    fn write_highlighted(&self, output: &mut dyn Write, lang: Option<&str>, code: &str) -> io::Result<()> {
        write!(output, "<span class=\"lang-{}\">{}</span>", lang.unwrap(), code)
    }

    fn write_pre_tag(&self, output: &mut dyn Write, _attributes: HashMap<String, String>) -> io::Result<()> {
        output.write_all(b"<pre lang=\"rust\">")
    }

    fn write_code_tag(&self, output: &mut dyn Write, _attributes: HashMap<String, String>) -> io::Result<()> {
        output.write_all(b"<code class=\"language-rust\">")
    }
}

let adapter = MockAdapter {};
plugins.render.codefence_syntax_highlighter = Some(&adapter);

assert_eq!(markdown_to_html_with_plugins(input, &options, &plugins),
           "<pre lang=\"rust\"><code class=\"language-rust\"><span class=\"lang-rust\">fn main<'a>();\n</span></code></pre>\n");

heading_adapter: Option<&'p dyn HeadingAdapter>

Optional heading adapter

Implementations

`impl Debug for RenderPlugins<'_>`

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

`impl<'p> Clone for RenderPlugins<'p>`

fn clone(self: &Self) -> RenderPlugins<'p>

`impl<'p> Default for RenderPlugins<'p>`

fn default() -> RenderPlugins<'p>

`impl<'p> Freeze for RenderPlugins<'p>`

`impl<'p> RefUnwindSafe for RenderPlugins<'p>`

`impl<'p> Send for RenderPlugins<'p>`

`impl<'p> Sync for RenderPlugins<'p>`

`impl<'p> Unpin for RenderPlugins<'p>`

`impl<'p> UnsafeUnpin for RenderPlugins<'p>`

`impl<'p> UnwindSafe for RenderPlugins<'p>`

`impl<T> Any for RenderPlugins<'p>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for RenderPlugins<'p>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for RenderPlugins<'p>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for RenderPlugins<'p>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for RenderPlugins<'p>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for RenderPlugins<'p>`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for RenderPlugins<'p>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for RenderPlugins<'p>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for RenderPlugins<'p>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>