mdmg 0.1.6

A scaffold prototype code tool
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use crate::scaffold::Scaffold;
use crate::Result;
use comrak::nodes::{AstNode, NodeValue};
use comrak::{parse_document, Arena, ComrakOptions};

pub fn parse<T: Into<String>>(markdown: T) -> Result<Vec<Scaffold>> {
    let arena = Arena::new();
    let doc = parse_document(&arena, markdown.into().as_ref(), &ComrakOptions::default());

    let mut scaffolds: Vec<Scaffold> = vec![];

    fn iter_nodes<'a, F>(
        node: &'a AstNode<'a>,
        scaffolds: &'a mut Vec<Scaffold>,
        f: &F,
    ) -> &'a mut Vec<Scaffold>
    where
        F: Fn(&'a AstNode<'a>, &'a mut Vec<Scaffold>) -> &'a mut Vec<Scaffold>,
    {
        let mut scaffolds = f(node, scaffolds);
        for c in node.children() {
            scaffolds = iter_nodes(c, scaffolds, f);
        }
        scaffolds
    }

    let scaffolds = iter_nodes(doc, &mut scaffolds, &|node, scaffolds| {
        if let NodeValue::Text(txt_vec) = node.data.clone().into_inner().value {
            if let Some(parent_node) = node.parent() {
                if let NodeValue::Heading(heading) = parent_node.data.clone().into_inner().value {
                    if heading.level != 2 {
                        return scaffolds;
                    }
                    if txt_vec.is_empty() {
                        return scaffolds;
                    }
                    let title_txt = String::from_utf8(txt_vec);
                    if let Ok(file_name) = title_txt {
                        scaffolds.push(Scaffold::Pending { file_name })
                    }
                }
            }
        }

        if let NodeValue::CodeBlock(ncb) = node.data.clone().into_inner().value {
            if ncb.literal.is_empty() {
                return scaffolds;
            }

            let code_block_txt = String::from_utf8(ncb.literal);
            let code_block = code_block_txt.expect("code block text is not found");
            let pending_scaffold_position_opt = scaffolds.iter().position(|scaffold| -> bool {
                if let Scaffold::Pending {
                    file_name: _file_name,
                } = scaffold
                {
                    return true;
                }
                false
            });
            if let Some(pending_scaffold_position) = pending_scaffold_position_opt {
                let pending_scaffold = scaffolds.swap_remove(pending_scaffold_position);
                if let Scaffold::Pending { file_name } = pending_scaffold {
                    scaffolds.push(Scaffold::Complete {
                        file_name,
                        file_body: code_block,
                    })
                }
            }
        }
        scaffolds
    });

    Ok(scaffolds.clone())
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn parse_is_return_to_one_scaffold() {
        let markdown = r#"
## src/foobar.rs
```rust
use crate::Result;

fn something() -> Result<String> {
    unimplemented!()
}

#[cfg(test)]
mod tests {
    use suepr::*;

    #[test]
    fn test_something() {
    }
}
```
"#;
        let scaffolds = parse(markdown).unwrap();
        let file_body = r#"use crate::Result;

fn something() -> Result<String> {
    unimplemented!()
}

#[cfg(test)]
mod tests {
    use suepr::*;

    #[test]
    fn test_something() {
    }
}
"#
        .to_string();
        assert_eq!(
            scaffolds,
            vec![Scaffold::Complete {
                file_name: "src/foobar.rs".to_string(),
                file_body
            }]
        )
    }
}