rfc 0.3.0

A lil helper tool to automate some of the tedium in mimicking Rust's RFC process
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
148
149
150
151
152
153
154
155

use regex::{self, Regex};

fn greater_or_equal_header_level_regex(level: usize) -> Regex {
    let string = match level {
        0 => panic!("Can't have a 0-level header"),
        1 => "(?m)^# +[^\\s].*\\n|(?m)^[^\\s].*\\n=+\\n".to_string(),
        _ => format!("(?m)^#{{1,{}}} +[^\\s].*\\n|(?m)^[^\\s].*\\n(=+|-+)\\n", level),
    };

    Regex::new(&string).expect("Header regex failed to compile")
}

fn header_regex(header: &str) -> Regex {
    Regex::new(&format!("(?m)^(#+) +{0}\\n|(?m)^{0}\\n(-+|=+)\\n", regex::quote(header)))
        .expect("Header regex failed to compile")
}

pub fn find_section(markdown: &str, header: &str) -> Option<(usize, usize)> {
    let header_regex = header_regex(header);

    let (header_start, content_start) = match header_regex.find(markdown) {
        Some((a, b)) => (a, b),
        None => return None,
    };

    let header_level = header_level(markdown, header).unwrap();

    let next_header_start = match greater_or_equal_header_level_regex(header_level).find(&markdown[content_start..]) {
        None => markdown.len(),
        Some((a, _)) => a + content_start,
    };

    Some((header_start, next_header_start))
}

pub fn get_section(markdown: &str, header: &str) -> Option<String> {
    if let Some((section_start, section_end)) = find_section(markdown, header) {
        Some(String::from(&markdown[section_start..section_end]))
    } else {
        None
    }
}


pub fn replace_section(markdown: &str, header: &str, insertion: &str) -> Option<String> {
    let section = match get_section(markdown, header) {
        Some(string) => string,
        None => return None,
    };

    let header_text = header_regex(header)
        .captures(markdown).unwrap()
        .at(0).unwrap()
        .clone();

    let full_replacement_text = format!("{}{}", header_text, insertion);

    Some(markdown.replace(&section, &full_replacement_text))
}

pub fn replace_or_append_section(markdown: &str, header: &str, insertion: &str) -> String {
    match replace_section(markdown, header, insertion) {
        Some(string) => string,
        None => format!("{}\n# {}{}", markdown, header, insertion),
    }
}

pub fn header_level(markdown: &str, header: &str) -> Option<usize> {
    match header_regex(header).captures(markdown) {
        Some(captures) => {
            Some(if let Some(num_signs) = captures.at(1) {
                num_signs.chars().count()
            } else if let Some(horiz_line) = captures.at(2) {
                match &horiz_line[..1] {
                    "=" => 1,
                    "-" => 2,
                    _ => unreachable!(),
                }
            } else {
                unreachable!()
            })
        }
        None => None,
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_markdown_replace() {
        let md = "\
          abc\
          \n\
          \n```\
          \n  123\
          \n```\
          \n\
          \n#### Blarg\
          \nblergins\
          \n- [85](lakjlkja)\
          \n\
          \n###### Florm\
          \n\
          \n###### Florm 2\
          \n\
          \n# Blaag\
          \nFlerbin Storpl\
          \n---\
          \n\
          \nJaxr\
          \n===\
          \n\
          \n\
          \nJaaaz\
          \n\
          \n\
          \n\
        ";

        assert_eq!(super::header_level(&md, "Blarg"), Some(4));
        assert_eq!(super::header_level(&md, "Flerbin Storpl"), Some(2));
        assert_eq!(super::header_level(&md, "Jaxr"), Some(1));
        assert_eq!(super::header_level(&md, "Jaaaz"), None);

        assert_eq!(super::get_section(&md, "Jaxr"), Some("Jaxr\n===\n\n\nJaaaz\n\n\n".to_string()));
        assert_eq!(super::get_section(&md, "Flerbin Storpl"), Some("Flerbin Storpl\n---\n\n".to_string()));
        assert_eq!(super::get_section(&md, "Blaag"), Some("# Blaag\nFlerbin Storpl\n---\n\n".to_string()));
        assert_eq!(super::get_section(&md, "Not Real"), None);

        assert_eq!(super::replace_or_append_section(&md, "Blarg", "abc\n123\n"),
                   "\
                     abc\
                     \n\
                     \n```\
                     \n  123\
                     \n```\
                     \n\
                     \n#### Blarg\
                     \nabc\
                     \n123\
                     \n# Blaag\
                     \nFlerbin Storpl\
                     \n---\
                     \n\
                     \nJaxr\
                     \n===\
                     \n\
                     \n\
                     \nJaaaz\
                     \n\
                     \n\
                     \n\
                   ".to_string());
    }
}