treeboot 0.8.2

Bootstrap Git worktrees from one repo-local setup file.
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

use std::io::Write;
use std::path::PathBuf;

use clap::Args;
use treeboot_core::{Error, InitScriptStatus, StatusOptions, StatusReport, StatusSnapshotReport};

use super::environment_input;
use super::output::{OutputArgs, ReportFormat, write_structured};

#[derive(Debug, Args, Clone, Default)]
pub(crate) struct StatusArgs {
    /// Override the checkout used for status discovery.
    #[arg(short, long)]
    root: Option<PathBuf>,

    /// Use one specific config file and skip init script discovery.
    #[arg(short, long)]
    config: Option<PathBuf>,

    /// Skip init script discovery and use declarative config discovery.
    #[arg(long)]
    no_init_script: bool,

    #[command(flatten)]
    output: OutputArgs,
}

pub(crate) fn run_status_command(args: StatusArgs) -> treeboot_core::Result<()> {
    let format = args.output.format();
    let report = treeboot_core::inspect_status(args.into())?;

    match format {
        ReportFormat::Text => print_status_text(&report).map_err(|source| Error::Output { source }),
        format => write_structured(&StatusSnapshotReport::from(&report), format),
    }
}

fn print_status_text(report: &StatusReport) -> std::io::Result<()> {
    let stdout = std::io::stdout();
    let mut handle = stdout.lock();

    writeln!(handle, "treeboot: status")?;
    writeln!(
        handle,
        "worktree: {}",
        report.context.worktree_path.display()
    )?;
    writeln!(handle, "root: {}", report.context.root_path.display())?;
    let default_branch = if report.context.default_branch.is_empty() {
        "(unknown)"
    } else {
        &report.context.default_branch
    };
    writeln!(handle, "default_branch: {default_branch}")?;

    match &report.init_script {
        InitScriptStatus::Skipped => writeln!(handle, "init_script: (skipped)")?,
        InitScriptStatus::Found { path } => {
            writeln!(handle, "init_script: {}", path.display())?;
        }
        InitScriptStatus::NotFound { ignored } => {
            writeln!(handle, "init_script: (none)")?;
            for ignored in ignored {
                writeln!(handle, "ignored_init_script: {}", ignored.path.display())?;
            }
        }
    }

    if let Some(path) = &report.config {
        writeln!(handle, "config: {}", path.display())
    } else {
        writeln!(handle, "config: (none)")
    }
}

impl From<StatusArgs> for StatusOptions {
    fn from(args: StatusArgs) -> Self {
        Self {
            cwd: None,
            root: args.root,
            environment: environment_input(),
            config: args.config,
            no_init_script: args.no_init_script,
        }
    }
}