How to create a nested command structure using derive?

[f16n]

I am trying to make a cli with a two level command structure. something like:

prog game new [--opponent=]
prog game status
prog login --username --password
prog server status

each level should be mutually exclusive (if new is given, no other commands are possible)

I think I need a toplevel enum (game/login/server) followed by a second level enum (for game: new/status/etc) following by the options for that command.

I struggle how to approach this

[pacak]

each level should be mutually exclusive (if new is given, no other commands are possible)
I think I need a toplevel enum (game/login/server) followed by a second level enum

This is a great start. You analyze how bits of the result relate to each other and come up with a structure - top level enum with some enums and structs inside.

This is how enum for server might look like

#[derive(Debug, Clone)]
enum Server {
    Status,
    Restart,
}

You want it to be command "server" on the outside so any bit of the parser can succeed and "status" / "restart" on the inside so you can pass prog server status / prog server restart:

#[derive(Debug, Clone, Bpaf)]
#[bpaf(command)]
enum Server {
    #[bpaf(command)] // implicit command name - it gets derived from enum field name
    Status,
    #[bpaf(command("restart"))]  // explicit command name
    Restart,
}

Here I'm using a mix of explicit and implicit names - up to you what you prefer. This gives you a function server() that parses sequences I listed above. The final bit is to refer to this parsre from inside Options struct using external attribute, so the whole parser can look like this:

use bpaf::*;

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options, version, fallback(Options::Dummy))]
enum Options {
    Game(#[bpaf(external(game))] Game), // explicit name with tuple struct
    Server {
        #[bpaf(external)] // or implicit name with named struct
        server: Server,
    },
    #[bpaf(hide)] // if you want to run something by default, or you can drop this branch
    Dummy,
}

#[derive(Debug, Clone, Bpaf)]
#[bpaf(command("game"))]
enum Game {
    #[bpaf(command("new"))]
    New { opponent: Option<String> },
    #[bpaf(command("status"))]
    Status,
}

#[derive(Debug, Clone, Bpaf)]
#[bpaf(command)]
enum Server {
    #[bpaf(command)]
    Status,

    #[bpaf(command)]
    Restart,
}

fn main() {
    println!("{:?}", options().run());
}

Add some doc comments on top of that, any missing fields and it should be good to go.

[f16n]

Thanks! /I ended up doing this:

#[derive(Debug, Clone, Bpaf)]
#[bpaf(options, version)]
enum Options {
    Signup(#[bpaf(external(signup))] Signup),
    Login(#[bpaf(external(login))] Login),
    Game(#[bpaf(external(game))] Game),
}

#[derive(Debug, Clone, Bpaf, Serialize, Deserialize)]
#[bpaf(command("signup"))]
/// signup to the game server
    struct Signup {
        #[bpaf(short, long, argument("URL"))]
        /// server address to login to
        server: String,

        #[bpaf(short, long, argument("USERNAME"))]
        /// username for unique identification
        username: String,

        #[bpaf(short, long, argument("PASSWORD"))]
        /// password to prove identity
        password: String,

        #[bpaf(short, long, argument("EMAIL ADDRESS"))]
        /// email address for verification
        email: String,

        #[bpaf(short, long, argument("NOTIFY"))]
        /// mail notifications when game changes occur
        notify: Option<bool>,
}

#[derive(Debug, Clone, Bpaf, Serialize, Deserialize)]
#[bpaf(command("login"))]
/// login to the server
    struct Login {
        #[bpaf(short, long, argument("URL"))]
        /// server address to login to
        server: String,

        #[bpaf(short, long, argument("USERNAME"))]
        /// username for unique identification
        username: String,

        #[bpaf(short, long, argument("PASSWORD"))]
        /// password to prove identity
        password: String,
}

#[derive(Debug, Clone, Bpaf, Serialize, Deserialize)]
#[bpaf(command("game"))]
/// game related commands
enum Game {
    #[bpaf(command("new"))]
    /// Start a new game
    New {
        #[bpaf(short, long, argument("USERNAME"))]
        /// Add player as opponent
        opponent: Option<String>
    },
    #[bpaf(command("status"))]
    /// Display game status
    Status {
        #[bpaf(short, long, argument("GAME ID"))]
        /// Add player as opponent
        id: u32
    }
}

fn main() -> Result<(),ClientError> {

    let args = options().run();
    //println!("{:#?}", args);

    match args {
        Options::Login(login) => { login_command(login)? },
        Options::Signup(signup) => { signup_command(signup)? },
        Options::Game(game) => { game_commands(game)? },
    }

    Ok(())
}

[pacak]

        #[bpaf(short, long, argument("NOTIFY"))]
        /// mail notifications when game changes occur
        notify: Option<bool>,

This bit looks a bit odd. As far as I remember deriving logic it can only return either Some(true) or Some(false). You might as well make it notify: bool

[f16n]

Sure, but it's optional with a default of false

[pacak]

Just having notify: bool gives you false if --notify is not is specified and true if is was.

[f16n]

Ah, didn't know that. Thanks!