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
136
137
138
139
140
141
142
143
144
145
146
147

use std::{collections::HashMap, path::PathBuf};

use mdtrans::{transform_markdown_string, MarkdownTransformer};

extern crate mdtrans;

#[derive(Default)]
pub struct Transformer {
    refs: HashMap<String, String>,
}

impl Transformer {
    fn sanitize_html(&self, text: String) -> String {
        text.replace('<', "&lt;").replace('>', "&gt;")
    }
}

impl MarkdownTransformer for Transformer {
    fn transform_text(&mut self, text: String) -> String {
        self.sanitize_html(text)
    }

    fn transform_quote(&mut self, text: String) -> String {
        format!("<div class=\"quote\">{text}</div>")
    }

    fn transform_image(
        &mut self,
        alt: String,
        url: String,
        add_tags: std::collections::HashMap<String, String>,
    ) -> String {
        let mut metadata = " ".to_string();
        metadata += add_tags
            .into_iter()
            .map(|(key, val)| {
                let val = val.trim_start_matches('\"').trim_end_matches('\"');
                format!(" {key}=\"{val}\"")
            })
            .collect::<Vec<String>>()
            .join(" ")
            .as_str();
        format!("<img src=\"{url}\" alt=\"{alt}\"{metadata}>")
    }

    fn transform_bold(&mut self, text: String) -> String {
        format!("<strong>{text}</strong>")
    }

    fn transform_italic(&mut self, text: String) -> String {
        format!("<em>{text}</em>")
    }

    fn transform_link(&mut self, text: String, url: String) -> String {
        format!("<a href=\"{url}\">{text}</a>")
    }

    fn transform_header(&mut self, level: usize, text: String) -> String {
        format!("<h{level}>{text}</h{level}>")
    }

    fn transform_inline_code(&mut self, text: String) -> String {
        format!("<code>{}</code>", self.sanitize_html(text))
    }

    fn transform_codeblock(&mut self, lang: Option<String>, text: String) -> String {
        let mut buffer = "<pre".to_string();
        if let Some(l) = lang {
            buffer += format!(" class=\"lang-{}\"", l.to_lowercase()).as_str();
        }
        buffer += format!("><code>{}</code></pre>", self.sanitize_html(text)).as_str();
        buffer
    }

    fn peek_refurl(&mut self, slug: String, url: String) {
        self.refs.insert(slug, url);
    }

    fn transform_reflink(&mut self, text: String, slug: String) -> String {
        let url = self.refs.get(&slug);
        assert!(url.is_some(), "Link reference {slug} not found");
        self.transform_link(text, url.unwrap().clone())
    }

    fn transform_refurl(&mut self, _slug: String, _url: String) -> String {
        "".to_string()
    }

    fn transform_list(&mut self, elements: Vec<String>) -> String {
        let mut buffer = "<ul>\n".to_string();
        buffer += elements.join("\n").as_str();
        buffer += "\n</ul>";
        buffer
    }

    fn transform_list_element(&mut self, element: String) -> String {
        format!("<li>{}</li>", self.sanitize_html(element))
    }

    fn transform_paragraph(&mut self, text: String) -> String {
        format!("<p>{text}</p>")
    }

    fn transform_vertical_space(&mut self) -> String {
        "<br/>".to_string()
    }
}

fn create_page(post: String) -> String {
    format!(
        "
        <!DOCTYPE html>
        <html lang=\"en\">
        <head>
            <meta charset=\"UTF-8\"> 
            <title>Post 1</title>
        </head>
        {post}
        </html>
    "
    )
}

fn main() {
    let mut transformer = Transformer::default();

    for file in std::fs::read_dir("./examples/data").unwrap() {
        let tstart = std::time::Instant::now();
        let post_file = file.unwrap().path();
        let fname = post_file
            .file_name()
            .unwrap()
            .to_os_string()
            .into_string()
            .unwrap();
        if !fname.ends_with(".md") {
            continue;
        }
        println!();
        let new_fname = fname.replace(".md", ".html");
        println!("{} -> {}", fname, new_fname);
        let post = std::fs::read_to_string(&post_file).unwrap();
        let res = transform_markdown_string(post, &mut transformer).unwrap();
        std::fs::write(PathBuf::from(new_fname), create_page(res)).unwrap();
        println!("Done in {:?}", tstart.elapsed());
    }
}