chore: clippy fix

Author: Sidharth-Singh10

src/auth/git_http.rs

@@ -16,7 +16,7 @@ pub fn try_userpass_authentication(username_from_url: Option<&str>) -> Result<Cr
                 Error::new(
                     ErrorCode::Auth,
                     ErrorClass::Net,
-                    format!("Failed to read username: {}", e),
+                    format!("Failed to read username: {e}"),
                 )
             })?
     };
@@ -28,7 +28,7 @@ pub fn try_userpass_authentication(username_from_url: Option<&str>) -> Result<Cr
             Error::new(
                 ErrorCode::Auth,
                 ErrorClass::Net,
-                format!("Failed to read token: {}", e),
+                format!("Failed to read token: {e}"),
             )
         })?;
 
@@ -40,7 +40,7 @@ pub fn try_userpass_authentication(username_from_url: Option<&str>) -> Result<Cr
                 Ok(cred)
             }
             Err(e) => {
-                debug!("Username/token authentication failed: {}", e);
+                debug!("Username/token authentication failed: {e}");
                 Err(e)
             }
         }

src/auth/git_ssh.rs

@@ -12,17 +12,15 @@ pub fn ssh_authenticate_git(
     attempt_count: usize,
 ) -> Result<Cred, Error> {
     debug!(
-        "Git authentication attempt #{} for URL: {}",
-        attempt_count, url
+        "Git authentication attempt #{attempt_count} for URL: {url}"
     );
-    debug!("Username from URL: {:?}", username_from_url);
-    debug!("Allowed credential types: {:?}", allowed_types);
+    debug!("Username from URL: {username_from_url:?}");
+    debug!("Allowed credential types: {allowed_types:?}");
 
     // Prevent infinite loops
     if attempt_count > 3 {
         debug!(
-            "Too many authentication attempts ({}), failing to prevent infinite loop",
-            attempt_count
+            "Too many authentication attempts ({attempt_count}), failing to prevent infinite loop"
         );
         return Err(Error::new(
             ErrorCode::Auth,
@@ -40,7 +38,7 @@ pub fn ssh_authenticate_git(
                 debug!("Second attempt: trying to add SSH keys to agent before authentication");
                 if std::env::var("SSH_AUTH_SOCK").is_ok() {
                     if let Err(e) = add_all_ssh_keys() {
-                        debug!("Failed to add keys to ssh-agent on second attempt: {}", e);
+                        debug!("Failed to add keys to ssh-agent on second attempt: {e}");
                     } else {
                         debug!("Keys added to ssh-agent, proceeding with authentication");
                     }
@@ -56,18 +54,17 @@ pub fn ssh_authenticate_git(
     }
 
     debug!(
-        "All authentication methods failed for attempt {}",
-        attempt_count
+        "All authentication methods failed for attempt {attempt_count}"
     );
     Err(Error::new(
         ErrorCode::Auth,
         ErrorClass::Net,
-        format!("Authentication failed - attempt {}", attempt_count),
+        format!("Authentication failed - attempt {attempt_count}"),
     ))
 }
 
 fn try_ssh_agent_auth(username: &str) -> Result<Cred, Error> {
-    debug!("Attempting SSH agent authentication for user: {}", username);
+    debug!("Attempting SSH agent authentication for user: {username}");
 
     if std::env::var("SSH_AUTH_SOCK").is_err() {
         debug!("SSH_AUTH_SOCK not set, attempting to spawn ssh-agent and add keys");
@@ -81,7 +78,7 @@ fn try_ssh_agent_auth(username: &str) -> Result<Cred, Error> {
             Ok(cred)
         }
         Err(e) => {
-            debug!("SSH agent authentication failed: {}", e);
+            debug!("SSH agent authentication failed: {e}");
 
             // Fallback to trying SSH key files directly
             debug!("Falling back to direct SSH key file authentication");
@@ -97,7 +94,7 @@ fn spawn_ssh_agent_and_add_keys() -> Result<(), Error> {
         Error::new(
             ErrorCode::Auth,
             ErrorClass::Net,
-            format!("Failed to spawn ssh-agent: {}", e),
+            format!("Failed to spawn ssh-agent: {e}"),
         )
     })?;
 
@@ -110,15 +107,15 @@ fn spawn_ssh_agent_and_add_keys() -> Result<(), Error> {
     }
 
     let agent_output = String::from_utf8_lossy(&output.stdout);
-    debug!("ssh-agent output: {}", agent_output);
+    debug!("ssh-agent output: {agent_output}");
 
     let env_vars = parse_ssh_agent_output(&agent_output);
 
     for (key, value) in &env_vars {
         unsafe {
             std::env::set_var(key, value);
         }
-        debug!("Set environment variable: {}={}", key, value);
+        debug!("Set environment variable: {key}={value}");
     }
 
     if !env_vars.contains_key("SSH_AUTH_SOCK") {
@@ -144,7 +141,7 @@ fn add_all_ssh_keys() -> Result<(), Error> {
     let ssh_dir = Path::new(&home_dir).join(".ssh");
 
     if !ssh_dir.exists() {
-        debug!("SSH directory {:?} does not exist", ssh_dir);
+        debug!("SSH directory {ssh_dir:?} does not exist");
         return Ok(());
     }
 
@@ -155,7 +152,7 @@ fn add_all_ssh_keys() -> Result<(), Error> {
         let key_path = ssh_dir.join(key_name);
 
         if key_path.exists() {
-            debug!("Found SSH key: {:?}", key_path);
+            debug!("Found SSH key: {key_path:?}");
 
             // First try a quick non-interactive add (for keys without passphrase)
             let quick_result = Command::new("ssh-add")
@@ -171,58 +168,56 @@ fn add_all_ssh_keys() -> Result<(), Error> {
 
             match quick_result {
                 Ok(output) if output.status.success() => {
-                    debug!("Successfully added key without interaction: {}", key_name);
+                    debug!("Successfully added key without interaction: {key_name}");
                     added_count += 1;
                 }
                 Ok(output) => {
                     let stderr = String::from_utf8_lossy(&output.stderr);
-                    debug!("Quick add failed for {}: {}", key_name, stderr);
+                    debug!("Quick add failed for {key_name}: {stderr}");
 
                     debug!(
-                        "Key {} appears to need passphrase, trying interactive add",
-                        key_name
+                        "Key {key_name} appears to need passphrase, trying interactive add"
                     );
 
                     match add_key_interactive(&key_path, key_name) {
                         Ok(true) => {
-                            debug!("Successfully added key interactively: {}", key_name);
+                            debug!("Successfully added key interactively: {key_name}");
                             added_count += 1;
                         }
                         Ok(false) => {
-                            debug!("User skipped key: {}", key_name);
+                            debug!("User skipped key: {key_name}");
                         }
                         Err(e) => {
-                            debug!("Interactive add failed for {}: {}", key_name, e);
+                            debug!("Interactive add failed for {key_name}: {e}");
                         }
                     }
                 }
                 Err(e) => {
-                    debug!("Error running ssh-add for {}: {}", key_name, e);
+                    debug!("Error running ssh-add for {key_name}: {e}");
                 }
             }
         } else {
-            debug!("SSH key not found: {:?}", key_path);
+            debug!("SSH key not found: {key_path:?}");
         }
     }
 
-    debug!("Added {} SSH keys to ssh-agent", added_count);
+    debug!("Added {added_count} SSH keys to ssh-agent");
 
     if added_count == 0 {
         debug!("No SSH keys were added");
         println!("No SSH keys were added to ssh-agent.");
         println!("You may need to generate SSH keys or check your ~/.ssh directory.");
     } else {
         println!(
-            "Successfully added {} SSH key(s) to ssh-agent.",
-            added_count
+            "Successfully added {added_count} SSH key(s) to ssh-agent."
         );
     }
 
     Ok(())
 }
 
 fn try_ssh_key_files_directly(username: &str) -> Result<Cred, Error> {
-    debug!("Trying SSH key files directly for user: {}", username);
+    debug!("Trying SSH key files directly for user: {username}");
 
     let home_dir = std::env::var("HOME")
         .or_else(|_| std::env::var("USERPROFILE"))
@@ -233,10 +228,10 @@ fn try_ssh_key_files_directly(username: &str) -> Result<Cred, Error> {
 
     for key_name in &key_files {
         let private_key_path = ssh_dir.join(key_name);
-        let public_key_path = ssh_dir.join(format!("{}.pub", key_name));
+        let public_key_path = ssh_dir.join(format!("{key_name}.pub"));
 
         if private_key_path.exists() && public_key_path.exists() {
-            debug!("Trying SSH key pair: {} / {}.pub", key_name, key_name);
+            debug!("Trying SSH key pair: {key_name} / {key_name}.pub");
 
             match Cred::ssh_key(
                 username,
@@ -245,11 +240,11 @@ fn try_ssh_key_files_directly(username: &str) -> Result<Cred, Error> {
                 None, // No passphrase for now
             ) {
                 Ok(cred) => {
-                    debug!("SSH key authentication succeeded with {}", key_name);
+                    debug!("SSH key authentication succeeded with {key_name}");
                     return Ok(cred);
                 }
                 Err(e) => {
-                    debug!("SSH key authentication failed with {}: {}", key_name, e);
+                    debug!("SSH key authentication failed with {key_name}: {e}");
                 }
             }
         }

src/auth/ssh_utils.rs

@@ -26,30 +26,29 @@ pub fn parse_ssh_agent_output(output: &str) -> HashMap<String, String> {
 }
 
 pub fn add_key_interactive(key_path: &Path, key_name: &str) -> Result<bool, Error> {
-    debug!("Trying interactive ssh-add for key: {}", key_name);
+    debug!("Trying interactive ssh-add for key: {key_name}");
 
     // Ask user if they want to add this key interactively
     let should_add = Confirm::with_theme(&ColorfulTheme::default())
         .with_prompt(format!(
-            "Add SSH key '{}' to ssh-agent? (you may be prompted for passphrase)",
-            key_name
+            "Add SSH key '{key_name}' to ssh-agent? (you may be prompted for passphrase)"
         ))
         .default(true)
         .interact()
         .map_err(|e| {
             Error::new(
                 ErrorCode::Auth,
                 ErrorClass::Net,
-                format!("Failed to get user confirmation: {}", e),
+                format!("Failed to get user confirmation: {e}"),
             )
         })?;
 
     if !should_add {
-        debug!("User chose not to add key: {}", key_name);
+        debug!("User chose not to add key: {key_name}");
         return Ok(false);
     }
 
-    println!("Adding SSH key: {}", key_name);
+    println!("Adding SSH key: {key_name}");
     println!("If the key is passphrase-protected, you will be prompted to enter it.");
 
     // Use interactive ssh-add - this will prompt the user directly in the terminal
@@ -67,17 +66,17 @@ pub fn add_key_interactive(key_path: &Path, key_name: &str) -> Result<bool, Erro
             Error::new(
                 ErrorCode::Auth,
                 ErrorClass::Net,
-                format!("Failed to spawn ssh-add: {}", e),
+                format!("Failed to spawn ssh-add: {e}"),
             )
         })?;
 
     if status.success() {
-        debug!("Successfully added key: {}", key_name);
-        println!("✓ SSH key '{}' added successfully!", key_name);
+        debug!("Successfully added key: {key_name}");
+        println!("✓ SSH key '{key_name}' added successfully!");
         Ok(true)
     } else {
-        debug!("Interactive ssh-add failed for key: {}", key_name);
-        println!("✗ Failed to add SSH key '{}'", key_name);
+        debug!("Interactive ssh-add failed for key: {key_name}");
+        println!("✗ Failed to add SSH key '{key_name}'");
         Ok(false)
     }
 }