gwx 2.0.0

A friendly git worktree manager with automatic paths, hooks and shell integration
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

//! `gwx list` — show every worktree of the repository.
//!
//! In a terminal this is the interactive picker; `--plain` and `--paths` are
//! the ways to ask for text a script can read.

use anyhow::Result;

use crate::cd_target;
use crate::cli::ListArgs;
use crate::git::Worktree;
use crate::repo::Repo;
use crate::tui::{self, Outcome};

pub fn run(args: ListArgs) -> Result<()> {
    let repo = Repo::discover()?;

    if !args.paths && !args.plain && tui::should_pick(&repo)? {
        return match tui::pick(&repo)? {
            Outcome::Cancelled => Ok(()),
            Outcome::Selected(path) => cd_target::request_picked(&path),
        };
    }

    let worktrees = repo.worktrees()?;

    if args.paths {
        for wt in &worktrees {
            println!("{}", wt.path.display());
        }
        return Ok(());
    }

    let Some(main) = worktrees.first() else {
        return Ok(());
    };

    let rows: Vec<Row> = worktrees
        .iter()
        .map(|wt| Row {
            current: wt.path == repo.cwd || repo.cwd.starts_with(&wt.path),
            name: repo.display_name(wt, main),
            head: wt.short_head(),
            note: note(wt),
            path: wt.path.display().to_string(),
        })
        .collect();

    let name_width = rows
        .iter()
        .map(|r| r.name.chars().count())
        .max()
        .unwrap_or(0);

    for row in &rows {
        let marker = if row.current { '*' } else { ' ' };
        println!(
            "{marker} {:<name_width$}  {}  {}{}",
            row.name, row.head, row.path, row.note
        );
    }
    Ok(())
}

struct Row {
    current: bool,
    name: String,
    head: String,
    note: String,
    path: String,
}

fn note(wt: &Worktree) -> String {
    let mut notes = Vec::new();
    if wt.bare {
        notes.push("bare");
    }
    if wt.detached {
        notes.push("detached");
    }
    if wt.locked {
        notes.push("locked");
    }
    if notes.is_empty() {
        String::new()
    } else {
        format!(" ({})", notes.join(", "))
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    #[test]
    fn notes_describe_worktree_state() {
        let mut wt = Worktree {
            path: PathBuf::from("/wt"),
            head: None,
            branch: None,
            bare: false,
            detached: true,
            locked: true,
        };
        assert_eq!(note(&wt), " (detached, locked)");
        wt.detached = false;
        wt.locked = false;
        assert_eq!(note(&wt), "");
    }
}