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
//! # 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::types::Task;

#[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_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
                    if shebang_script::is_shebang_exists(script) {
                        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 runner = task.script_runner.clone();
            os_script::execute(script, runner, cli_arguments, validate);

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

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

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

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

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