Feature/eirikb/multi config fix (#205)

* Fix multi-config runner

It needs special special handling in order to support both gg aliases and direct commands!

* Update readme to show advanced-ish setup of alias sequential run

Author: eirikb

README.md

@@ -121,7 +121,8 @@ Aliases support `&&` for sequential execution:
 
 ```toml
 [aliases]
-build-and-test = "gradle clean build && npm test"
+clean-build = "gradle clean build"
+build-and-test = "clean-build && npm test"
 ```
 
 ### Viewing Configuration

src/stage4/src/main.rs

@@ -255,13 +255,63 @@ async fn main() -> ExitCode {
                 for command_args in alias_commands {
                     println!("Executing: {}", command_args.join(" "));
 
-                    let mut gg_args =
-                        vec![env::current_exe().unwrap().to_string_lossy().to_string()];
-                    gg_args.extend(command_args.iter().map(|s| s.to_string()));
+                    if command_args.is_empty() {
+                        continue;
+                    }
 
-                    let status = std::process::Command::new(&gg_args[0])
-                        .args(&gg_args[1..])
-                        .status();
+                    let execute_as_gg_command = |args: &[String]| {
+                        let mut gg_args = vec![env::args().next().unwrap_or_else(|| {
+                            env::current_exe().unwrap().to_string_lossy().to_string()
+                        })];
+                        gg_args.extend(args.iter().map(|s| s.to_string()));
+                        std::process::Command::new(&gg_args[0])
+                            .args(&gg_args[1..])
+                            .status()
+                    };
+
+                    let status = if command_args.len() == 1 {
+                        if let Some(nested_alias_commands) =
+                            config.resolve_alias_with_and(&command_args[0])
+                        {
+                            let mut all_success = true;
+                            for nested_command_args in nested_alias_commands {
+                                if nested_command_args.is_empty() {
+                                    continue;
+                                }
+                                let nested_status =
+                                    std::process::Command::new(&nested_command_args[0])
+                                        .args(&nested_command_args[1..])
+                                        .status();
+                                match nested_status {
+                                    Ok(exit_status) => {
+                                        if !exit_status.success() {
+                                            all_success = false;
+                                            break;
+                                        }
+                                    }
+                                    Err(_) => {
+                                        all_success = false;
+                                        break;
+                                    }
+                                }
+                            }
+                            if all_success {
+                                std::process::Command::new("true").status()
+                            } else {
+                                std::process::Command::new("false").status()
+                            }
+                        } else if let Some(nested_alias_args) =
+                            config.resolve_alias(&command_args[0])
+                        {
+                            execute_as_gg_command(&nested_alias_args)
+                        } else {
+                            execute_as_gg_command(&command_args)
+                        }
+                    } else {
+                        std::process::Command::new(&command_args[0])
+                            .args(&command_args[1..])
+                            .status()
+                    };
 
                     match status {
                         Ok(exit_status) => {