Prioritise between subcommand, global, env vars, and config file

[SamuelMarks]

I want to support 3 different ways of providing input:

0. config file
1. global command line argument
2. subcommand argument

Additionally the global and subcommand arguments have defaults and environment variables set, so this logic is desired:

0. if provided explicitly in subcommand, use this
1. otherwise use global command argument
2. otherwise use value in config file if existent
3. otherwise use subcommand env var if provided
4. otherwise use global env var if provided

config.json

{
    "0.0.1": { "count": 1 },
    "0.0.5": { "count": 7 },
    "0.2.1": { "count": 10 },
    "0.7.1": { "count": 12 },
    "1.0.0": { "count": 1 }
}

main.rs

use clap::Parser;

#[derive(clap::Parser, serde::Serialize, serde::Deserialize, std::fmt::Debug)]
#[command(author, version=env!("CARGO_PKG_VERSION"), about, long_about = None)]
struct Args {
    #[arg(short, long, env="APP_VERSION", default_value = "latest")]
    app_version: String,

    #[arg(short, long, default_value_t = 1)]
    count: u8,

    #[serde(skip)]
    #[arg(long, env = "CONFIG_FILE",
          default_value_os_t = std::ffi::OsString::from("/tmp/config.json"))]
    config: std::ffi::OsString,

    #[serde(skip, default = "_default_command")]
    #[command(subcommand)]
    command: Commands,
}

fn _default_command() -> Commands {
    Commands::GetCount { version: None }
}

#[derive(clap::Subcommand, serde::Serialize, serde::Deserialize, std::fmt::Debug)]
enum Commands {
    GetCount {
        #[arg(short, long, env="SUB_VERSION", default_value = "latest-sub")]
        version: Option<String>
    },
}

fn main() {
    let args = Args::parse();
    println!(
        "[before_config_read] {} being run for the {} time",
        args.app_version,
        ordinal::Ordinal(args.count).to_string()
    );

    if std::path::Path::new(&args.config).is_file() {
        // TODO: Read config file
    }

    // TODO: Write config file, properly interpolating just this version
    /* serde_json::to_writer(
         std::fs::File::create(&args.config).unwrap(),
         &args,
    ).unwrap(); */
}

Cargo.toml

[dependencies]
clap = { version = "4.4.*", features = ["derive", "env"] }
ordinal = "0.3.*"
serde = { version = "1.0.*", features = ["derive"] }
serde_json = "1.0.*"

---

I guess my first question so I can implement this logic is:
how do I know whether a variable was provided by the user, was provided in an env var, or was provided as a default?

[epage]

how do I know whether a variable was provided by the user, was provided in an env var, or was provided as a default?

You can check ArgMatches to get the value source. It would require not using Parer::parse but to get the Command for your Parser, run get_matches to get ArgMatches, process it as needed, and then use Parser to extract your struct from ArgMatches.

Support in derive is being tracked in #3846

[marcoradocchia]

I was struggling to find a solution to the exact same problem using derive. Seems like clap::parser::ValueSource is exactly what need. Looking forward for derive support.

Thank you @epage for such precious information! :)