Build Status Spec Status: 643/643 crates.io version docs.rs

Rust port of github's cmark-gfm.

Usage

A binary is included which does everything you typically want:

``` $ comrak --help comrak 0.1.7 Ashe Connor ashe@kivikakk.ee CommonMark parser with GitHub Flavored Markdown extensions

USAGE: comrak [FLAGS] [OPTIONS] [--] []

FLAGS: --github-pre-lang Use GitHub-style 

 for code blocks
        --hardbreaks         Treat newlines as hard line breaks
    -h, --help               Prints help information
    -V, --version            Prints version information



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



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



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



``` rust
extern crate comrak;
extern crate typedarena;
use typedarena::Arena;
use comrak::{parsedocument, formathtml, 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 iternodes<'a, F>(node: &'a AstNode<'a>, f: &F)
    where F : Fn(&'a AstNode<'a>) {
    f(node);
    for c in node.children() {
        iternodes(c, f);
    }
}



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



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



assert_eq!(
    html,
    "
This is your input.
\n\
     
    \n\
     
  1. Also your input.
    2. \n\
     
  2. Certainly your input.
    3. \n\
     
\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



Copyright (c) 2017, Ashe Connor.  Licensed under the 2-Clause BSD License.



cmark itself is is copyright (c) 2014, John MacFarlane.



See COPYING for all the details.



Contributors



Thank you for PRs and issues opened!