limb 0.1.0

A focused CLI for git worktree management
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

//! Implements `limb update`. Fetch + fast-forward every worktree.

use anyhow::Result;

use crate::cli::UpdateArgs;
use crate::context::Context;
use crate::worktree;

/// Runs `limb update`.
///
/// By default: `git fetch --all --prune` once, then `merge --ff-only
/// @{upstream}` in each non-bare worktree that has a branch. `--fetch-only`
/// skips the fast-forward pass; `--ff-only` skips the fetch.
/// Fast-forward failures are reported as `skip` and do not abort.
///
/// # Errors
///
/// Returns an error if the repo cannot be resolved or the initial fetch
/// fails. Per-worktree fast-forward failures are non-fatal.
pub fn run(ctx: &Context, args: &UpdateArgs) -> Result<()> {
    let repo = ctx.repo()?;

    let dim = crate::style::DIM;
    let ok = crate::style::OK;
    let warn = crate::style::WARN;

    if !args.ff_only {
        if !ctx.quiet {
            let verb = if args.dry_run { "would" } else { "→" };
            anstream::eprintln!("{dim}{verb} fetch --all --prune{dim:#}");
        }
        if !args.dry_run {
            worktree::fetch(&repo, ctx.quiet)?;
        }
    }

    if !args.fetch_only {
        let trees = worktree::list(&repo)?;
        for w in &trees {
            if w.bare || w.branch.is_none() {
                continue;
            }
            if args.dry_run {
                if !ctx.quiet {
                    anstream::eprintln!("{dim}would ff {}{dim:#}", w.name);
                }
                continue;
            }
            if !ctx.quiet {
                anstream::eprint!("{dim}→ ff {} ... {dim:#}", w.name);
            }
            match worktree::fast_forward(&w.path, ctx.quiet) {
                Ok(()) => {
                    if !ctx.quiet {
                        anstream::eprintln!("{ok}ok{ok:#}");
                    }
                }
                Err(e) => {
                    if !ctx.quiet {
                        anstream::eprintln!("{warn}skip{warn:#} ({e})");
                    }
                }
            }
        }
    }
    Ok(())
}