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

use crate::fleet::error::{Result, SuperGitError};
use crate::fleet::git::{SubmoduleOps, SubmoduleTree};
use crate::fleet::output::Formatter;
use crate::prelude::*;

pub fn execute<P: AsRef<Path>>(
    repo_root: P,
    recursive: bool,
    dry_run: bool,
    verbose: bool,
) -> Result<()> {
    let tree = SubmoduleTree::discover(&repo_root)?;

    let candidates: Vec<_> = tree
        .top_down()
        .iter()
        .filter(|node| recursive || node.depth == 0)
        .collect();
    let pending: Vec<_> = candidates.iter().filter(|node| !node.initialized).collect();

    Formatter::print_info(&format!(
        "Initializing {} of {} known submodule(s){}",
        pending.len(),
        candidates.len(),
        if recursive { " (recursively)" } else { "" }
    ));

    if recursive && !pending.is_empty() {
        Formatter::print_info(
            "Submodules nested inside these will be discovered once their parent is checked out",
        );
    }

    if dry_run {
        Formatter::print_warning("DRY RUN: No changes will be made");
        for node in &pending {
            Formatter::print_info(&format!("Would initialize '{}'", node.label()));
        }
        return Ok(());
    }

    let skipped = candidates.len() - pending.len();
    let outcome = SubmoduleOps::init_tree(&repo_root, recursive, |node| {
        if verbose {
            Formatter::print_submodule_header(node.label());
        }
    })?;

    for name in &outcome.initialized {
        Formatter::print_success(&format!("Initialized '{}'", name));
    }
    for (name, err) in &outcome.failures {
        Formatter::print_error(&format!("Failed to initialize '{}': {}", name, err));
    }

    Formatter::print_summary(outcome.initialized.len(), outcome.failures.len(), skipped);

    if !outcome.failures.is_empty() {
        return Err(SuperGitError::Other(format!(
            "{} submodule(s) failed to initialize",
            outcome.failures.len()
        )));
    }

    Ok(())
}