sluuz 0.10.6

git, but it sleuths - a git superset with cross-repo search, secret scanning, and multi-repo management
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

//! `slu sync` - fetch (and optionally fast-forward) every repo under a path in
//! parallel.
//!
//! By default it only fetches + prunes, which never touches your working tree.
//! With `--pull` it also fast-forwards the current branch to its upstream
//! (`load::fast_forward`), which refuses rather than merging, so it can never
//! create a merge commit or a conflict.

use crate::git::{display_name, first_line, git_run, repos_or_exit, with_remote_limit};
use colored::Colorize;
use rayon::prelude::*;
use std::path::PathBuf;

#[derive(clap::Args)]
pub struct Args {
    /// Base directory to search for repos (defaults to current directory)
    #[arg(default_value = ".")]
    pub path: PathBuf,

    /// How many directory levels deep to look for repos
    #[arg(short, long, default_value_t = 3)]
    pub depth: usize,

    /// After fetching, fast-forward the current branch (git merge --ff-only)
    #[arg(long)]
    pub pull: bool,
}

enum State {
    Ok,
    Skip,
    Fail,
}

struct Outcome {
    name: String,
    state: State,
    note: String,
}

pub fn run(args: Args) {
    let repos = repos_or_exit(&args.path, args.depth);

    outln!(
        "{} {} repo(s)…\n",
        if args.pull {
            "Fetching + pulling"
        } else {
            "Fetching"
        }
        .dimmed(),
        repos.len()
    );

    let mut outcomes: Vec<Outcome> = with_remote_limit(|| {
        repos
            .par_iter()
            .filter_map(|repo| {
                let name = display_name(repo);
                let repo_str = repo.to_str()?;
                Some(process(name, repo_str, args.pull))
            })
            .collect()
    });

    outcomes.sort_by(|a, b| a.name.cmp(&b.name));

    let name_w = outcomes.iter().map(|o| o.name.len()).max().unwrap_or(0);
    let mut failed = 0usize;

    for o in &outcomes {
        let mark = match o.state {
            State::Ok => "✓".green(),
            State::Skip => "–".dimmed(),
            State::Fail => {
                failed += 1;
                "✗".red()
            }
        };
        outln!("  {}  {:name_w$}  {}", mark, o.name.bold(), o.note.dimmed());
    }

    outln!();
    let summary = format!("{} repos · {} failed", outcomes.len(), failed);
    if failed > 0 {
        outln!("{}", summary.red());
    } else {
        outln!("{}", summary.dimmed());
    }
}

fn process(name: String, repo: &str, pull: bool) -> Outcome {
    let (ok, out) = git_run(repo, &["fetch", "--all", "--prune"]);
    if !ok {
        return Outcome {
            name,
            state: State::Fail,
            note: first_line(&out),
        };
    }

    if !pull {
        // Fetch output is empty when nothing new arrived.
        let note = if out.is_empty() {
            "up to date"
        } else {
            "fetched"
        };
        return Outcome {
            name,
            state: State::Ok,
            note: note.to_string(),
        };
    }

    let (state, note) = match crate::git::load::fast_forward(repo) {
        Ok(Some(0)) => (State::Ok, "up to date".to_string()),
        Ok(Some(_)) => (State::Ok, "fast-forwarded".to_string()),
        // A missing upstream isn't a failure - there's just nothing to pull.
        Ok(None) => (State::Skip, "fetched, no upstream to pull".to_string()),
        Err(words) => (State::Fail, first_line(&words)),
    };
    Outcome { name, state, note }
}