markdtohtml 0.1.1

Tool to convert markdown files to html files.
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

use std::fs;
use std::io::Write;

pub enum MarkdownElement {
    Header1(String),
    Header2(String),
    Header3(String),
    ListItem(String),
    Paragraph(String),
    NewLine,
}

pub fn parse(token: &str) -> MarkdownElement {
    if token.is_empty() {
        MarkdownElement::NewLine
    } else if let Some(stripped) = token.strip_prefix("# ") {
        MarkdownElement::Header1(stripped.to_string())
    } else if let Some(stripped) = token.strip_prefix("## ") {
        MarkdownElement::Header2(stripped.to_string())
    } else if let Some(stripped) = token.strip_prefix("### ") {
        MarkdownElement::Header3(stripped.to_string())
    } else if let Some(stripped) = token.strip_prefix("- ") {
        MarkdownElement::ListItem(stripped.to_string())
    } else {
        MarkdownElement::Paragraph(token.to_string())
    }
}

pub fn lexical(path: std::path::PathBuf) -> std::io::Result<()> {
    if path.is_file() && path.extension() == Some(std::ffi::OsStr::new("md")) {
        let mut output_file = fs::File::create(path.with_extension("html"))?;
        match std::fs::read_to_string(&path) {
            Ok(contents) => {
                println!("File name is {}", path.display());
                let tokens: Vec<&str> = contents.lines().collect();
                let mut in_list = false;
                for token in tokens {
                    let element: MarkdownElement = parse(token);
                    match &element {
                        MarkdownElement::ListItem(_) if !in_list => {
                            writeln!(output_file, "<ul>")?;
                            in_list = true;
                        }
                        _ if in_list && !matches!(element, MarkdownElement::ListItem(_)) => {
                            writeln!(output_file, "</ul>")?;
                            in_list = false;
                        }
                        _ => {}
                    }
                    match element {
                        MarkdownElement::Header1(text) => {
                            writeln!(output_file, "<h1>{}</h1>", text)?
                        }
                        MarkdownElement::Header2(text) => {
                            writeln!(output_file, "<h2>{}</h2>", text)?
                        }
                        MarkdownElement::Header3(text) => {
                            writeln!(output_file, "<h3>{}</h3>", text)?
                        }
                        MarkdownElement::ListItem(text) => {
                            writeln!(output_file, "<li>{}</li>", text)?
                        }
                        MarkdownElement::Paragraph(text) => {
                            writeln!(output_file, "<p>{}</p>", text)?
                        }
                        MarkdownElement::NewLine => writeln!(output_file)?,
                    }
                }
            }
            Err(e) => println!("Failed to read {}: {}", path.display(), e),
        }
    }
    Ok(())
}