Fix tests

Author: simeg

src/cli.rs

@@ -110,7 +110,10 @@ pub enum StashBranchAction {
     },
     #[clap(about = "Clean old stashes")]
     Clean {
-        #[clap(long = "older-than", help = "Remove stashes older than (e.g., '7d', '2w', '1m')")]
+        #[clap(
+            long = "older-than",
+            help = "Remove stashes older than (e.g., '7d', '2w', '1m')"
+        )]
         older_than: Option<String>,
         #[clap(long = "dry-run", help = "Show what would be cleaned without doing it", action = clap::ArgAction::SetTrue)]
         dry_run: bool,

src/fixup.rs

@@ -57,7 +57,11 @@ pub fn run(commit_hash: String, rebase: bool) {
 // Helper function to validate commit hash exists
 fn validate_commit_hash(commit_hash: &str) -> Result<(), &'static str> {
     let output = Command::new("git")
-        .args(["rev-parse", "--verify", &format!("{commit_hash}^{{commit}}")])
+        .args([
+            "rev-parse",
+            "--verify",
+            &format!("{commit_hash}^{{commit}}"),
+        ])
         .output()
         .map_err(|_| "Failed to validate commit hash")?;
 
@@ -216,4 +220,4 @@ pub fn get_commit_hash_validation_rules() -> &'static [&'static str] {
         "Must contain only hex characters (0-9, a-f)",
         "Must reference an existing commit",
     ]
-}
+}

src/main.rs

@@ -25,7 +25,10 @@ fn main() {
         Commands::Sync { merge } => sync::run(merge),
         Commands::New { branch_name, from } => new_branch::run(branch_name, from),
         Commands::LargeFiles { limit, threshold } => large_files::run(limit, threshold),
-        Commands::Fixup { commit_hash, rebase } => fixup::run(commit_hash, rebase),
+        Commands::Fixup {
+            commit_hash,
+            rebase,
+        } => fixup::run(commit_hash, rebase),
         Commands::StashBranch { action } => stash_branch::run(action),
         Commands::Upstream { action } => upstream::run(action),
     }

src/stash_branch.rs

@@ -3,15 +3,18 @@ use std::process::Command;
 
 pub fn run(action: StashBranchAction) {
     match action {
-        StashBranchAction::Create { branch_name, stash_ref } => {
-            create_branch_from_stash(branch_name, stash_ref)
-        }
-        StashBranchAction::Clean { older_than, dry_run } => {
-            clean_old_stashes(older_than, dry_run)
-        }
-        StashBranchAction::ApplyByBranch { branch_name, list_only } => {
-            apply_stashes_by_branch(branch_name, list_only)
-        }
+        StashBranchAction::Create {
+            branch_name,
+            stash_ref,
+        } => create_branch_from_stash(branch_name, stash_ref),
+        StashBranchAction::Clean {
+            older_than,
+            dry_run,
+        } => clean_old_stashes(older_than, dry_run),
+        StashBranchAction::ApplyByBranch {
+            branch_name,
+            list_only,
+        } => apply_stashes_by_branch(branch_name, list_only),
     }
 }
 
@@ -81,7 +84,10 @@ fn clean_old_stashes(older_than: Option<String>, dry_run: bool) {
         return;
     }
 
-    println!("{}", format_stashes_to_clean_message(stashes_to_clean.len(), dry_run));
+    println!(
+        "{}",
+        format_stashes_to_clean_message(stashes_to_clean.len(), dry_run)
+    );
 
     for stash in &stashes_to_clean {
         println!("  {}", format_stash_entry(&stash.name, &stash.message));
@@ -90,10 +96,16 @@ fn clean_old_stashes(older_than: Option<String>, dry_run: bool) {
     if !dry_run {
         for stash in &stashes_to_clean {
             if let Err(msg) = delete_stash(&stash.name) {
-                eprintln!("{}", format_error_message(&format!("Failed to delete {}: {}", stash.name, msg)));
+                eprintln!(
+                    "{}",
+                    format_error_message(&format!("Failed to delete {}: {}", stash.name, msg))
+                );
             }
         }
-        println!("{}", format_cleanup_complete_message(stashes_to_clean.len()));
+        println!(
+            "{}",
+            format_cleanup_complete_message(stashes_to_clean.len())
+        );
     }
 }
 
@@ -119,13 +131,19 @@ fn apply_stashes_by_branch(branch_name: String, list_only: bool) {
     }
 
     if list_only {
-        println!("{}", format_stashes_for_branch_header(&branch_name, branch_stashes.len()));
+        println!(
+            "{}",
+            format_stashes_for_branch_header(&branch_name, branch_stashes.len())
+        );
         for stash in &branch_stashes {
             println!("  {}", format_stash_entry(&stash.name, &stash.message));
         }
     } else {
-        println!("{}", format_applying_stashes_message(&branch_name, branch_stashes.len()));
-        
+        println!(
+            "{}",
+            format_applying_stashes_message(&branch_name, branch_stashes.len())
+        );
+
         for stash in &branch_stashes {
             match apply_stash(&stash.name) {
                 Ok(()) => println!("  ✅ Applied {}", stash.name),
@@ -168,7 +186,12 @@ fn validate_branch_name(name: &str) -> Result<(), &'static str> {
 // Helper function to check if branch exists
 fn branch_exists(branch_name: &str) -> bool {
     Command::new("git")
-        .args(["show-ref", "--verify", "--quiet", &format!("refs/heads/{branch_name}")])
+        .args([
+            "show-ref",
+            "--verify",
+            "--quiet",
+            &format!("refs/heads/{branch_name}"),
+        ])
         .status()
         .map(|status| status.success())
         .unwrap_or(false)
@@ -287,7 +310,7 @@ fn extract_branch_from_message(message: &str) -> String {
             return rest[..end].to_string();
         }
     }
-    
+
     if let Some(start) = message.find("WIP on ") {
         let rest = &message[start + 7..];
         if let Some(end) = rest.find(':') {
@@ -399,4 +422,4 @@ pub fn format_applying_stashes_message(branch_name: &str, count: usize) -> Strin
 
 pub fn format_stash_entry(name: &str, message: &str) -> String {
     format!("{name}: {message}")
-}
+}

src/upstream.rs

@@ -32,15 +32,21 @@ fn set_upstream(upstream: String) {
         }
     };
 
-    println!("{}", format_setting_upstream_message(&current_branch, &upstream));
+    println!(
+        "{}",
+        format_setting_upstream_message(&current_branch, &upstream)
+    );
 
     // Set upstream
     if let Err(msg) = set_branch_upstream(&current_branch, &upstream) {
         eprintln!("{}", format_error_message(msg));
         return;
     }
 
-    println!("{}", format_upstream_set_message(&current_branch, &upstream));
+    println!(
+        "{}",
+        format_upstream_set_message(&current_branch, &upstream)
+    );
 }
 
 fn show_upstream_status() {
@@ -72,18 +78,21 @@ fn show_upstream_status() {
     let current_branch = get_current_branch().unwrap_or_default();
 
     println!("{}", format_upstream_status_header());
-    
+
     for branch in &branches {
         let is_current = branch == &current_branch;
         let upstream = branch_upstreams.get(branch).unwrap();
-        
+
         match upstream {
             Some(upstream_ref) => {
                 // Check sync status
-                let sync_status = get_branch_sync_status(branch, upstream_ref)
-                    .unwrap_or_else(|_| SyncStatus::Unknown);
-                
-                println!("{}", format_branch_with_upstream(branch, upstream_ref, &sync_status, is_current));
+                let sync_status =
+                    get_branch_sync_status(branch, upstream_ref).unwrap_or(SyncStatus::Unknown);
+
+                println!(
+                    "{}",
+                    format_branch_with_upstream(branch, upstream_ref, &sync_status, is_current)
+                );
             }
             None => {
                 println!("{}", format_branch_without_upstream(branch, is_current));
@@ -107,15 +116,21 @@ fn sync_all_branches(dry_run: bool, merge: bool) {
         return;
     }
 
-    println!("{}", format_sync_all_start_message(branches.len(), dry_run, merge));
+    println!(
+        "{}",
+        format_sync_all_start_message(branches.len(), dry_run, merge)
+    );
 
     let mut sync_results = Vec::new();
 
     for (branch, upstream) in &branches {
         let sync_status = match get_branch_sync_status(branch, upstream) {
             Ok(status) => status,
             Err(_) => {
-                sync_results.push((branch.clone(), SyncResult::Error("Failed to get sync status".to_string())));
+                sync_results.push((
+                    branch.clone(),
+                    SyncResult::Error("Failed to get sync status".to_string()),
+                ));
                 continue;
             }
         };
@@ -130,15 +145,20 @@ fn sync_all_branches(dry_run: bool, merge: bool) {
                 } else {
                     match sync_branch_with_upstream(branch, upstream, merge) {
                         Ok(()) => sync_results.push((branch.clone(), SyncResult::Synced)),
-                        Err(msg) => sync_results.push((branch.clone(), SyncResult::Error(msg.to_string()))),
+                        Err(msg) => {
+                            sync_results.push((branch.clone(), SyncResult::Error(msg.to_string())))
+                        }
                     }
                 }
             }
             SyncStatus::Ahead(_) => {
                 sync_results.push((branch.clone(), SyncResult::Ahead));
             }
             SyncStatus::Unknown => {
-                sync_results.push((branch.clone(), SyncResult::Error("Unknown sync status".to_string())));
+                sync_results.push((
+                    branch.clone(),
+                    SyncResult::Error("Unknown sync status".to_string()),
+                ));
             }
         }
     }
@@ -150,7 +170,10 @@ fn sync_all_branches(dry_run: bool, merge: bool) {
     }
 
     // Print summary
-    let synced_count = sync_results.iter().filter(|(_, r)| matches!(r, SyncResult::Synced | SyncResult::WouldSync)).count();
+    let synced_count = sync_results
+        .iter()
+        .filter(|(_, r)| matches!(r, SyncResult::Synced | SyncResult::WouldSync))
+        .count();
     println!("{}", format_sync_summary(synced_count, dry_run));
 }
 
@@ -270,7 +293,12 @@ fn get_branch_upstream(branch: &str) -> Result<String, &'static str> {
 // Helper function to get branch sync status
 fn get_branch_sync_status(branch: &str, upstream: &str) -> Result<SyncStatus, &'static str> {
     let output = Command::new("git")
-        .args(["rev-list", "--left-right", "--count", &format!("{upstream}...{branch}")])
+        .args([
+            "rev-list",
+            "--left-right",
+            "--count",
+            &format!("{upstream}...{branch}"),
+        ])
         .output()
         .map_err(|_| "Failed to get sync status")?;
 
@@ -279,13 +307,13 @@ fn get_branch_sync_status(branch: &str, upstream: &str) -> Result<SyncStatus, &'
     }
 
     let counts = String::from_utf8_lossy(&output.stdout);
-    let mut parts = counts.trim().split_whitespace();
-    
+    let mut parts = counts.split_whitespace();
+
     let behind: u32 = parts
         .next()
         .and_then(|s| s.parse().ok())
         .ok_or("Invalid sync count format")?;
-    
+
     let ahead: u32 = parts
         .next()
         .and_then(|s| s.parse().ok())
@@ -315,7 +343,11 @@ fn get_branches_with_upstreams() -> Result<Vec<(String, String)>, &'static str>
 }
 
 // Helper function to sync branch with upstream
-fn sync_branch_with_upstream(branch: &str, upstream: &str, merge: bool) -> Result<(), &'static str> {
+fn sync_branch_with_upstream(
+    branch: &str,
+    upstream: &str,
+    merge: bool,
+) -> Result<(), &'static str> {
     // Switch to the branch first
     let status = Command::new("git")
         .args(["checkout", branch])
@@ -339,7 +371,11 @@ fn sync_branch_with_upstream(branch: &str, upstream: &str, merge: bool) -> Resul
         .map_err(|_| "Failed to sync with upstream")?;
 
     if !status.success() {
-        return Err(if merge { "Merge failed" } else { "Rebase failed" });
+        return Err(if merge {
+            "Merge failed"
+        } else {
+            "Rebase failed"
+        });
     }
 
     Ok(())
@@ -371,7 +407,12 @@ pub fn format_upstream_status_header() -> &'static str {
     "🔗 Upstream status for all branches:\n"
 }
 
-pub fn format_branch_with_upstream(branch: &str, upstream: &str, sync_status: &SyncStatus, is_current: bool) -> String {
+pub fn format_branch_with_upstream(
+    branch: &str,
+    upstream: &str,
+    sync_status: &SyncStatus,
+    is_current: bool,
+) -> String {
     let current_indicator = if is_current { "* " } else { "  " };
     let status_text = match sync_status {
         SyncStatus::UpToDate => "✅ up-to-date",
@@ -380,7 +421,7 @@ pub fn format_branch_with_upstream(branch: &str, upstream: &str, sync_status: &S
         SyncStatus::Diverged(b, a) => &format!("🔀 {b} behind, {a} ahead"),
         SyncStatus::Unknown => "❓ unknown",
     };
-    
+
     format!("{current_indicator}{branch} -> {upstream} ({status_text})")
 }
 
@@ -418,8 +459,10 @@ pub fn format_sync_result_line(branch: &str, result: &SyncResult) -> String {
 
 pub fn format_sync_summary(synced_count: usize, dry_run: bool) -> String {
     if dry_run {
-        format!("\n💡 Would sync {synced_count} branch(es). Run without --dry-run to apply changes.")
+        format!(
+            "\n💡 Would sync {synced_count} branch(es). Run without --dry-run to apply changes."
+        )
     } else {
         format!("\n✅ Synced {synced_count} branch(es) successfully.")
     }
-}
+}