Feature/eirikb/config (#204)

* Ensure piggybacking tools get version from parent - in config!

* Multi Command!

This is not a task runner - I promise!

* Add config version check for tool compatibility in the checker!

Author: eirikb

README.md

@@ -117,6 +117,13 @@ Once defined, aliases can be used directly:
 ./gg.cmd test --coverage # Expands to: ./gg.cmd npm test --coverage
 ```
 
+Aliases support `&&` for sequential execution:
+
+```toml
+[aliases]
+build-and-test = "gradle clean build && npm test"
+```
+
 ### Viewing Configuration
 
 View your current configuration:

src/stage4/src/checker.rs

@@ -297,12 +297,28 @@ pub async fn check_or_update_tool(
     should_update: bool,
     allow_major: bool,
     force: bool,
+    config: &crate::config::GgConfig,
 ) {
     let metas = get_all_tool_metas().await;
 
+    let config_version = config.dependencies.get(tool_name);
+
     let matching_meta = metas.into_iter().find(|(meta, _)| {
         if let Some(executor) = <dyn Executor>::new(meta.cmd.clone()) {
-            executor.get_name() == tool_name
+            let name_matches = executor.get_name() == tool_name;
+
+            if let Some(config_ver) = config_version {
+                if let Some(version_req) = crate::executor::GgVersionReq::new(config_ver) {
+                    if let Some(meta_version) = &meta.download.version {
+                        return name_matches
+                            && version_req
+                                .to_version_req()
+                                .matches(&meta_version.to_version());
+                    }
+                }
+            }
+
+            name_matches
         } else {
             false
         }

src/stage4/src/cli.rs

@@ -165,6 +165,21 @@ impl Cli {
             }
         } else {
             if let Some(first_arg) = self.args.first() {
+                if let Some(alias_commands) = config.resolve_alias_with_and(first_arg) {
+                    if alias_commands.len() > 1 {
+                        return (
+                            vec![ClapCmd {
+                                cmd: format!("__multi_alias__{}", first_arg),
+                                version: None,
+                                distribution: None,
+                                include_tags: HashSet::new(),
+                                exclude_tags: HashSet::new(),
+                            }],
+                            self.args[1..].to_vec(),
+                        );
+                    }
+                }
+
                 if let Some(alias_args) = config.resolve_alias(first_arg) {
                     let mut expanded_args = alias_args;
                     expanded_args.extend_from_slice(&self.args[1..]);
@@ -314,6 +329,16 @@ fn parse_command_string(cmd_string: &str, config: &GgConfig) -> Vec<ClapCmd> {
             if version.is_none() {
                 if let Some(dep_version) = config.dependencies.get(&base_cmd) {
                     version = Some(dep_version.clone());
+                } else {
+                    // Piggybacking!
+                    let underlying_tool = match base_cmd.as_str() {
+                        "npm" | "npx" => "node",
+                        "dart" => "flutter",
+                        _ => &base_cmd,
+                    };
+                    if let Some(dep_version) = config.dependencies.get(underlying_tool) {
+                        version = Some(dep_version.clone());
+                    }
                 }
             }
 

src/stage4/src/config.rs

@@ -71,6 +71,16 @@ impl GgConfig {
             .map(|alias_cmd| shlex::split(alias_cmd).unwrap_or_else(|| vec![alias_cmd.clone()]))
     }
 
+    pub fn resolve_alias_with_and(&self, command: &str) -> Option<Vec<Vec<String>>> {
+        self.aliases.get(command).map(|alias_cmd| {
+            alias_cmd
+                .split("&&")
+                .map(|cmd| cmd.trim())
+                .map(|cmd| shlex::split(cmd).unwrap_or_else(|| vec![cmd.to_string()]))
+                .collect()
+        })
+    }
+
     pub fn init_config() -> Result<(), String> {
         let config_path = Path::new("gg.toml");
 
@@ -196,4 +206,19 @@ test = "npm test"
 
         assert!(config.resolve_alias("nonexistent").is_none());
     }
+
+    #[test]
+    fn test_alias_with_and_operator() {
+        let mut config = GgConfig::default();
+        config.aliases.insert(
+            "build-and-test".to_string(),
+            "gradle clean build && npm test".to_string(),
+        );
+
+        let resolved = config.resolve_alias_with_and("build-and-test").unwrap();
+        assert_eq!(
+            resolved,
+            vec![vec!["gradle", "clean", "build"], vec!["npm", "test"]]
+        );
+    }
 }

src/stage4/src/main.rs

@@ -249,6 +249,37 @@ async fn main() -> ExitCode {
     debug!(target: "main", "{:?}", &cli);
 
     if let Some(cmd) = cmds.first() {
+        if cmd.cmd.starts_with("__multi_alias__") {
+            let alias_name = cmd.cmd.strip_prefix("__multi_alias__").unwrap();
+            if let Some(alias_commands) = config.resolve_alias_with_and(alias_name) {
+                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()));
+
+                    let status = std::process::Command::new(&gg_args[0])
+                        .args(&gg_args[1..])
+                        .status();
+
+                    match status {
+                        Ok(exit_status) => {
+                            if !exit_status.success() {
+                                println!("Command failed: {}", command_args.join(" "));
+                                return ExitCode::from(exit_status.code().unwrap_or(1) as u8);
+                            }
+                        }
+                        Err(e) => {
+                            println!("Failed to execute command: {}", e);
+                            return ExitCode::from(1);
+                        }
+                    }
+                }
+                return ExitCode::from(0);
+            }
+        }
+
         match cmd.cmd.as_str() {
             "update" => {
                 let tool_name = app_args.first().cloned();
@@ -281,6 +312,7 @@ async fn main() -> ExitCode {
                             should_update,
                             allow_major,
                             force,
+                            &config,
                         )
                         .await;
                     }