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
161
162
163
164
165
166
167
168

use indexmap::IndexMap;

#[cfg(feature = "eval-bash")]
use crate::utils::{
    argc_var_name, escape_shell_words, expand_dotenv, AFTER_HOOK, ARGC_REQUIRE_TOOLS, BEFORE_HOOK,
    VARIABLE_PREFIX,
};

#[derive(Debug, PartialEq, Eq)]
pub enum ArgcValue {
    Single(String, String),
    SingleFn(String, String),
    Multiple(String, Vec<String>),
    Map(String, IndexMap<String, Vec<String>>),
    PositionalSingle(String, String),
    PositionalSingleFn(String, String),
    PositionalMultiple(String, Vec<String>),
    ExtraPositionalMultiple(Vec<String>),
    Env(String, String),
    EnvFn(String, String),
    Hook((bool, bool)),
    Dotenv(String),
    RequireTools(Vec<String>),
    CommandFn(String),
    ParamFn(String),
    Error((String, i32)),
}

#[cfg(feature = "eval-bash")]
impl ArgcValue {
    pub fn to_bash(values: &[Self]) -> String {
        let mut list = vec![];
        let mut last = String::new();
        let mut exit = false;
        let mut positional_args = vec![];
        let mut require_tools = vec![];
        let (mut before_hook, mut after_hook) = (false, false);
        for value in values {
            match value {
                ArgcValue::Single(id, value) => {
                    list.push(format!(
                        "{}={}",
                        argc_var_name(id),
                        escape_shell_words(value)
                    ));
                }
                ArgcValue::SingleFn(id, fn_name) => {
                    list.push(format!("{}=`{}`", argc_var_name(id), fn_name,));
                }
                ArgcValue::Multiple(id, values) => {
                    list.push(format!(
                        "{}=( {} )",
                        argc_var_name(id),
                        values
                            .iter()
                            .map(|v| escape_shell_words(v))
                            .collect::<Vec<String>>()
                            .join(" ")
                    ));
                }
                ArgcValue::Map(id, map) => {
                    let var_name = argc_var_name(id);
                    list.push(format!("declare -A {var_name}"));
                    list.extend(map.iter().map(|(k, v)| {
                        let v = v
                            .iter()
                            .map(|x| escape_shell_words(x))
                            .collect::<Vec<String>>()
                            .join("|");
                        format!(r#"{var_name}["{k}"]={v}"#)
                    }));
                }
                ArgcValue::PositionalSingle(id, value) => {
                    let value = escape_shell_words(value);
                    list.push(format!("{}={}", argc_var_name(id), &value));
                    positional_args.push(value);
                }
                ArgcValue::PositionalSingleFn(id, fn_name) => {
                    list.push(format!("{}=`{}`", argc_var_name(id), &fn_name));
                    positional_args.push(format!("`{}`", fn_name));
                }
                ArgcValue::PositionalMultiple(id, values) => {
                    let values = values
                        .iter()
                        .map(|v| escape_shell_words(v))
                        .collect::<Vec<String>>();
                    list.push(format!("{}=( {} )", argc_var_name(id), values.join(" ")));
                    positional_args.extend(values);
                }
                ArgcValue::ExtraPositionalMultiple(values) => {
                    let values = values
                        .iter()
                        .map(|v| escape_shell_words(v))
                        .collect::<Vec<String>>();
                    positional_args.extend(values);
                }
                ArgcValue::Env(name, value) => {
                    list.push(format!("export {}={}", name, escape_shell_words(value)));
                }
                ArgcValue::EnvFn(id, fn_name) => {
                    list.push(format!("export {}=`{}`", id, fn_name,));
                }
                ArgcValue::Hook((before, after)) => {
                    if *before {
                        before_hook = *before;
                    }
                    if *after {
                        after_hook = *after;
                    }
                }
                ArgcValue::Dotenv(value) => {
                    list.push(expand_dotenv(value));
                }
                ArgcValue::RequireTools(tools) => {
                    require_tools = tools.to_vec();
                }
                ArgcValue::CommandFn(name) => {
                    if positional_args.is_empty() {
                        last = name.to_string();
                    } else {
                        last = format!("{} {}", name, positional_args.join(" "));
                    }
                    list.push(format!("{}_fn={}", VARIABLE_PREFIX, name));
                }
                ArgcValue::ParamFn(name) => {
                    if positional_args.is_empty() {
                        last.clone_from(name);
                    } else {
                        last = format!("{} {}", name, positional_args.join(" "));
                    }
                    exit = true;
                }
                ArgcValue::Error((error, exit)) => {
                    return format!("command cat >&2 <<-'EOF' \n{}\nEOF\nexit {}", error, exit)
                }
            }
        }

        list.push(format!(
            "{}_positionals=( {} )",
            VARIABLE_PREFIX,
            positional_args.join(" ")
        ));
        if !require_tools.is_empty() {
            let tools = require_tools
                .iter()
                .map(|v| escape_shell_words(v))
                .collect::<Vec<_>>()
                .join(" ");
            list.push(format!(
                "\n{ARGC_REQUIRE_TOOLS}\n_argc_require_tools {tools}\n"
            ));
        }
        if before_hook {
            list.push(BEFORE_HOOK.to_string())
        }
        if !last.is_empty() {
            list.push(last);
            if after_hook {
                list.push(AFTER_HOOK.to_string())
            }
        }
        if exit {
            list.push("exit".to_string());
        }
        list.join("\n")
    }
}