🔒 Updated dependencies and refactored command utilities.

Author: DerTyp7214

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "gpt-commit-rust"
-version = "0.3.8"
+version = "0.3.9"
 edition = "2021"
 
 [dependencies]

Cargo.toml

@@ -1,79 +1,41 @@
 use colored::*;
-use std::process::{Child, Command};
+use std::process::Command;
 
-pub fn run_commands(commands: &str) {
-    if commands.contains(" && ") {
-        return run_and_commands(commands);
-    }
-
-    if commands.contains(" | ") {
-        return run_pipe_commands(commands);
-    }
-
-    let commands = commands.split('\n');
-    for c in commands {
-        if c.trim() == "" {
-            continue;
-        }
-        run_command(c).unwrap().wait().unwrap();
-    }
-}
-
-fn run_and_commands(commands: &str) {
-    let commands = commands.split(" && ");
-    let mut last_command = None;
-    for c in commands {
-        if c.trim() == "" {
-            continue;
-        }
-        let mut command = run_command(c).unwrap();
-        command.wait().unwrap();
-        last_command = Some(command);
-    }
-    if let Some(mut command) = last_command {
-        command.wait().unwrap();
-    }
-}
-
-fn run_pipe_commands(commands: &str) {
-    let commands = commands.split(" | ");
-    let mut last_command: Option<Child> = None;
+pub fn run_commands(commands: &Vec<Vec<String>>) {
     for c in commands {
-        if c.trim() == "" {
-            continue;
+        let mut command = Command::new(&c[0]);
+        for arg in &c[1..] {
+            command.arg(arg);
         }
-        let mut command = run_command(c).unwrap();
-        if let Some(mut last_command) = last_command {
-            last_command.stdout = command.stdout.take();
-            last_command.wait().unwrap();
-        }
-        last_command = Some(command);
-    }
-    if let Some(mut command) = last_command {
-        command.wait().unwrap();
+        command.spawn().unwrap().wait().unwrap();
     }
 }
 
-fn run_command(command: &str) -> Result<Child, std::io::Error> {
-    let mut parts = command.split_whitespace();
-    let cmd = parts.next().unwrap();
-    let args = parts.collect::<Vec<_>>();
-    let args = args
+pub fn parse_commands(commands: &Vec<Vec<String>>, new_lines: bool) -> String {
+    return commands
         .into_iter()
-        .fold::<Vec<String>, _>(vec![], |mut args, arg| match args.last_mut() {
-            Some(last) if last.starts_with('"') => {
-                *last = format!("{} {}", last, arg);
-                args
-            }
-            _ => {
-                args.push(arg.to_owned());
-                args
-            }
+        .map(|command| {
+            colorize_command(
+                command
+                    .into_iter()
+                    .map(|arg| {
+                        if arg.contains(' ') {
+                            format!("\"{}\"", arg).to_owned()
+                        } else {
+                            arg.to_owned()
+                        }
+                    })
+                    .collect::<Vec<String>>()
+                    .join(" ")
+                    .as_str(),
+            )
         })
-        .into_iter()
-        .map(|arg| arg.replace("\"", ""))
-        .collect::<Vec<_>>();
-    Command::new(cmd).args(args).spawn()
+        .collect::<Vec<_>>()
+        .join(&format!(
+            "{}{}",
+            " &&".bright_black(),
+            if new_lines { "\n" } else { " " }
+        ));
 }
 
 pub fn parse_command(line: &str, new_lines: bool) -> String {

src/command_utils.rs

@@ -3,22 +3,24 @@ use git2::{DiffFormat, DiffOptions, Repository, StatusOptions};
 use normpath::{BasePathBuf, PathExt};
 use std::{path::Path, str};
 
-pub fn build_commands(commit_message: String, include_push: bool) -> String {
+pub fn build_commands(commit_message: String, include_push: bool) -> Vec<Vec<String>> {
     let mut commit_message = commit_message;
 
     if commit_message.starts_with("\"") && commit_message.ends_with("\"") {
         commit_message = commit_message[1..commit_message.len() - 1].to_owned();
     }
 
-    let mut commands = String::new();
-    commands.push_str("git add .");
-    commands.push_str(" && ");
-    commands.push_str("git commit -m");
-    commands.push(' ');
-    commands.push_str(format!("\"{}\"", commit_message).as_str());
+    let mut commands: Vec<Vec<String>> = Vec::new();
+    commands.push("git add .".split(' ').map(|s| s.to_owned()).collect());
+    let mut commit_command: Vec<String> = "git commit -m"
+        .to_owned()
+        .split(' ')
+        .map(|s| s.to_owned())
+        .collect();
+    commit_command.push(commit_message);
+    commands.push(commit_command);
     if include_push {
-        commands.push_str(" && ");
-        commands.push_str("git push");
+        commands.push("git push".split(' ').map(|s| s.to_owned()).collect());
     }
 
     commands

src/git.rs

@@ -12,7 +12,7 @@ use colored::Colorize;
 use gpt_api::query;
 
 use crate::{
-    command_utils::{parse_command, run_commands},
+    command_utils::{parse_command, parse_commands, run_commands},
     git::{build_commands, Git},
     utils::{check_for_update, get_executable_name},
 };
@@ -170,19 +170,15 @@ async fn main() {
 
     loader.stop();
 
-    let mut result = match result {
-        Ok(result) => build_commands(result, false),
+    let result = match result {
+        Ok(result) => build_commands(result, push),
         Err(err) => {
             println!("Error: {}", err);
             return;
         }
     };
 
-    if push {
-        result.push_str(" && git push");
-    }
-
-    let parsed_command = parse_command(&result, true);
+    let parsed_command = parse_commands(&result, true);
 
     println!("{}\n{}", "Commands:".bright_magenta(), parsed_command);
     print!("\n{} {}: ", "Confirm".green(), "(Y/n)");