comrak 0.1.4

A 100% CommonMark-compatible GitHub Flavored Markdown parser and formatter
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! The `comrak` binary.

#![deny(missing_docs,
        missing_debug_implementations,
	missing_copy_implementations,
	trivial_casts,
	trivial_numeric_casts,
	unsafe_code,
	unstable_features,
	unused_import_braces,
	unused_qualifications)]

#![cfg_attr(feature = "dev", allow(unstable_features))]
#![cfg_attr(feature = "dev", feature(plugin))]
#![cfg_attr(feature = "dev", plugin(clippy))]
#![allow(unknown_lints, doc_markdown, cyclomatic_complexity)]

#[macro_use]
extern crate clap;
extern crate unicode_categories;
extern crate arena_tree;
extern crate typed_arena;
extern crate regex;
#[macro_use]
extern crate lazy_static;

mod html;
mod cm;
mod parser;
mod nodes;
mod ctype;
mod scanners;
mod strings;
mod entity;
mod entity_data;

use std::collections::BTreeSet;
use std::io::Read;
use std::process;
use typed_arena::Arena;

fn main() {
    let matches = clap::App::new("comrak")
        .version(crate_version!())
        .author("Yuki Izumi <yuki@kivikakk.ee>")
        .about("CommonMark parser with GitHub Flavored Markdown extensions")
        .arg(clap::Arg::with_name("file")
                 .value_name("FILE")
                 .multiple(true)
                 .help("The CommonMark file to parse; or standard input if none passed"))
        .arg(clap::Arg::with_name("hardbreaks")
                 .long("hardbreaks")
                 .help("Treat newlines as hard line breaks"))
        .arg(clap::Arg::with_name("github-pre-lang")
                 .long("github-pre-lang")
                 .help("Use GitHub-style <pre lang> for code blocks"))
        .arg(clap::Arg::with_name("extension")
                 .short("e")
                 .long("extension")
                 .takes_value(true)
                 .number_of_values(1)
                 .multiple(true)
                 .possible_values(&["strikethrough",
                                    "tagfilter",
                                    "table",
                                    "autolink",
                                    "tasklist",
                                    "superscript"])
                 .value_name("EXTENSION")
                 .help("Specify an extension name to use"))
        .arg(clap::Arg::with_name("format")
                 .short("t")
                 .long("to")
                 .takes_value(true)
                 .possible_values(&["html", "commonmark"])
                 .default_value("html")
                 .value_name("FORMAT")
                 .help("Specify output format"))
        .arg(clap::Arg::with_name("width")
                 .long("width")
                 .takes_value(true)
                 .value_name("WIDTH")
                 .default_value("0")
                 .help("Specify wrap width (0 = nowrap)"))
        .get_matches();

    let mut exts = matches
        .values_of("extension")
        .map_or(BTreeSet::new(), |vals| vals.collect());

    let options = parser::ComrakOptions {
        hardbreaks: matches.is_present("hardbreaks"),
        github_pre_lang: matches.is_present("github-pre-lang"),
        width: matches
            .value_of("width")
            .unwrap_or("0")
            .parse()
            .unwrap_or(0),
        ext_strikethrough: exts.remove("strikethrough"),
        ext_tagfilter: exts.remove("tagfilter"),
        ext_table: exts.remove("table"),
        ext_autolink: exts.remove("autolink"),
        ext_tasklist: exts.remove("tasklist"),
        ext_superscript: exts.remove("superscript"),
    };

    assert!(exts.is_empty());

    let mut s = String::with_capacity(2048);

    match matches.values_of("file") {
        None => {
            std::io::stdin().read_to_string(&mut s).unwrap();
        }
        Some(fs) => {
            for f in fs {
                let mut io = std::fs::File::open(f).unwrap();
                io.read_to_string(&mut s).unwrap();
            }
        }
    };

    let arena = Arena::new();
    let root = parser::parse_document(&arena, &s, &options);

    let formatter = match matches.value_of("format") {
        Some("html") => html::format_document,
        Some("commonmark") => cm::format_document,
        _ => panic!("unknown format"),
    };

    print!("{}", formatter(root, &options));

    process::exit(0);
}