🚑️ fix

src/bootstrap.rs

@@ -71,36 +71,38 @@ pub struct VarCompare {
     pub eq: String,
 }
 
+type WhenExpression = Either<Option<String>, Option<VarCompare>>;
+
 #[derive(Debug, Deserialize)]
 pub struct ReplaceAction {
-    pub when: Option<Either<String, VarCompare>>,
+    pub when: Option<toml::Value>,
     pub from: String,
-    pub to: String,
+    pub to: Option<String>,
     pub to_var: Option<String>,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct BranchAction {
-    pub when: Option<Either<String, VarCompare>>,
+    pub when: Option<toml::Value>,
     pub branch: String,
 }
 
 #[derive(Debug, Deserialize)]
 pub struct ScriptAction {
-    pub when: Option<Either<String, VarCompare>>,
+    pub when: Option<toml::Value>,
     pub script: String,
     pub expose: Option<Vec<String>>,
 }
 
-pub fn eval(when: &Either<String, VarCompare>, vars: &[AskValue]) -> bool {
+pub fn eval(when: &WhenExpression, vars: &[AskValue]) -> bool {
     if when.is_left() {
-        let when = when.as_ref().left().unwrap();
+        let when = when.as_ref().left().unwrap().as_ref().unwrap();
         let var = vars.into_iter().find(|x| x.has_name(&when)).unwrap();
         if let AskValue::Bool(_, ret) = var {
             return *ret;
         }
     } else {
-        let when = when.as_ref().right().unwrap();
+        let when = when.as_ref().right().unwrap().as_ref().unwrap();
         let var = vars.into_iter().find(|x| x.has_name(&when.var)).unwrap();
         match var {
             AskValue::Text(_, t) => {
@@ -133,10 +135,10 @@ pub fn build_script_vars(expose: Option<Vec<String>>, vars: &[AskValue]) -> Stri
         return exp
             .iter()
             .map(|x| match x {
-                AskValue::Text(name, text) => format!("{name}='{text}'"),
+                AskValue::Text(name, text) => format!("export {name}='{text}'"),
-                AskValue::Number(name, num) => format!("{name}={num}"),
+                AskValue::Number(name, num) => format!("export {name}={num}"),
-                AskValue::Selection(name, select) => format!("{name}='{select}'"),
+                AskValue::Selection(name, select) => format!("export {name}='{select}'"),
-                AskValue::Bool(name, b) => format!("{name}='{}'", b.to_string()),
+                AskValue::Bool(name, b) => format!("export {name}='{}'", b.to_string()),
             })
             .collect::<Vec<_>>()
             .join("\n");
@@ -150,7 +152,7 @@ pub fn do_script(action: &ScriptAction, vars: &[AskValue], name: &str) {
     println!("Running script '{}'", action.script);
     Exec::cmd("sh")
         .arg("-c")
-        .arg(format!("{pre}\n./{}", action.script))
+        .arg(format!("{pre}\nbash {}", action.script))
         .cwd(std::path::Path::new(name))
         .popen()
         .unwrap()
@@ -162,7 +164,7 @@ pub fn do_replace(action: &ReplaceAction, name: &str, vars: &[AskValue]) {
     let to = if let Some(var) = &action.to_var {
         vars.iter().find(|x| x.has_name(var)).unwrap().text()
     } else {
-        action.to.clone()
+        action.to.clone().unwrap()
     };
     println!("Replacing '{}' -> '{}'", action.from, to);
     Exec::cmd("fd")
@@ -221,20 +223,37 @@ pub fn bootstrap(base: &str, name: &str) {
         }
 
         for action in config.actions.branch {
-            if let Some(when) = action.when {
+            if let Some(when) = &action.when {
+                let when = match when {
+                    toml::Value::String(s) => WhenExpression::Left(Some(s.clone())),
+                    toml::Value::Table(map) => WhenExpression::Right(Some(VarCompare {
+                        var: map.get("var").unwrap().as_str().unwrap().to_string(),
+                        eq: map.get("eq").unwrap().as_str().unwrap().to_string(),
+                    })),
+                    _ => panic!("Invalid value in when condition"),
+                };
+
                 if eval(&when, &vars) {
                     println!("Switching to '{}' branch", action.branch);
-                    switch_branch(&action.branch);
+                    switch_branch(&action.branch, name);
                 }
             } else {
                 println!("Switching to '{}' branch", action.branch);
-                switch_branch(&action.branch);
+                switch_branch(&action.branch, name);
             }
         }
 
         for action in config.actions.replace {
             if let Some(when) = &action.when {
-                if eval(when, &vars) {
+                let when = match when {
+                    toml::Value::String(s) => WhenExpression::Left(Some(s.clone())),
+                    toml::Value::Table(map) => WhenExpression::Right(Some(VarCompare {
+                        var: map.get("var").unwrap().as_str().unwrap().to_string(),
+                        eq: map.get("eq").unwrap().as_str().unwrap().to_string(),
+                    })),
+                    _ => panic!("Invalid value in when condition"),
+                };
+                if eval(&when, &vars) {
                     do_replace(&action, name, &vars);
                 }
             } else {
@@ -244,7 +263,16 @@ pub fn bootstrap(base: &str, name: &str) {
 
         for action in config.actions.script {
             if let Some(when) = &action.when {
-                if eval(when, &vars) {
+                let when = match when {
+                    toml::Value::String(s) => WhenExpression::Left(Some(s.clone())),
+                    toml::Value::Table(map) => WhenExpression::Right(Some(VarCompare {
+                        var: map.get("var").unwrap().as_str().unwrap().to_string(),
+                        eq: map.get("eq").unwrap().as_str().unwrap().to_string(),
+                    })),
+                    _ => panic!("Invalid value in when condition"),
+                };
+
+                if eval(&when, &vars) {
                     do_script(&action, &vars, name);
                 }
             } else {

src/git.rs

@@ -13,10 +13,11 @@ pub fn has_remote() -> bool {
     !str.is_empty()
 }
 
-pub fn switch_branch(branch: &str) {
+pub fn switch_branch(branch: &str, repo: &str) {
     let mut git = Exec::cmd("git")
         .arg("checkout")
         .arg(branch)
+        .cwd(std::path::Path::new(repo))
         .popen()
         .unwrap();
     git.wait().unwrap();