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
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! # scriptengine
//!
//! Facade for all different non OS scripts.
//!

pub(crate) mod generic_script;
mod os_script;
mod rsscript;
pub(crate) mod script_utils;
mod shebang_script;
mod shell_to_batch;

#[cfg(test)]
#[path = "./mod_test.rs"]
mod mod_test;

use crate::environment;
use crate::io;
use crate::types::{ScriptValue, Task};
use std::path::PathBuf;

#[derive(Debug, Clone, PartialEq)]
/// The currently supported engine types
pub(crate) enum EngineType {
    /// OS native script
    OS,
    /// Rust language
    Rust,
    /// shell to windows batch conversion
    Shell2Batch,
    /// Generic script runner
    Generic,
    /// Shebang script runner
    Shebang,
    /// Unsupported type
    Unsupported,
}

pub(crate) fn get_script_text(script: &ScriptValue) -> Vec<String> {
    match script {
        ScriptValue::Text(text) => text.clone(),
        ScriptValue::File(info) => {
            let mut file_path_string = String::new();
            if !info.absolute_path.unwrap_or(false) {
                file_path_string.push_str("${CARGO_MAKE_WORKING_DIRECTORY}/");
            }
            file_path_string.push_str(&info.file);

            // expand env
            let expanded_value = environment::expand_value(&file_path_string);

            let mut file_path = PathBuf::new();
            file_path.push(expanded_value);

            let script_text = io::read_text_file(&file_path);
            let lines: Vec<&str> = script_text.split('\n').collect();

            let mut script_lines: Vec<String> = vec![];

            for line in lines.iter() {
                script_lines.push(line.to_string());
            }

            script_lines
        }
    }
}

pub(crate) fn get_engine_type(task: &Task) -> EngineType {
    match task.script {
        None => EngineType::Unsupported,
        Some(ref script) => {
            match task.script_runner {
                Some(ref script_runner) => {
                    debug!("Checking script runner: {}", script_runner);

                    if script_runner == "@rust" {
                        debug!("Rust script detected.");
                        EngineType::Rust
                    } else if script_runner == "@shell" {
                        debug!("Shell to batch detected.");
                        EngineType::Shell2Batch
                    } else if task.script_extension.is_some() {
                        // if both script runner and extension is defined, we use generic script runner
                        debug!("Generic script detected.");
                        EngineType::Generic
                    } else {
                        // use default OS extension with custom runner
                        debug!("OS script with custom runner detected.");
                        EngineType::OS
                    }
                }
                None => {
                    // if no runner specified, try to extract it from script content
                    let script_text = get_script_text(&script);
                    if shebang_script::is_shebang_exists(&script_text) {
                        EngineType::Shebang
                    } else {
                        EngineType::OS
                    }
                }
            }
        }
    }
}

pub(crate) fn invoke(task: &Task, cli_arguments: &Vec<String>) -> bool {
    let engine_type = get_engine_type(&task);
    let validate = !task.should_ignore_errors();

    match engine_type {
        EngineType::OS => {
            let script = task.script.as_ref().unwrap();
            let script_text = get_script_text(&script);
            let runner = task.script_runner.clone();
            os_script::execute(&script_text, runner, cli_arguments, validate);

            true
        }
        EngineType::Rust => {
            let script = task.script.as_ref().unwrap();
            let script_text = get_script_text(&script);
            rsscript::execute(&script_text, cli_arguments, validate);

            true
        }
        EngineType::Shell2Batch => {
            let script = task.script.as_ref().unwrap();
            let script_text = get_script_text(&script);
            shell_to_batch::execute(&script_text, cli_arguments, validate);

            true
        }
        EngineType::Generic => {
            let script = task.script.as_ref().unwrap();
            let script_text = get_script_text(&script);
            let runner = task.script_runner.clone().unwrap();
            let extension = task.script_extension.clone().unwrap();
            generic_script::execute(
                &script_text,
                runner,
                extension,
                None,
                cli_arguments,
                validate,
            );

            true
        }
        EngineType::Shebang => {
            let script = task.script.as_ref().unwrap();
            let script_text = get_script_text(&script);
            let extension = task.script_extension.clone();
            shebang_script::execute(&script_text, &extension, cli_arguments, validate);

            true
        }
        EngineType::Unsupported => false,
    }
}