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

use crate::scaffold::Scaffold;
use crate::Result;

use std::fs::{create_dir_all, File};
use std::io::Write;
use std::path::Path;

use derive_more::Constructor;
use yansi::Paint;

pub trait ScaffoldExecutor {
    fn execute(self, scaffold: &Scaffold) -> Result<()>;
}

#[derive(Clone, Debug, Copy, Constructor)]
pub struct DryRunScaffoldExecutor {}

#[derive(Clone, Debug, Copy, Constructor)]
pub struct FSScaffoldExecutor {}

impl ScaffoldExecutor for DryRunScaffoldExecutor {
    fn execute(self, scaffold: &Scaffold) -> Result<()> {
        if let Scaffold::Complete {
            file_name,
            file_body,
        } = scaffold
        {
            println!("=== filename: {} ===", file_name);
            println!("{}", file_body);
            println!("====================");
        }
        Ok(())
    }
}

impl ScaffoldExecutor for FSScaffoldExecutor {
    fn execute(self, scaffold: &Scaffold) -> Result<()> {
        if let Scaffold::Complete {
            file_name,
            file_body,
        } = scaffold
        {
            if Path::new(file_name).exists() {
                println!(
                    "{} {} (file_exists)",
                    Paint::yellow("Skip generate:"),
                    file_name
                );
                return Ok(());
            }
            let parent = Path::new(file_name).parent();
            if let Some(parent_path) = parent {
                create_dir_all(parent_path)?;
            }
            let mut file = File::create(file_name)?;
            file.write_all(file_body.as_bytes())?;
            println!("{} {}", Paint::green("Generated:"), file_name);
        }
        Ok(())
    }
}

#[cfg(not(tarpaulin_include))]
#[cfg(test)]
mod tests {
    use super::{DryRunScaffoldExecutor, FSScaffoldExecutor, ScaffoldExecutor};
    use crate::scaffold::Scaffold;
    use std::fs::{create_dir_all, read_to_string, remove_dir_all, write};
    use std::path::Path;

    #[test]
    pub fn dryrun_executor_execute_is_ok() {
        let executor = DryRunScaffoldExecutor {};
        let scaffold = Scaffold::Complete {
            file_name: "Foobar".to_string(),
            file_body: "hello_world".to_string(),
        };
        assert!(executor.execute(&scaffold).is_ok());
    }
    #[test]
    #[cfg_attr(not(feature = "fs-test"), ignore)]
    pub fn fsscaffold_executor_execute_is_not_created_files_when_exiist() {
        let executor = FSScaffoldExecutor {};
        let path = "support/fs_scaffold_executor_execute_when_exist/foobar.md".to_string();

        assert!(create_dir_all(Path::new(&path).parent().unwrap()).is_ok());
        assert!(write(&path, b"dummy").is_ok());

        let scaffold = Scaffold::Complete {
            file_name: path,
            file_body: "hello_world".to_string(),
        };
        assert!(executor.execute(&scaffold).is_ok());
        remove_dir_all("support/fs_scaffold_executor_execute_when_exist").unwrap();
    }

    #[test]
    #[cfg_attr(not(feature = "fs-test"), ignore)]
    pub fn fsscaffold_executor_execute_is_created_files() {
        let executor = FSScaffoldExecutor {};
        let path = "support/fs_scaffold_executor_execute/foobar.md".to_string();
        let scaffold = Scaffold::Complete {
            file_name: path.clone(),
            file_body: "hello_world".to_string(),
        };
        executor.execute(&scaffold).unwrap();
        let actual_file_body = read_to_string(path).expect("file is not found");
        assert_eq!(actual_file_body, "hello_world".to_string());
        remove_dir_all("support/fs_scaffold_executor_execute").unwrap();
    }
}