without autoescape

cuddle_cli/src/actions/mod.rs

@@ -1 +1,78 @@
+use std::path::PathBuf;
+
+use crate::{
+    actions::shell::ShellAction,
+    model::{CuddleScript, CuddleShellScriptArg, CuddleVariable},
+};
+
 pub mod shell;
+
+#[derive(Debug, Clone)]
+#[allow(dead_code)]
+pub struct CuddleAction {
+    pub script: CuddleScript,
+    pub path: PathBuf,
+    pub name: String,
+}
+#[allow(dead_code)]
+impl CuddleAction {
+    pub fn new(script: CuddleScript, path: PathBuf, name: String) -> Self {
+        Self { script, path, name }
+    }
+
+    pub fn execute(self, variables: Vec<CuddleVariable>) -> anyhow::Result<()> {
+        match self.script {
+            CuddleScript::Shell(s) => {
+                let mut arg_variables: Vec<CuddleVariable> = vec![];
+                if let Some(args) = s.args {
+                    for (k, v) in args {
+                        let var = match v {
+                            CuddleShellScriptArg::Env(e) => {
+                                let env_var = match std::env::var(e.key.clone()) {
+                                    Ok(var) => var,
+                                    Err(e) => {
+                                        log::error!("env_variable not found: {}", k);
+                                        return Err(anyhow::anyhow!(e));
+                                    }
+                                };
+                                CuddleVariable::new(k.clone(), env_var)
+                            }
+                        };
+
+                        arg_variables.push(var);
+                    }
+                } else {
+                    arg_variables = vec![]
+                };
+
+                let mut vars = variables.clone();
+                vars.append(&mut arg_variables);
+
+                log::trace!("preparing to run action");
+
+                match ShellAction::new(
+                    self.name.clone(),
+                    format!(
+                        "{}/scripts/{}.sh",
+                        self.path
+                            .to_str()
+                            .expect("action doesn't have a name, this should never happen"),
+                        self.name
+                    ),
+                )
+                .execute(vars)
+                {
+                    Ok(()) => {
+                        log::trace!("finished running action");
+                        Ok(())
+                    }
+                    Err(e) => {
+                        log::error!("{}", e);
+                        Err(e)
+                    }
+                }
+            }
+            CuddleScript::Dagger(_d) => Err(anyhow::anyhow!("not implemented yet!")),
+        }
+    }
+}