Struct comrak::ParseOptions

source ·
#[non_exhaustive]
pub struct ParseOptions<'c> { pub smart: bool, pub default_info_string: Option<String>, pub relaxed_tasklist_matching: bool, pub relaxed_autolinks: bool, pub broken_link_callback: Option<Arc<Mutex<BrokenLinkCallback<'c>>>>, }
Expand description

Options for parser functions.

Fields (Non-exhaustive)§

This struct is marked as non-exhaustive
Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.
§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.

§relaxed_autolinks: bool

Relax parsing of autolinks, allow links to be detected inside brackets and allow all url schemes

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");
§broken_link_callback: Option<Arc<Mutex<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 arena = Arena::new();
let mut 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 options = Options {
    parse: ParseOptionsBuilder::default()
        .broken_link_callback(Some(Arc::new(Mutex::new(&mut cb))))
        .build()
        .unwrap(),
    ..Default::default()
};

let root = parse_document(
    &arena,
    "# Cool input!\nWow look at this cool [link][foo]. A [broken link] renders as text.",
    &options,
);

let mut output = Vec::new();
format_html(root, &Options::default(), &mut output)?;
assert_eq!(str::from_utf8(&output).unwrap(),
           "<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");

Trait Implementations§

source§

impl<'c, 'arbitrary: 'c> Arbitrary<'arbitrary> for ParseOptions<'c>

source§

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data. Read more
source§

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data. Read more
source§

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself. Read more
source§

impl<'c> Clone for ParseOptions<'c>

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<'c> Debug for ParseOptions<'c>

source§

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

Formats the value using the given formatter. Read more
source§

impl<'c> Default for ParseOptions<'c>

source§

fn default() -> ParseOptions<'c>

Returns the “default value” for a type. Read more

Auto Trait Implementations§

§

impl<'c> Freeze for ParseOptions<'c>

§

impl<'c> RefUnwindSafe for ParseOptions<'c>

§

impl<'c> !Send for ParseOptions<'c>

§

impl<'c> !Sync for ParseOptions<'c>

§

impl<'c> Unpin for ParseOptions<'c>

§

impl<'c> UnwindSafe for ParseOptions<'c>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

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

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

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

source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

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

Performs the conversion.