gitgrip 0.20.0

Multi-repo workflow tool - manage multiple git repositories as one
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

//! Prune command implementation
//!
//! Deletes local branches that have been merged into the default branch.
//! Optionally prunes remote tracking refs.

use crate::cli::output::Output;
use crate::core::manifest::Manifest;
use crate::core::repo::{filter_repos, RepoInfo};
use crate::git::branch::{delete_local_branch, is_branch_merged, list_local_branches};
use crate::git::{get_current_branch, open_repo, path_exists};
use crate::util::log_cmd;
use std::path::Path;
use std::process::Command;

/// Run the prune command
pub fn run_prune(
    workspace_root: &Path,
    manifest: &Manifest,
    execute: bool,
    remote: bool,
    repos_filter: Option<&[String]>,
    group_filter: Option<&[String]>,
) -> anyhow::Result<()> {
    if execute {
        Output::header("Pruning merged branches...");
    } else {
        Output::header("Pruning merged branches (dry run)...");
    }
    println!();

    let repos: Vec<RepoInfo> =
        filter_repos(manifest, workspace_root, repos_filter, group_filter, false);

    let mut total_pruned = 0;
    let mut total_repos = 0;

    for repo in &repos {
        if !path_exists(&repo.absolute_path) {
            continue;
        }

        let git_repo = match open_repo(&repo.absolute_path) {
            Ok(r) => r,
            Err(e) => {
                Output::error(&format!("{}: {}", repo.name, e));
                continue;
            }
        };

        let current_branch = match get_current_branch(&git_repo) {
            Ok(b) => b,
            Err(e) => {
                Output::error(&format!("{}: {}", repo.name, e));
                continue;
            }
        };

        let branches = match list_local_branches(&git_repo) {
            Ok(b) => b,
            Err(e) => {
                Output::error(&format!("{}: {}", repo.name, e));
                continue;
            }
        };

        let mut merged_branches: Vec<String> = Vec::new();

        for branch in &branches {
            // Skip current branch and default branch
            if branch == &current_branch || branch == repo.target_branch() {
                continue;
            }

            match is_branch_merged(&git_repo, branch, repo.target_branch()) {
                Ok(true) => merged_branches.push(branch.clone()),
                Ok(false) => {}
                Err(e) => {
                    Output::warning(&format!(
                        "{}: could not check branch '{}': {}",
                        repo.name, branch, e
                    ));
                }
            }
        }

        if merged_branches.is_empty() {
            continue;
        }

        total_repos += 1;
        Output::subheader(&format!("{}:", repo.name));

        for branch in &merged_branches {
            if execute {
                match delete_local_branch(&git_repo, branch, false) {
                    Ok(()) => {
                        Output::success(&format!("  Deleted: {}", branch));
                        total_pruned += 1;
                    }
                    Err(e) => {
                        Output::error(&format!("  Failed to delete '{}': {}", branch, e));
                    }
                }
            } else {
                println!("  Would delete: {}", branch);
                total_pruned += 1;
            }
        }

        // Prune remote tracking refs if requested
        if remote {
            let mut cmd = Command::new("git");
            cmd.args(["fetch", "--prune"])
                .current_dir(&repo.absolute_path);
            log_cmd(&cmd);
            let output = cmd.output();

            match output {
                Ok(o) if o.status.success() => {
                    let stderr = String::from_utf8_lossy(&o.stderr);
                    if stderr.contains("pruning") || stderr.contains("[deleted]") {
                        Output::info("  Pruned remote tracking refs");
                    }
                }
                Ok(o) => {
                    let stderr = String::from_utf8_lossy(&o.stderr);
                    Output::warning(&format!("  Failed to prune remote refs: {}", stderr.trim()));
                }
                Err(e) => {
                    Output::warning(&format!("  Failed to prune remote refs: {}", e));
                }
            }
        }
    }

    println!();
    if total_pruned == 0 {
        Output::success("No merged branches to prune.");
    } else if execute {
        Output::success(&format!(
            "Pruned {} branch(es) across {} repo(s).",
            total_pruned, total_repos
        ));
    } else {
        Output::info(&format!(
            "Found {} merged branch(es) across {} repo(s).",
            total_pruned, total_repos
        ));
        Output::warning("Run with --execute to actually delete them.");
    }

    Ok(())
}