use clap::error::{ContextKind, ContextValue, ErrorKind};
use clap::parser::ValueSource;
use clap::{Arg, ArgAction, ArgMatches, Command};
use gadk_platform::go_flag::{go_parse_bool, go_parse_int};
use gadk_platform::{GoDuration, go_parse_duration, go_quote};
pub const STRAY_ARGS: &str = "args";
pub fn pflag_command(name: &'static str) -> Command {
Command::new(name)
.args_override_self(true)
.disable_help_subcommand(true)
}
fn value_flag(
long: &'static str,
short: Option<char>,
default: &'static str,
help: &'static str,
value_name: &'static str,
zero: &'static str,
) -> Arg {
let mut arg = Arg::new(long)
.long(long)
.help(help)
.value_name(value_name)
.action(ArgAction::Set)
.num_args(1)
.allow_hyphen_values(true)
.default_value(default)
.hide_default_value(default == zero);
if let Some(c) = short {
arg = arg.short(c);
}
arg
}
pub fn string_flag(
long: &'static str,
short: Option<char>,
default: &'static str,
help: &'static str,
) -> Arg {
value_flag(long, short, default, help, "string", "")
}
pub fn int_flag(
long: &'static str,
short: Option<char>,
default: &'static str,
help: &'static str,
) -> Arg {
value_flag(long, short, default, help, "int", "0").value_parser(go_parse_int)
}
pub fn duration_flag(
long: &'static str,
short: Option<char>,
default: &'static str,
help: &'static str,
) -> Arg {
value_flag(long, short, default, help, "duration", "0s").value_parser(go_parse_duration)
}
pub fn bool_flag(long: &'static str, default: bool, help: &'static str) -> Arg {
Arg::new(long)
.long(long)
.help(help)
.value_name("bool")
.action(ArgAction::Set)
.num_args(0..=1)
.require_equals(true)
.default_missing_value("true")
.default_value(if default { "true" } else { "false" })
.hide_default_value(!default)
.value_parser(go_parse_bool)
}
pub fn stray_args() -> Arg {
Arg::new(STRAY_ARGS)
.num_args(0..)
.action(ArgAction::Append)
.hide(true)
}
pub fn passed(m: &ArgMatches, id: &str) -> bool {
matches!(m.value_source(id), Some(ValueSource::CommandLine))
}
pub fn string_value(m: &ArgMatches, id: &str) -> String {
m.try_get_one::<String>(id)
.ok()
.flatten()
.cloned()
.unwrap_or_default()
}
pub fn int_value(m: &ArgMatches, id: &str) -> i64 {
m.try_get_one::<i64>(id)
.ok()
.flatten()
.copied()
.unwrap_or_default()
}
pub fn duration_value(m: &ArgMatches, id: &str) -> GoDuration {
m.try_get_one::<GoDuration>(id)
.ok()
.flatten()
.copied()
.unwrap_or_default()
}
pub fn bool_value(m: &ArgMatches, id: &str) -> bool {
m.try_get_one::<bool>(id)
.ok()
.flatten()
.copied()
.unwrap_or_default()
}
fn context_str(e: &clap::Error, kind: ContextKind) -> Option<&str> {
match e.get(kind) {
Some(ContextValue::String(s)) => Some(s.as_str()),
_ => None,
}
}
fn quote_rune(c: char) -> String {
let q = go_quote(&c.to_string());
let inner = &q[1..q.len() - 1];
let inner = if inner == "\\\"" { "\"" } else { inner };
if inner == "'" {
return "'\\''".to_string();
}
format!("'{inner}'")
}
fn long_name(rendered: &str) -> &str {
let s = rendered.trim_start_matches('-');
let end = s.find([' ', '[', '=']).unwrap_or(s.len());
&s[..end]
}
pub fn pflag_error(e: &clap::Error, cmd: &Command, raw: &[String]) -> String {
match e.kind() {
ErrorKind::UnknownArgument => {
let arg = context_str(e, ContextKind::InvalidArg).unwrap_or_default();
if let Some(name) = arg.strip_prefix("--") {
if name.is_empty() || name.starts_with(['-', '=']) {
return format!("bad flag syntax: {arg}");
}
let name = name.split('=').next().unwrap_or(name);
return format!("unknown flag: --{name}");
}
if let Some(c) = arg.strip_prefix('-').and_then(|s| s.chars().next()) {
let start = format!("-{c}");
let shorthands = raw
.iter()
.find(|t| t.starts_with(&start) && !t.starts_with("--"))
.map(|t| &t[1..])
.unwrap_or(&arg[1..]);
return format!("unknown shorthand flag: {} in -{shorthands}", quote_rune(c));
}
clap_message(e)
}
ErrorKind::InvalidValue
if context_str(e, ContextKind::InvalidValue) == Some("")
&& std::error::Error::source(e).is_none() =>
{
match raw.last() {
Some(last) if last.starts_with("--") => {
format!(
"flag needs an argument: {}",
last.split('=').next().unwrap_or(last)
)
}
Some(last) if last.starts_with('-') => {
let c = last.chars().last().unwrap_or('-');
format!("flag needs an argument: {} in -{c}", quote_rune(c))
}
_ => clap_message(e),
}
}
ErrorKind::ValueValidation => {
let rendered = context_str(e, ContextKind::InvalidArg).unwrap_or_default();
let long = long_name(rendered);
let short = cmd
.get_arguments()
.find(|a| a.get_long() == Some(long))
.and_then(Arg::get_short);
let flag = match short {
Some(s) => format!("-{s}, --{long}"),
None => format!("--{long}"),
};
let value = context_str(e, ContextKind::InvalidValue).unwrap_or_default();
let cause = std::error::Error::source(e)
.map(ToString::to_string)
.unwrap_or_default();
format!(
"invalid argument {} for {} flag: {cause}",
go_quote(value),
go_quote(&flag)
)
}
_ => clap_message(e),
}
}
fn clap_message(e: &clap::Error) -> String {
let rendered = e.render().to_string();
let first = rendered.lines().next().unwrap_or_default();
first.strip_prefix("error: ").unwrap_or(first).to_string()
}
#[cfg(test)]
mod tests {
use pretty_assertions::assert_eq;
use super::*;
fn cmd() -> Command {
pflag_command("t")
.arg(string_flag("region", Some('r'), "", "GCP Region"))
.arg(string_flag("pubsub_oidc_audience", None, "", "aud"))
.arg(string_flag("eventarc_oidc_audience", None, "", "aud"))
.arg(string_flag(
"a2a_agent_url",
Some('a'),
"http://127.0.0.1:8081",
"url",
))
.arg(int_flag("server_port", None, "8080", "port"))
.arg(duration_flag("mem_ttl", None, "8760h0m0s", "ttl"))
.arg(bool_flag("a2a", true, "Enable A2A"))
.arg(bool_flag("pubsub", false, "Enable PubSub"))
.arg(stray_args())
}
fn parse(args: &[&str]) -> Result<ArgMatches, String> {
let raw: Vec<String> = std::iter::once("t")
.chain(args.iter().copied())
.map(str::to_string)
.collect();
let c = cmd();
c.clone()
.try_get_matches_from(&raw)
.map_err(|e| pflag_error(&e, &c, &raw[1..]))
}
fn stray(m: &ArgMatches) -> Vec<String> {
m.get_many::<String>(STRAY_ARGS)
.map(|v| v.cloned().collect())
.unwrap_or_default()
}
#[test]
fn defaults_are_go_defaults_and_not_passed() {
let m = parse(&[]).unwrap();
assert_eq!(string_value(&m, "region"), "");
assert_eq!(string_value(&m, "a2a_agent_url"), "http://127.0.0.1:8081");
assert_eq!(int_value(&m, "server_port"), 8080);
assert_eq!(
duration_value(&m, "mem_ttl"),
GoDuration(8760 * 3600 * 1_000_000_000)
);
assert!(bool_value(&m, "a2a"));
assert!(!bool_value(&m, "pubsub"));
for id in [
"region",
"a2a_agent_url",
"server_port",
"mem_ttl",
"a2a",
"pubsub",
] {
assert!(!passed(&m, id), "{id}");
}
assert_eq!(stray(&m), Vec::<String>::new());
}
#[test]
fn bool_flags_take_a_value_only_after_equals() {
let m = parse(&["--a2a=false"]).unwrap();
assert!(!bool_value(&m, "a2a"));
assert!(passed(&m, "a2a"));
let m = parse(&["--pubsub"]).unwrap();
assert!(bool_value(&m, "pubsub"));
assert!(passed(&m, "pubsub"));
let m = parse(&["--a2a", "false"]).unwrap();
assert!(bool_value(&m, "a2a"));
assert_eq!(stray(&m), ["false"]);
for (v, want) in [
("1", true),
("t", true),
("TRUE", true),
("0", false),
("F", false),
] {
let m = parse(&[&format!("--pubsub={v}")]).unwrap();
assert_eq!(bool_value(&m, "pubsub"), want, "{v}");
}
let m = parse(&["--a2a", "--a2a=false"]).unwrap();
assert!(!bool_value(&m, "a2a"));
}
#[test]
fn value_flags_accept_every_pflag_spelling() {
for args in [
&["-r", "x"][..],
&["-rx"],
&["-r=x"],
&["--region", "x"],
&["--region=x"],
&["-r", "y", "--region", "x"],
] {
let m = parse(args).unwrap();
assert_eq!(string_value(&m, "region"), "x", "{args:?}");
assert!(passed(&m, "region"), "{args:?}");
}
for args in [&["--region", "-y"][..], &["--region=-y"], &["-r", "-y"]] {
assert_eq!(
string_value(&parse(args).unwrap(), "region"),
"-y",
"{args:?}"
);
}
let m = parse(&[
"--pubsub_oidc_audience",
"--eventarc_oidc_audience",
"https://svc.run.app",
])
.unwrap();
assert_eq!(
string_value(&m, "pubsub_oidc_audience"),
"--eventarc_oidc_audience"
);
assert!(!passed(&m, "eventarc_oidc_audience"));
assert_eq!(stray(&m), ["https://svc.run.app"]);
let m = parse(&["--region="]).unwrap();
assert_eq!(string_value(&m, "region"), "");
assert!(passed(&m, "region"));
}
#[test]
fn ints_are_go_parse_int_base_0() {
for (v, want) in [
("9090", 9090),
("0x10", 16),
("010", 8),
("0o10", 8),
("0b1", 1),
("1_000", 1000),
("-1", -1),
("+7", 7),
] {
let m = parse(&["--server_port", v]).unwrap();
assert_eq!(int_value(&m, "server_port"), want, "{v}");
}
}
#[test]
fn durations_are_go_parse_duration() {
for (v, want) in [
("1s", 1_000_000_000),
("1h30m", 5_400_000_000_000),
("1.5s", 1_500_000_000),
("300ms", 300_000_000),
("0", 0),
("-2m", -120_000_000_000),
] {
let m = parse(&[&format!("--mem_ttl={v}")]).unwrap();
assert_eq!(duration_value(&m, "mem_ttl"), GoDuration(want), "{v}");
}
}
#[test]
fn stray_positionals_are_accepted_and_ignored() {
let m = parse(&["a", "-r", "x", "b", "--", "--c", "-"]).unwrap();
assert_eq!(string_value(&m, "region"), "x");
assert_eq!(stray(&m), ["a", "b", "--c", "-"]);
}
#[test]
fn parse_errors_are_pflag_texts() {
let cases: &[(&[&str], &str)] = &[
(&["--nope"], "unknown flag: --nope"),
(&["--nope=3"], "unknown flag: --nope"),
(&["-r", "x", "-x"], "unknown shorthand flag: 'x' in -x"),
(&["-xyz"], "unknown shorthand flag: 'x' in -xyz"),
(&["---x"], "bad flag syntax: ---x"),
(&["--region"], "flag needs an argument: --region"),
(&["-r"], "flag needs an argument: 'r' in -r"),
(&["--a2a", "-a"], "flag needs an argument: 'a' in -a"),
(
&["--server_port=x"],
r#"invalid argument "x" for "--server_port" flag: strconv.ParseInt: parsing "x": invalid syntax"#,
),
(
&["--server_port", "99999999999999999999"],
r#"invalid argument "99999999999999999999" for "--server_port" flag: strconv.ParseInt: parsing "99999999999999999999": value out of range"#,
),
(
&["--a2a=x"],
r#"invalid argument "x" for "--a2a" flag: strconv.ParseBool: parsing "x": invalid syntax"#,
),
(
&["--a2a="],
r#"invalid argument "" for "--a2a" flag: strconv.ParseBool: parsing "": invalid syntax"#,
),
(
&["--mem_ttl", "1d"],
r#"invalid argument "1d" for "--mem_ttl" flag: time: unknown unit "d" in duration "1d""#,
),
];
for (args, want) in cases {
assert_eq!(parse(args).unwrap_err(), *want, "{args:?}");
}
}
#[test]
fn invalid_value_of_a_flag_with_a_shorthand_names_both() {
let c = pflag_command("t").arg(
Arg::new("port")
.long("port")
.short('p')
.num_args(1)
.value_parser(go_parse_int),
);
let raw = vec!["t".to_string(), "-p".to_string(), "x".to_string()];
let e = c.clone().try_get_matches_from(&raw).unwrap_err();
assert_eq!(
pflag_error(&e, &c, &raw[1..]),
r#"invalid argument "x" for "-p, --port" flag: strconv.ParseInt: parsing "x": invalid syntax"#
);
}
#[test]
fn quote_rune_is_go_percent_q_of_a_rune() {
assert_eq!(quote_rune('x'), "'x'");
assert_eq!(quote_rune('é'), "'é'");
assert_eq!(quote_rune('\''), "'\\''");
assert_eq!(quote_rune('"'), "'\"'");
}
}