wsb 0.225.4660

Workspace - A tool suite for file operations, version management, and development workflow automation
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

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

pub struct Formatter;

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

        for status in statuses {
            let indent = "  ".repeat(status.depth);
            if !status.exists {
                println!(
                    "  {}{} {} {}",
                    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()
            };

            print!("  {}{} {}", indent, indicator, status.name.bold());

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

            println!();

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

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

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

        println!();
    }

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

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

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

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

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

    pub fn print_summary(successful: usize, failed: usize, skipped: usize) {
        println!("\n{}", "Summary:".bold().underline());
        println!(
            "  {} 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>) {
        println!("\n{}", submodule_name.bold());
        for branch in branches {
            if Some(branch.as_str()) == current {
                println!("  {} {}", "*".green(), branch.green());
            } else {
                println!("    {}", branch);
            }
        }
    }
}