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

use run_script::ScriptOptions;
mod rs_files;

pub fn with_script(args: &Vec<String>, mode: &str, file_name: &str) {
    let options = ScriptOptions::new();
    if !mode.is_empty() {
        let code_name :&str = &format!("{}_{}", file_name, mode);
        let rs_code = rs_files::get_rs(code_name);
        let set_file = format!("echo '{}'", rs_code);
        let cmd_echo = format!("echo '{}' > {}.rs", rs_code, file_name);
        let cargo_script = format!("cargo script {}.rs", file_name);
        let rm_script = format!("rm -rf {}.rs", file_name);
        //dbg!(&rs_code);
        //dbg!(&cargo_script);
        //let cmds = format!("{}", &set_file);
        let cmds = format!(
            "{}\n{}\n{}\n{}",
            &set_file, &cmd_echo, &cargo_script, &rm_script
        );
        let (_code, output, error) = run_script::run(&cmds, &args, &options).unwrap();
        //println!("Exit Code: {}\n\n", code);
        println!("{}\n\n", output);
        println!("Compiler: Output Info  >>>>>>>>>>>>>> :\n\n{}", error);
    } else {
        //
    }
}

/*
pub fn with_mode(args: &Vec<String>, mode: &str, file_name: &str) {
    let options = ScriptOptions::new();
    let rs_file: &str = &format!("RS_FILE=./examples/{}.rs", file_name);
    let cmd_cargo;
    // cargo run --bin bw -- -f kw_let -m error | bat -l rs
    // cargo run --bin bw -- --file kw_let --mode ok
    // cargo run --bin bw -- --file kw_let --mode err
    // is equal to
    // # cargo run --example kw_let --features ok
    // # cargo run --example kw_let --features err
    cmd_cargo = format!("cargo run --example {} --features '{}'", file_name, mode);
    dbg!(&cmd_cargo);
    let cmds = format!("{}\n{}\n{}", rs_file, &cmd_cargo, RUM_CMD_BAT);
    let (_code, output, error) = run_script::run(&cmds, &args, &options).unwrap();
    //println!("Exit Code: {}\n\n", code);
    println!("{}\n\n", output);
    println!("Compiler: Output Info  >>>>>>>>>>>>>> :\n\n{}", error);
}
*/

pub fn without_mode(args: &Vec<String>, file_name: &str) {
    let options = ScriptOptions::new();
    let cmd_cargo;
    match file_name.as_ref() {
        "bwx" => {
            // cargo run --bin bw -- -f bwx
            // # cargo run --bin bwx            
            cmd_cargo = format!("cargo run --bin {}", file_name);
            dbg!(&cmd_cargo);
            let cmds = format!("{}", &cmd_cargo);
            let (_code, output, error) = run_script::run(&cmds, &args, &options).unwrap();
            println!("{}", output);
            dbg!(error);
        }
        _ => {
            println!("\n\nList commands with all features for this code {}:\n", file_name);
            for item in rs_files::FEATURE_MODE.iter() {
                let code_name = &format!("{}_{}", file_name, item);
                let result = rs_files::get_rs(code_name);
                if result != rs_files::HELLO {
                    println!("bw -c {} -f {} | bat -l rs", file_name, item);
                    //println!("cargo run --bin bw -- -c {} -f {} | bat -l rs\n", file_name, item);
                }
            }
            
            // # cargo run --bin bwx allx
            // # cargo run --bin bwx devx

            //cmd_cargo = format!("cargo run --bin bwx {}", file_name);
            //let cmds = format!("{}", &cmd_cargo);
            //let (_code, output, error) = run_script::run(&cmds, &args, &options).unwrap();
            //println!("{}", output);
            //dbg!(error);
        }
    }
}

//const RUM_CMD_BAT: &str = r#"bat $RS_FILE"#;

// https://doc.rust-lang.org/rust-by-example/std_misc/arg/matching.html
// https://doc.rust-lang.org/rust-by-example/flow_control/match.html

// 题外话
// https://doc.rust-lang.org/rust-by-example/flow_control/match.html
// https://stackoverflow.com/questions/25383488/how-to-match-a-string-against-string-literals-in-rust