feat: support apply user config

Cargo.toml

@@ -12,6 +12,8 @@ clap = { version = "4.5.4", features = ["derive"] }
 console = "0.15.8"
 dialoguer = "0.11.0"
 dirs = "5.0.1"
+git2 = { version = "0.19.0", features = [] }
 regex = "1.10.5"
+rust-ini = "0.21.0"
 serde = {version = "1.0.203", features = ["derive"] }
 serde_json = "1.0.117"

src/process/clone_repo.rs

@@ -29,11 +29,6 @@ fn get_repo_local_path(git_url: &GitUrl, global_config: &GlobalConfig) -> Result
 }
 
 fn call_git_clone_command(url: &str, repo_path: &Path) -> Result<()> {
-  run_piped_command(vec![
-    "git".to_string(),
-    "clone".to_string(),
-    url.to_string(),
-    repo_path.to_string_lossy().to_string(),
-  ])?;
+  run_piped_command(vec!["git", "clone", url, repo_path.to_str().unwrap()])?;
   Ok(())
 }

src/process/git_user_config/add.rs

@@ -1,6 +1,5 @@
 use crate::{GitUserConfig, GlobalConfig};
 use anyhow::{Ok, Result};
-use console::style;
 use dialoguer::Input;
 use regex::Regex;
 
@@ -46,12 +45,7 @@ pub fn add() -> Result<()> {
 
   GitUserConfig::new(&config_id, &name, &email).add()?;
 
-  println!(
-    "Git user config {}({}<{}>) added successfully!",
-    style(&config_id).bold(),
-    style(&name).bold(),
-    style(&email).bold()
-  );
+  println!("Git user config added successfully!",);
 
   Ok(())
 }

src/process/git_user_config/apply.rs

@@ -1,6 +1,27 @@
-use anyhow::Result;
+use crate::{run_piped_command, GitUserConfig};
+use anyhow::{Ok, Result};
+use git2::Repository;
+use std::{env, path::Path};
 
 /// apply git config to current directory
-pub fn apply(_config_id: String) -> Result<()> {
-  Ok(())
+pub fn apply(config_id: String) -> Result<()> {
+  // check if it is a git repository
+  if !is_git_repo(env::current_dir()?) {
+    return Err(anyhow::anyhow!("The current directory is not a git repository"));
+  }
+
+  let git_user_configs = GitUserConfig::get_all()?;
+  let git_user_config = git_user_configs.iter().find(|c| c.config_id == config_id);
+  match git_user_config {
+    Some(git_user_config) => {
+      run_piped_command(vec!["git", "config", "user.name", git_user_config.name.as_str()])?;
+      run_piped_command(vec!["git", "config", "user.email", git_user_config.email.as_str()])?;
+      Ok(())
+    }
+    None => Err(anyhow::anyhow!("Config id: {} is not found", config_id)),
+  }
+}
+
+fn is_git_repo<P: AsRef<Path>>(path: P) -> bool {
+  Repository::open(path).is_ok()
 }

src/utils/get_git_user_config_id.rs

@@ -21,9 +21,16 @@ pub fn get_git_user_config_id(raw_config_id: Option<String>) -> anyhow::Result<S
         })
         .collect::<Vec<String>>();
 
+      if items.is_empty() {
+        return Err(anyhow::anyhow!(
+          "No git user config found. Please add one by running `gitez user-config add`"
+        ));
+      }
+
       let selection = Select::new()
-        .with_prompt("Chose the user config you want to remove")
+        .with_prompt("choose the user config you want to remove")
         .items(&items)
+        .default(0)
         .interact()?;
       let selected_config_id = &git_user_configs[selection].config_id;
 

src/utils/global_config.rs

@@ -5,7 +5,8 @@ use std::path::PathBuf;
 
 use crate::GitUserConfig;
 
-const CONFIG_NAME: &str = ".gitez.json";
+pub const DIR: &str = ".gitez";
+const CONFIG_FILENAME: &str = "config.json";
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct GlobalConfig {
@@ -16,34 +17,43 @@ pub struct GlobalConfig {
 impl GlobalConfig {
   pub fn init() -> Result<()> {
     let config_path = GlobalConfig::config_path();
+    Self::init_dir()?;
     if !config_path.exists() {
-      fs::write(config_path, "{ git_user_configs: [] }")
-        .map_err(|err| anyhow::anyhow!("Unable to create {}. Reason: {}", CONFIG_NAME, err))?;
+      fs::write(&config_path, "{ \"git_user_configs\": [] }")
+        .map_err(|err| anyhow::anyhow!("Unable to create {}. Reason: {}", config_path.display(), err))?;
+    }
+    Ok(())
+  }
+  fn init_dir() -> Result<()> {
+    let config_path = GlobalConfig::config_path();
+    let dir = config_path.parent().unwrap();
+    if !dir.exists() {
+      fs::create_dir(dir).map_err(|err| anyhow::anyhow!("Unable to create {}. Reason: {}", dir.display(), err))?;
     }
     Ok(())
   }
   pub fn config_path() -> PathBuf {
     match dirs::home_dir() {
-      // The path is ～/.gitez.json
-      Some(home_dir) => home_dir.join(CONFIG_NAME),
-      None => PathBuf::from(CONFIG_NAME),
+      // The path is ～/.gitez/config.json
+      Some(home_dir) => home_dir.join(DIR).join(CONFIG_FILENAME),
+      None => PathBuf::from(DIR).join(CONFIG_FILENAME),
     }
   }
   pub fn new() -> Result<Self> {
     let config_path = GlobalConfig::config_path();
-    let config_str = fs::read_to_string(config_path)
-      .map_err(|err| anyhow::anyhow!("Unable to create {}. Reason: {}", CONFIG_NAME, err))?;
+    let config_str = fs::read_to_string(&config_path)
+      .map_err(|err| anyhow::anyhow!("Unable to create {}. Reason: {}", config_path.display(), err))?;
     let config = serde_json::from_str::<GlobalConfig>(&config_str)
-      .map_err(|err| anyhow::anyhow!("Unable to parse {}. Reason: {}", CONFIG_NAME, err))?;
+      .map_err(|err| anyhow::anyhow!("Unable to parse {}. Reason: {}", config_path.display(), err))?;
     Ok(config)
   }
 
   pub fn save(&self) -> Result<()> {
     let config_path = GlobalConfig::config_path();
     let config_str = serde_json::to_string_pretty(&self)
-      .map_err(|err| anyhow::anyhow!("Unable to serialize {}. Reason: {}", CONFIG_NAME, err))?;
-    fs::write(config_path, config_str)
-      .map_err(|err| anyhow::anyhow!("Unable to write {}. Reason: {}", CONFIG_NAME, err))?;
+      .map_err(|err| anyhow::anyhow!("Unable to serialize {}. Reason: {}", config_path.display(), err))?;
+    fs::write(&config_path, config_str)
+      .map_err(|err| anyhow::anyhow!("Unable to write {}. Reason: {}", config_path.display(), err))?;
     Ok(())
   }
 }

src/utils/shell.rs

@@ -14,17 +14,17 @@ fn get_shell_name() -> String {
   }
 }
 
-fn get_shell_args(args: Vec<String>) -> Vec<String> {
+fn get_shell_args(args: Vec<&str>) -> Vec<String> {
   // windows
   if cfg!(windows) {
-    vec!["/c".to_string(), args.join(" ")]
+    ["/c", &args.join(" ")].iter().map(|s| s.to_string()).collect()
   } else {
     // linux / macOS
-    vec!["-c".to_string(), args.join(" ")]
+    ["-c", &args.join(" ")].iter().map(|s| s.to_string()).collect()
   }
 }
 
-pub fn run_piped_command(args: Vec<String>) -> Result<()> {
+pub fn run_piped_command(args: Vec<&str>) -> Result<()> {
   let shell_name = get_shell_name();
   let shell_args = get_shell_args(args);