comrak 0.1.4 - Docs.rs

Rust port of github's cmark-gfm.

Usage
Extensions
Legal

Usage

A binary is included which does everything you typically want:

$ comrak --help
comrak 0.1.4
Yuki Izumi <yuki@kivikakk.ee>
CommonMark parser with GitHub Flavored Markdown extensions

USAGE:
    comrak [FLAGS] [OPTIONS] [--] [<FILE>]

FLAGS:
        --github-pre-lang    Use GitHub-style <pre lang> for code blocks
        --hardbreaks         Treat newlines as hard line breaks
    -h, --help               Prints help information
    -V, --version            Prints version information

OPTIONS:
    -e, --extension <EXTENSION>...    Specify an extension name to use [values: strikethrough, tagfilter, table, autolink, superscript]
    -t, --to <FORMAT>                 Specify output format [default: html]  [values: html, commonmark]
        --width <WIDTH>               Specify wrap width (0 = nowrap) [default: 0]

ARGS:
    <FILE>...    The CommonMark file to parse; or standard input if none passed

And there's a Rust interface. You can use comrak::markdown_to_html directly:

use comrak::{markdown_to_html, ComrakOptions};
assert_eq!(markdown_to_html("Hello, **世界**!", &ComrakOptions::default()),
           "<p>Hello, <strong>世界</strong>!</p>\n");

Or you can parse the input into an AST yourself, manipulate it, and then use your desired formatter:

extern crate comrak;
extern crate typed_arena;
use typed_arena::Arena;
use comrak::{parse_document, format_html, ComrakOptions};
use comrak::nodes::{AstNode, NodeValue};

// The returned nodes are created in the supplied Arena, and are bound by its lifetime.
let arena = Arena::new();

let root = parse_document(
    &arena,
    "This is my input.\n\n1. Also my input.\n2. Certainly my input.\n",
    &ComrakOptions::default());

fn iter_nodes<'a, F>(node: &'a AstNode<'a>, f: &F)
    where F : Fn(&'a AstNode<'a>) {
    f(node);
    for c in node.children() {
        iter_nodes(c, f);
    }
}

iter_nodes(root, &|node| {
    match &mut node.data.borrow_mut().value {
        &mut NodeValue::Text(ref mut text) => {
            *text = text.replace("my", "your");
        }
        _ => (),
    }
});

let html: String = format_html(root, &ComrakOptions::default());

assert_eq!(
    html,
    "<p>This is your input.</p>\n\
     <ol>\n\
     <li>Also your input.</li>\n\
     <li>Certainly your input.</li>\n\
     </ol>\n");

Extensions

Comrak supports the five extensions to CommonMark defined in the GitHub Flavored Markdown Spec:

as well as superscript.

By default none are enabled; they are individually enabled with each parse by setting the appropriate values in the ComrakOptions struct.

Legal

See COPYING for all the details.

Contributors

Thank you for PRs and issues opened!