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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use parser::Block;
use parser::Block::CodeBlock;
use regex::Regex;

pub fn parse_code_block(lines: &[&str]) -> Option<(Block, usize)> {
    lazy_static! {
        static ref CODE_BLOCK_SPACES: Regex = Regex::new(r"^ {4}").unwrap();
        static ref CODE_BLOCK_TABS: Regex = Regex::new(r"^\t").unwrap();
        static ref CODE_BLOCK_BACKTICKS: Regex = Regex::new(r"```").unwrap();
    }

    let mut content = String::new();
    let mut lang: Option<String> = None;
    let mut line_number = 0;
    let mut backtick_opened = false;
    let mut backtick_closed = false;

    for line in lines {
        if !backtick_opened && CODE_BLOCK_SPACES.is_match(line) {
            if line_number > 0 && !content.is_empty() {
                content.push('\n');
            }
            // remove top-level spaces
            content.push_str(&line[4..line.len()]);
            line_number += 1;
        } else if !backtick_opened && CODE_BLOCK_TABS.is_match(line) {
            if line_number > 0 && !content.is_empty() {
                content.push('\n');
            }

            if !(line_number == 0 && line.trim().is_empty()) {
                // remove top-level spaces
                content.push_str(&line[1..line.len()]);
            }
            line_number += 1;
        } else if CODE_BLOCK_BACKTICKS.is_match(line) {
            line_number += 1;

            if !backtick_opened && !(line_number == 0 && line.get(3..).is_some()) {
                lang = Some(String::from(line.get(3..).unwrap()));
                backtick_opened = true;
            } else if backtick_opened {
                backtick_closed = true;
                break;
            }
        } else if backtick_opened {
            content.push_str(line);
            content.push('\n');

            line_number += 1;
        } else {
            break;
        }
    }

    if line_number > 0 && ((backtick_opened && backtick_closed) || !backtick_opened) {
        return Some((
            CodeBlock(lang, content.trim_matches('\n').to_owned()),
            line_number,
        ));
    }

    None
}

#[cfg(test)]
mod test {
    use super::parse_code_block;
    use parser::Block::CodeBlock;

    #[test]
    fn finds_code_block() {
        assert_eq!(
            parse_code_block(&vec!["    Test"]).unwrap(),
            ((CodeBlock(None, "Test".to_owned()), 1))
        );

        assert_eq!(
            parse_code_block(&vec!["    Test", "    this"]).unwrap(),
            ((CodeBlock(None, "Test\nthis".to_owned()), 2))
        );

        assert_eq!(
            parse_code_block(&vec!["```testlang", "Test", "this", "```"]).unwrap(),
            ((
                CodeBlock(Some(String::from("testlang")), "Test\nthis".to_owned()),
                4
            ))
        );
    }

    #[test]
    fn knows_when_to_stop() {
        assert_eq!(
            parse_code_block(&vec!["    Test", "    this", "stuff", "    now"]).unwrap(),
            ((CodeBlock(None, "Test\nthis".to_owned()), 2))
        );
    }

    #[test]
    fn no_false_positives() {
        assert_eq!(parse_code_block(&vec!["   Test"]), None);
    }

    #[test]
    fn no_early_matching() {
        assert_eq!(
            parse_code_block(&vec!["Test", "    this", "stuff", "    now"]),
            None
        );
    }
}