gitgrip 1.0.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

//! Cache command implementation
//!
//! Manages bare-repo caches under the machine-level cache root for workspace repos.

use crate::cli::args::CacheCommands;
use crate::cli::output::Output;
use crate::core::manifest::Manifest;
use crate::core::repo::filter_repos;
use crate::core::workspace_cache;
use anyhow::Result;
use colored::Colorize;
use std::path::Path;

pub fn run_cache(
    workspace_root: &Path,
    manifest: &Manifest,
    action: CacheCommands,
    quiet: bool,
) -> Result<()> {
    // Include reference repos in caching — they benefit from local caches too
    let repos = filter_repos(manifest, workspace_root, None, None, true);

    match action {
        CacheCommands::Bootstrap => {
            if !quiet {
                Output::info(&format!(
                    "Bootstrapping caches for {} repos...",
                    repos.len()
                ));
            }

            let repo_pairs: Vec<(&str, &str)> = repos
                .iter()
                .map(|r| (r.name.as_str(), r.url.as_str()))
                .collect();

            let count = workspace_cache::bootstrap_all(workspace_root, repo_pairs.into_iter())?;

            if !quiet {
                if count > 0 {
                    Output::success(&format!("Bootstrapped {} new cache(s)", count));
                } else {
                    Output::info("All caches already exist");
                }
            }
        }

        CacheCommands::Update => {
            if !quiet {
                Output::info("Updating all caches...");
            }

            let repo_pairs: Vec<(&str, &str)> = repos
                .iter()
                .map(|r| (r.name.as_str(), r.url.as_str()))
                .collect();

            let count = workspace_cache::update_all(workspace_root, repo_pairs.into_iter())?;

            if !quiet {
                Output::success(&format!("Updated {} cache(s)", count));
            }
        }

        CacheCommands::Status => {
            println!(
                "{:<20} {:<8} {}",
                "Repo".bold(),
                "Status".bold(),
                "Path".bold()
            );
            println!("{}", "─".repeat(70));

            for repo in &repos {
                let exists = workspace_cache::cache_exists(workspace_root, &repo.name, &repo.url)?;
                let path =
                    workspace_cache::resolve_cache_path(workspace_root, &repo.name, &repo.url)?;
                let status = if exists {
                    "cached".green().to_string()
                } else {
                    "missing".yellow().to_string()
                };
                println!("{:<20} {:<8} {}", repo.name, status, path.display());
            }
        }

        CacheCommands::Remove { repo } => {
            let Some(repo_info) = repos.iter().find(|r| r.name == repo) else {
                anyhow::bail!("repo '{}' is not in this manifest", repo);
            };
            let removed =
                workspace_cache::remove_cache(workspace_root, &repo_info.name, &repo_info.url)?;
            if removed {
                Output::success(&format!("Removed cache for {}", repo));
            } else {
                Output::warning(&format!("No cache found for {}", repo));
            }
        }
    }

    Ok(())
}