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

use crate::prelude::*;
pub mod cli;
pub mod commands;
pub mod config;
pub mod error;
pub mod git;
pub mod output;

use cli::Commands;
use std::env;

/// Execute git commands across a fleet rooted at the current directory.
pub fn execute(command: Commands, verbose: bool, dry_run: bool) -> anyhow::Result<()> {
    let repo_root = env::current_dir().unwrap_or_else(|_| PathBuf::from("."));

    let result = match command {
        Commands::Status => commands::status::execute(&repo_root, verbose),

        Commands::Discard { untracked, yes } => commands::discard::execute(
            &repo_root,
            commands::discard::Options {
                untracked,
                assume_yes: yes,
                dry_run,
            },
        ),

        Commands::Checkout {
            branch,
            create,
            ignore_missing,
        } => commands::checkout::execute(
            &repo_root,
            &branch,
            create,
            ignore_missing,
            dry_run,
            verbose,
        ),

        Commands::Pull {
            rebase,
            autostash,
            overwrite_local,
        } => {
            let options = crate::git_backend::PullOptions {
                rebase,
                autostash,
                overwrite_local,
            };
            commands::pull::execute(&repo_root, options, dry_run, verbose)
        }

        Commands::Push {
            force_with_lease,
            force_all,
        } => commands::push::execute(&repo_root, force_with_lease, force_all, dry_run, verbose),

        Commands::Create {
            branch,
            from,
            push,
            force_all,
        } => commands::create::execute(
            &repo_root,
            &branch,
            from.as_deref(),
            push,
            force_all,
            dry_run,
            verbose,
        ),

        Commands::Commit {
            message,
            push,
            stage_all,
            exclude,
            include,
            force_all,
        } => commands::commit::execute(
            &repo_root, &message, push, stage_all, &exclude, &include, force_all, dry_run, verbose,
        ),

        Commands::Sync { init, recursive } => {
            commands::sync::execute(&repo_root, init, recursive, dry_run, verbose)
        }

        Commands::Delete {
            branch,
            remote,
            force,
        } => commands::delete::execute(&repo_root, &branch, remote, force, dry_run, verbose),

        Commands::Fetch { all, force_all } => {
            commands::fetch::execute(&repo_root, all, force_all, dry_run, verbose)
        }

        Commands::Branch { all } => commands::branch::execute(&repo_root, all, verbose),

        Commands::Init { recursive } => {
            commands::init::execute(&repo_root, recursive, dry_run, verbose)
        }

        Commands::Diff {
            base,
            since,
            output,
            staged,
            clean,
        } => commands::diff::execute(
            &repo_root,
            base.as_deref(),
            since.as_deref(),
            &output,
            staged,
            clean,
            verbose,
        ),

        Commands::Stage => commands::stage::execute(&repo_root, dry_run, verbose),

        Commands::MergeBack { message } => {
            commands::merge_back::execute(&repo_root, &message, dry_run, verbose)
        }

        Commands::TestCatalog {
            output,
            git_add,
            quiet,
        } => commands::catalogue::execute(&repo_root, output.as_deref(), git_add, quiet)
            .map_err(|e| crate::fleet::error::SuperGitError::Other(format!("{}", e))),
    };

    result.map_err(|e| anyhow::anyhow!("{}", e))
}