mdiu 0.1.2

Build documents with gemtext
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

use super::{Block, Level, Markup};

/// An HTML formatter, available with the `html` feature
///
/// Links are formatted as lists of links.
pub struct Html;

impl Markup for Html {
    fn markup(blocks: &[Block]) -> String {
        let mut iter = blocks.iter();
        let mut block = iter.next();
        let mut in_list: Option<List> = None;

        std::iter::from_fn(|| {
            let intermediate = match (in_list.as_ref(), block) {
                (None, Some(Block::Link(_))) => {
                    in_list = Some(List::Link);
                    Intermediate::OpenList
                }
                (None, Some(Block::ListItem(_))) => {
                    in_list = Some(List::Item);
                    Intermediate::OpenList
                }
                (Some(_), None) => {
                    in_list = None;
                    Intermediate::CloseList
                }
                (Some(List::Link), Some(b)) if !matches!(b, Block::Link(_)) => {
                    in_list = None;
                    Intermediate::CloseList
                }
                (Some(List::Item), Some(b)) if !matches!(b, Block::ListItem(_)) => {
                    in_list = None;
                    Intermediate::CloseList
                }
                (_, Some(block)) => Intermediate::Block(block),
                (None, None) => return None,
            };

            if let Intermediate::Block(_) = intermediate {
                block = iter.next();
            }

            Some(intermediate)
        })
        .map(|intermediate| match intermediate {
            Intermediate::Block(block) => generate(block),
            Intermediate::OpenList => "<ul>\n".to_string(),
            Intermediate::CloseList => "</ul>\n".to_string(),
        })
        .collect::<String>()
    }
}

enum List {
    Link,
    Item,
}

enum Intermediate<'a> {
    Block(&'a Block),
    OpenList,
    CloseList,
}

fn generate(block: &Block) -> String {
    match block {
        Block::Text(text) => format!("<p>{}</p>\n", text),
        Block::Link(link) => match link.label() {
            Some(label) => {
                format!("<li><a href=\"{}\">{}</a></li>\n", link.uri(), label)
            }
            None => {
                format!("<li><a href=\"{0}\">{0}</a></li>\n", link.uri())
            }
        },
        Block::Heading(Level::One, text) => format!("<h1>{}</h1>\n", text),
        Block::Heading(Level::Two, text) => format!("<h2>{}</h2>\n", text),
        Block::Heading(Level::Three, text) => format!("<h3>{}</h3>\n", text),
        Block::ListItem(text) => {
            format!("<li>{}</li>\n", text)
        }
        Block::Quote(text) => format!("<blockquote>{}</blockquote>\n", text),
        Block::Preformatted(pre) => format!("<pre>\n{}\n</pre>\n", pre.text()),
        // TODO
        Block::Empty => "".to_string(),
    }
}