miana 0.1.0

The is a boilerplate creating tool for diamond standard, it covers diamond standard with Hardhat(JavaScript), Hardhat(Type Script), Foundry, Foundry + Hardhat and the Modular flavour of all this code base.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

use git2::Repository;
use std::error::Error;
use std::fs;






pub const GIT_HARDHAT_JS: &str = "https://github.com/mudgen/diamond-3-hardhat.git";
pub const GIT_HARDHAT_TS: &str = "https://github.com/Timidan/diamond-3-hardhat-typechain.git";
pub const GIT_FOUNDRY_HARDHAT: &str = "https://github.com/Timidan/Foundry-Hardhat-Diamonds.git";
pub const GIT_FOUNDRY: &str = "https://github.com/FydeTreasury/Diamond-Foundry.git";

pub const GIT_MOD_FOUNDRY: &str = "https://github.com/developeruche/modularized-diamond-structure-foundry";
pub const GIT_MOD_FOUNDRY_HARDHAT: &str = "https://github.com/developeruche/modularized-diamond-structure-foundry";
pub const GIT_MOD_HARDHAT: &str = "https://github.com/developeruche/modularized-diamond-stucture-hardhat";




pub enum Template {
    HardhatJS, // hardatjs | hjs
    HardhatTs, // hardatts | hts
    HardhatFoundry, // hardatfoundry | hf
    Foundry // foundry | f
}


pub struct Config {
    pub command: String,
    pub project_name: String,
    pub template: Template,
    pub isModular: bool,
    pub raw: Vec<String>
}

impl Config {
    pub fn new(args: Vec<String>) -> Config {
        // Check if the number of args is correct
        if args.len() < 3 {
            panic!("not enough arguments");
        }
         let is_modular_flag = String::from("--modular");
         let template_flag = String::from("--template");

        // Extracting the args from env::args
        let command = args[1].clone();
        let project_name = args[2].clone();
        let is_modular = args.contains(&is_modular_flag);
        let template_name: String;

        if command != "init" {
            panic!("command not found");
        }

        if project_name == "" {
            panic!("project name not found");
        }

        if args.contains(&template_flag) {
            // get the index of the template flag
            let index = args.iter().position(|r| r == "--template").unwrap();
            
            if let Some(value) = args.get(index + 1) {
                if value == &String::from("") {
                    panic!("bad template name");
                }
                
                template_name = value.clone();
            } else {
                panic!("template name not found");
            }

            match template_name.as_str() {
                "hardhatjs" | "hjs" => {
                    return Config { command, project_name, template: Template::HardhatJS, isModular: is_modular, raw: args.clone() };
                },
                "hardhatts" | "hts" => {
                    return Config { command, project_name, template: Template::HardhatTs, isModular: is_modular, raw: args.clone() };
                },
                "hardhatfoundry" | "hf" => {
                    return Config { command, project_name, template: Template::HardhatFoundry, isModular: is_modular, raw: args.clone() };
                },
                "foundry" | "f" => {
                    return Config { command, project_name, template: Template::Foundry, isModular: is_modular, raw: args.clone() };
                },
                _ => {
                    panic!("template not found");
                }
            }
            
        }
        // Return the Config struct
        Config { command, project_name, template: Template::HardhatJS, isModular: false, raw: args.clone()}
    }
}




pub fn pull(config: &Config) -> Result<(), git2::Error> {
    

    match config.template {
        Template::Foundry => {
            if config.isModular {
                Repository::clone(GIT_MOD_FOUNDRY, config.project_name.clone())?;
            } else {
                Repository::clone(GIT_FOUNDRY, config.project_name.clone())?;
            }
        }
        Template::HardhatFoundry => {
            if config.isModular {
                Repository::clone(GIT_MOD_FOUNDRY_HARDHAT, config.project_name.clone())?;
            } else {
                Repository::clone(GIT_FOUNDRY_HARDHAT, config.project_name.clone())?;
            }
        }
        Template::HardhatJS => {
            if config.isModular {
                Repository::clone(GIT_MOD_HARDHAT, config.project_name.clone())?;
            } else {
                Repository::clone(GIT_HARDHAT_JS, config.project_name.clone())?;
            }
        }
        Template::HardhatTs => {
            if config.isModular {
                Repository::clone(GIT_MOD_HARDHAT, config.project_name.clone())?;
            } else {
                Repository::clone(GIT_HARDHAT_TS, config.project_name.clone())?;
            }
        }
    }



    let _git_path = format!("{}/.git", config.project_name);
    fs::remove_dir_all(_git_path).unwrap();

    println!("Happy hacking !!!");
    Ok(())
}