wsb 0.258.6441

Workspace tools for every project under $PRJ: git across submodules, template stamping, GitHub, and the workbench
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

use crate::fleet::git::SubmoduleStatus;
use colored::*;

pub struct Formatter;

impl Formatter {
    pub fn print_status(statuses: &[SubmoduleStatus]) {
        crate::outln!("\n{}", "Git Status:".bold().underline());
        crate::outln!();

        for status in statuses {
            let indent = "  ".repeat(status.depth);
            if !status.exists {
                crate::outln!(
                    "  {}{} {} {}",
                    indent,
                    "●".red(),
                    status.name.bold(),
                    "[NOT INITIALIZED]".red()
                );
                continue;
            }

            // Green means nothing to do here; yellow means something needs
            // attention, whether that is local changes, drift from the remote, or
            // a detached HEAD. Which one it is, is spelled out on the lines below.
            let indicator = if status.is_clean && status.ahead == 0 && status.behind == 0 {
                "●".green()
            } else {
                "●".yellow()
            };

            crate::out!("  {}{} {}", indent, indicator, status.name.bold());

            if let Some(ref branch) = status.current_branch {
                crate::out!(" ({})", branch.cyan());
            } else if status.is_detached {
                crate::out!(" {}", "[DETACHED HEAD]".red());
            }

            crate::outln!();

            if !status.is_clean {
                crate::outln!(
                    "    {}{} {} uncommitted file(s)",
                    indent,
                    "!".yellow(),
                    status.uncommitted_files.len()
                );
            }

            // Said, but quietly. These differ from HEAD and a commit here would
            // carry them, so a status that omitted them would misdescribe what
            // this tree contains. They are not what somebody scanning for their
            // own work is looking for, so they do not raise the indicator and
            // do not make a repository unclean.
            if !status.rendered_files.is_empty() {
                crate::outln!(
                    "    {}{}",
                    indent,
                    format!(
                        "~ {} generated file(s) — the local render",
                        status.rendered_files.len()
                    )
                    .dimmed()
                );
            }

            // Likewise said quietly. A container repository is mostly gitlinks,
            // and they move whenever a child's tree does — so in a fleet under
            // `wsb local on` they move all at once, tracking the render rather
            // than anything somebody did.
            if !status.moved_pointers.is_empty() {
                crate::outln!(
                    "    {}{}",
                    indent,
                    format!(
                        "~ {} submodule pointer(s) moved",
                        status.moved_pointers.len()
                    )
                    .dimmed()
                );
            }

            if status.ahead > 0 {
                crate::outln!(
                    "    {}{} {} commit(s) ahead",
                    indent,
                    "↑".green(),
                    status.ahead
                );
            }

            if status.behind > 0 {
                crate::outln!(
                    "    {}{} {} commit(s) behind",
                    indent,
                    "↓".red(),
                    status.behind
                );
            }
        }

        crate::outln!();
    }

    pub fn print_success(message: &str) {
        crate::outln!("{} {}", "✓".green(), message);
    }

    pub fn print_error(message: &str) {
        crate::errln!("{} {}", "✗".red(), message);
    }

    pub fn print_warning(message: &str) {
        crate::outln!("{} {}", "!".yellow(), message);
    }

    pub fn print_info(message: &str) {
        crate::outln!("{} {}", "ℹ".cyan(), message);
    }

    pub fn print_submodule_header(name: &str) {
        crate::outln!("\n{} {}...", "→".cyan(), name.bold());
    }

    pub fn print_summary(successful: usize, failed: usize, skipped: usize) {
        crate::outln!("\n{}", "Summary:".bold().underline());
        crate::outln!(
            "  {} successful, {} failed, {} skipped",
            successful.to_string().green(),
            failed.to_string().red(),
            skipped.to_string().yellow()
        );
    }

    pub fn print_branches(submodule_name: &str, branches: &[String], current: Option<&str>) {
        crate::outln!("\n{}", submodule_name.bold());
        for branch in branches {
            if Some(branch.as_str()) == current {
                crate::outln!("  {} {}", "*".green(), branch.green());
            } else {
                crate::outln!("    {}", branch);
            }
        }
    }
}