invar 0.6.0

CLI management tool for modded Minecraft servers
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
137
138
139
140
141
142
143
144
145
146
147
148
149

use clap::builder::styling::AnsiColor::{BrightBlue, White, Yellow};
use clap::builder::Styles;
use clap::Parser;
use invar::Loader;
use semver::Version;

/// Styling for [`clap`]'s CLI interface.
const STYLES: Styles = Styles::styled()
    .usage(Yellow.on_default().bold())
    .literal(BrightBlue.on_default().bold())
    .placeholder(White.on_default().bold())
    .header(Yellow.on_default().bold());

#[derive(Parser, Debug)]
#[command(version, author, about, styles(STYLES))]
pub struct Options {
    #[command(subcommand)]
    pub subcommand: Subcommand,

    #[arg(short('f'), long("format"), default_value_t = OutputFormat::default())]
    pub output_format: OutputFormat,
}

#[derive(clap::Subcommand, Debug)]
pub enum Subcommand {
    /// Manage the pack itself.
    Pack {
        #[command(subcommand)]
        action: PackAction,
    },

    /// Manage modpack's components.
    Component {
        #[command(subcommand)]
        action: ComponentAction,
    },

    /// Manage the self-hosted server.
    Server {
        #[command(subcommand)]
        action: ServerAction,
    },
}

#[derive(clap::Subcommand, Debug)]
pub enum PackAction {
    /// Create a new pack in the current directory.
    #[clap(visible_alias("new"), visible_alias("create"))]
    Setup {
        /// The name of the created modpack.
        #[arg(short, long)]
        name: Option<String>,

        /// What game version to build upon.
        #[arg(long)]
        minecraft_version: Option<Version>,

        /// Which modloader to build upon.
        #[arg(short, long)]
        loader: Option<Loader>,

        /// Which loader version to use. Ignored if no loader is used.
        #[arg(long)]
        loader_version: Option<Version>,

        /// Don't ask for confirmation if there's already a pack in the current
        /// directory.
        #[arg(short, long)]
        overwrite: bool,
    },

    /// Read the local storage and show Invar sees.
    Show,

    /// Export the modpack in `.mrpack` format.
    Export,
}

#[derive(clap::Subcommand, Debug)]
pub enum ComponentAction {
    /// Show the existing components in the pack.
    List,

    /// Add a new component to the pack.
    #[command(arg_required_else_help = true)]
    Add {
        /// The IDs of components to be added.
        ids: Vec<String>,

        /// Show the component's metadata before writing it to disk.
        #[arg(short('d'), long("debug"))]
        show_metadata: bool,
    },

    /// Update one or more of the existing components.
    Update {
        /// The IDs of components to update (update all if not provided).
        slugs: Vec<String>,
    },

    /// Remove one or more of the existing components.
    #[clap(visible_alias("delete"))]
    #[command(arg_required_else_help = true)]
    Remove {
        /// The IDs of components to remove.
        slugs: Vec<String>,
    },
}

#[derive(clap::Subcommand, Debug)]
pub enum ServerAction {
    /// Prepare for the first start of the server.
    Setup,

    /// Start the server, do nothing if it is already running.
    Start,

    /// Stop the server, do nothing if it is already stopped.
    Stop,

    /// Report the status of the server.
    Status,

    /// Manage backups of the server.
    Backup {
        #[command(subcommand)]
        action: BackupAction,
    },
}

#[derive(clap::Subcommand, Debug)]
pub enum BackupAction {
    /// List out all the backups created in the past.
    List,

    /// Create a new backup at this point in time.
    Create,

    /// Garbage-collect backups.
    Gc,
}

#[derive(Debug, Default, Clone, PartialEq, Eq, clap::ValueEnum, strum::Display)]
#[strum(serialize_all = "kebab-case")]
pub enum OutputFormat {
    #[default]
    Human,
    Yaml,
}