zamm_yang 0.1.8

A basic, experimental code generator
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

use super::basic::{AtomicFragment, FileFragment, FunctionFragment};
use std::cell::RefCell;
use std::rc::Rc;

/// Output config for main function code generation.
#[derive(Eq, PartialEq, Debug)]
pub struct MainConfig {
    /// Ignore dead code and unused imports.
    pub ignore_dead_code: bool,
    /// Imports that the main function uses.
    pub imports: Vec<String>,
    /// Lines of code to include in the main function. Should really be additional fragments to
    /// include.
    pub lines: Vec<String>,
}

/// Generate code for a main function.
pub fn code_main(cfg: &MainConfig) -> String {
    let mut file = FileFragment::default();

    if cfg.ignore_dead_code {
        file.set_preamble(AtomicFragment::new(
            "#![allow(dead_code, unused_imports)]".to_owned(),
        ));
    }

    let mut main_function = FunctionFragment::new("main".to_owned());
    for import in &cfg.imports {
        main_function.add_import(import.clone());
    }
    for line in &cfg.lines {
        main_function.append(Rc::new(RefCell::new(AtomicFragment::new(line.clone()))));
    }
    file.append(Rc::new(RefCell::new(main_function)));

    file.generate_code()
}

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

    #[test]
    fn test_empty_main() {
        assert_eq!(
            code_main(&MainConfig {
                ignore_dead_code: false,
                imports: vec![],
                lines: vec![],
            }),
            "fn main() {}\n"
        );
    }

    #[test]
    fn test_some_main() {
        assert_eq!(
            code_main(&MainConfig {
                ignore_dead_code: false,
                imports: vec!["crate::mymod::Thing".to_owned()],
                lines: vec![
                    "let t = Thing::new();".to_owned(),
                    "t.do_something();".to_owned()
                ],
            }),
            indoc! {"
                use crate::mymod::Thing;

                fn main() {
                    let t = Thing::new();
                    t.do_something();
                }
                "}
        );
    }

    #[test]
    fn test_main_ignore_dead_code() {
        assert_eq!(
            code_main(&MainConfig {
                ignore_dead_code: true,
                imports: vec!["crate::mymod::Thing".to_owned()],
                lines: vec![
                    "let t = Thing::new();".to_owned(),
                    "t.do_something();".to_owned()
                ],
            }),
            indoc! {"
                #![allow(dead_code, unused_imports)]

                use crate::mymod::Thing;

                fn main() {
                    let t = Thing::new();
                    t.do_something();
                }
                "}
        );
    }
}