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
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)]
pub(crate) enum EngineType {
OS,
Rust,
Shell2Batch,
Generic,
Shebang,
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() {
debug!("Generic script detected.");
EngineType::Generic
} else {
debug!("OS script with custom runner detected.");
EngineType::OS
}
}
None => {
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,
}
}