markly 0.3.0

Native Rust library for parsing Markdown and (outputting HTML)
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

use super::{Block, ListItem, Span};

trait JoinHelper<I>
where
    I: Iterator,
{
    fn j(self, sep: &'static str) -> String;
}

impl<I> JoinHelper<I> for I
where
    I: Iterator<Item = String>,
{
    fn j(self, sep: &'static str) -> String {
        self.collect::<Vec<String>>().join(sep)
    }
}

fn gen_block(b: Block) -> String {
    use Block::*;
    match b {
        Header(s, level) => format!(
            "{} {}",
            ::std::iter::repeat("#".to_string()).take(level).j(""),
            generate_from_spans(s)
        ),
        Paragraph(s) => generate_from_spans(s),
        Blockquote(bb) => generate(bb).lines().map(|x| format!("> {}", x)).j("\n"),
        CodeBlock(lang, x) => {
            if lang.is_none() {
                x.lines().map(|x| format!("    {}", x)).j("\n")
            } else {
                format!("```{}\n{}```", lang.unwrap(), x)
            }
        }
        // [TODO]: Ordered list generation - 2017-12-10 10:12pm
        OrderedList(_x, _num_type) => unimplemented!("Generate ordered list"),
        UnorderedList(x) => generate_from_li(x),
        // TODO: Link References generation - 2020-05-11
        LinkReference(_reference, _link, _title) => unimplemented!("Generate link reference"),
        Raw(x) => x,
        Hr => "\n\n".to_string(),
    }
}

fn gen_span(s: Span) -> String {
    use Span::*;
    match s {
        Break => "  \n".to_string(),
        Text(x) => x,
        Code(x) => format!("`{}`", x),
        Link(a, b, None) => format!("[{}]({})", a, b),
        Link(a, b, Some(c)) => format!("[{}]({} \"{}\")", a, b, c),
        // TODO: Reference Link generation - 2020-05-11
        ReferenceLink(_a, _b) => unimplemented!("Generate reference link"),
        Image(a, b, None) => format!("![{}]({})", a, b),
        Image(a, b, Some(c)) => format!("![{}]({} \"{}\")", a, b, c),
        Emphasis(x) => format!("*{}*", generate_from_spans(x)),
        Strong(x) => format!("**{}**", generate_from_spans(x)),
    }
}

fn generate_from_li(data: Vec<ListItem>) -> String {
    use ListItem::*;

    data.into_iter()
        .map(|x| {
            format!(
                "* {}",
                match x {
                    Simple(x) => generate_from_spans(x),
                    Paragraph(x) => format!(
                        "{}\n",
                        generate(x)
                            .lines()
                            .enumerate()
                            .map(|(i, x)| if i == 0 {
                                x.to_string()
                            } else {
                                format!("    {}", x)
                            })
                            .j("\n")
                    ),
                }
            )
        })
        .j("\n")
}

fn generate_from_spans(data: Vec<Span>) -> String {
    data.into_iter().map(gen_span).j("")
}

pub fn generate(data: Vec<Block>) -> String {
    data.into_iter().map(gen_block).j("\n\n")
}