repo 0.15.4

An opinionated tool for repo management.
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

use std::io::stdout;
use std::process::exit;

use clap::{Args, CommandFactory, Parser, Subcommand};
use clap_complete::generator::generate;
use clap_complete::{Generator, Shell};

use crate::build::CLAP_LONG_VERSION;
use crate::commands::boilerplate::BoilerplateArgs;
use crate::commands::dependencies::DependenciesArgs;
use crate::commands::print_schema::PrintSchemaArgs;
use crate::commands::publish::PublishArgs;
use crate::commands::setup::SetupArgs;
use crate::commands::vcs::VcsArgs;
use crate::commands::version::VersionArgs;
use crate::commands::workspace::WorkspaceArgs;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
#[clap(name = "repo", long_version = CLAP_LONG_VERSION)]
pub(crate) struct RepoArgs {
    #[command(subcommand)]
    pub command: RepoCommand,
}

#[derive(Debug, Subcommand)]
pub(crate) enum RepoCommand {
    /// Perform operations on the repo version.
    Version(VersionArgs),
    /// Publish.
    Publish(PublishArgs),
    /// Set up boilerplate for the repo.
    Boilerplate(BoilerplateArgs),
    /// Set up a repository checkout.
    Setup(SetupArgs),
    /// Get information about the current VCS.
    Vcs(VcsArgs),
    /// Get information about the current workspace.
    Workspace(WorkspaceArgs),
    /// Operate on dependencies.
    Dependencies(DependenciesArgs),
    /// Print completions for the given shell.
    Completions(CompletionsArgs),
    /// Print the given JSON schema.
    PrintSchema(PrintSchemaArgs),
}

#[derive(Args, Debug)]
pub(crate) struct CompletionsArgs {
    /// Print completions for the given shell.
    /// These can be loaded/stored permanently (e.g. when using Homebrew), but they can also be sourced directly, e.g.:
    ///
    ///  repo completions fish | source # fish
    ///  source <(repo completions zsh) # zsh
    #[clap(verbatim_doc_comment, id = "SHELL")]
    shell: Shell,

    #[clap(long)]
    bin_name: Option<String>,
}

fn completions_for_shell(
    cmd: &mut clap::Command,
    generator: impl Generator,
    bin_name: Option<String>,
) {
    generate(
        generator,
        cmd,
        bin_name.unwrap_or_else(|| cmd.get_name().to_owned()),
        &mut stdout(),
    );
}

pub(crate) fn get_args() -> RepoArgs {
    let mut command = RepoArgs::command();

    let args = RepoArgs::parse();
    if let RepoCommand::Completions(completions_args) = args.command {
        completions_for_shell(
            &mut command,
            completions_args.shell,
            completions_args.bin_name,
        );
        exit(0);
    };

    args
}

#[cfg(test)]
mod tests {
    use crate::args::RepoArgs;

    // https://docs.rs/clap/latest/clap/_derive/_tutorial/index.html#testing
    #[test]
    fn test_clap_args() {
        use clap::CommandFactory;

        RepoArgs::command().debug_assert();
    }
}