aboutsummaryrefslogtreecommitdiff
path: root/code/src/markdown.rs
blob: 5d98f830f28f1a75b2fb2715fbe64992fbc5ef38 (plain)
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
use markdown::{Block, ListItem, Span};


pub fn span_to_html(ss: Vec<Span>) -> String {
    let mut out = String::new();
    for s in ss {
        out += match s {
            Span::Break => format!("<br/>"),
            Span::Text(t) => escape(&t),
            Span::Code(c) => format!("<code>{}</code>", escape(&c)),
            Span::Link(text, url, _) => {
                format!("<a href=\"{}\">{}</a>", escape(&url), escape(&text))
            }
            Span::Image(_, _, _) => todo!(),
            Span::Emphasis(c) => format!("<i>{}</i>", span_to_html(c)),
            Span::Strong(c) => format!("<b>{}</b>", span_to_html(c)),
        }
        .as_str()
    }
    out
}
pub fn blocks_to_html(blocks: Vec<Block>) -> String {
    let mut out = String::new();
    for e in blocks {
        out += match e {
            Block::Header(text, level) => {
                format!("<h{level}>{}</h{level}>", span_to_html(text))
            }
            Block::Paragraph(p) => format!("<p>{}</p>", span_to_html(p)),
            Block::Blockquote(q) => format!("<quote>{}</quote>", blocks_to_html(q)),
            Block::CodeBlock(_syntax, content) => {
                format!("<pre>{}</pre>", escape(&content)) // TODO syntax highlighting
            }
            Block::OrderedList(els, _) => format!(
                "<ol>{}</ol>",
                els.into_iter()
                    .map(|e| format!(
                        "<li>{}</li>",
                        match e {
                            ListItem::Simple(s) => span_to_html(s),
                            ListItem::Paragraph(b) => blocks_to_html(b),
                        }
                    ))
                    .collect::<Vec<_>>()
                    .join("")
            ),
            Block::UnorderedList(els) => {
                format!(
                    "<ul>{}</ul>",
                    els.into_iter()
                        .map(|e| format!(
                            "<li>{}</li>",
                            match e {
                                ListItem::Simple(s) => span_to_html(s),
                                ListItem::Paragraph(b) => blocks_to_html(b),
                            }
                        ))
                        .collect::<Vec<_>>()
                        .join("")
                )
            }
            Block::Raw(r) => r,
            Block::Hr => format!("<hr/>"),
        }
        .as_str();
    }
    out
}

pub fn escape(text: &str) -> String {
    text.replace("&", "&amp;")
        .replace("<", "&lt;")
        .replace(">", "&gt;")
        .replace("'", "&#8217;")
        .replace("\"", "&quot;")
}