mirror of
https://github.com/clap-rs/clap
synced 2024-12-14 06:42:33 +00:00
470531b515
This reduces ambiguity in how the different "multiple" parts of the API interact and lowrs the amount of API surface area users have to dig through to use clap. For now, this is only a matter of cleaning up the public API. Cleaning up the implementation is the next step.
297 lines
10 KiB
Rust
297 lines
10 KiB
Rust
use clap::{arg, Arg, ArgAction, Command};
|
|
use criterion::{criterion_group, criterion_main, Criterion};
|
|
|
|
static OPT3_VALS: [&str; 2] = ["fast", "slow"];
|
|
static POS3_VALS: [&str; 2] = ["vi", "emacs"];
|
|
|
|
macro_rules! create_app {
|
|
() => {{
|
|
Command::new("claptests")
|
|
.version("0.1")
|
|
.about("tests clap library")
|
|
.author("Kevin K. <kbknapp@gmail.com>")
|
|
.arg(arg!(-o --option <opt> ... "tests options").required(false))
|
|
.arg(arg!([positional] "tests positionals"))
|
|
.arg(arg!(-f --flag ... "tests flags").global(true))
|
|
.args(&[
|
|
arg!(flag2: -F "tests flags with exclusions")
|
|
.conflicts_with("flag")
|
|
.requires("option2"),
|
|
arg!(option2: --"long-option-2" <option2> "tests long options with exclusions")
|
|
.required(false)
|
|
.conflicts_with("option")
|
|
.requires("positional2"),
|
|
arg!([positional2] "tests positionals with exclusions"),
|
|
arg!(-O --Option <option3> "tests options with specific value sets")
|
|
.required(false)
|
|
.value_parser(OPT3_VALS),
|
|
arg!([positional3] ... "tests positionals with specific values")
|
|
.value_parser(POS3_VALS),
|
|
arg!(--multvals <s> "Tests multiple values not mult occs").required(false).value_names(&["one", "two"]),
|
|
arg!(
|
|
--multvalsmo <s> "Tests multiple values, not mult occs"
|
|
).required(false).value_names(&["one", "two"]),
|
|
arg!(--minvals2 <minvals> ... "Tests 2 min vals").number_of_values(2..).required(false),
|
|
arg!(--maxvals3 <maxvals> ... "Tests 3 max vals").number_of_values(1..=3).required(false),
|
|
])
|
|
.subcommand(
|
|
Command::new("subcmd")
|
|
.about("tests subcommands")
|
|
.version("0.1")
|
|
.author("Kevin K. <kbknapp@gmail.com>")
|
|
.arg(arg!(-o --option <scoption> ... "tests options").required(false))
|
|
.arg(arg!([scpositional] "tests positionals"))
|
|
)
|
|
}};
|
|
}
|
|
|
|
pub fn build_from_builder(c: &mut Criterion) {
|
|
c.bench_function("build_from_builder", |b| {
|
|
b.iter(|| {
|
|
Command::new("claptests")
|
|
.version("0.1")
|
|
.about("tests clap library")
|
|
.author("Kevin K. <kbknapp@gmail.com>")
|
|
.arg(
|
|
Arg::new("opt")
|
|
.help("tests options")
|
|
.short('o')
|
|
.long("option")
|
|
.number_of_values(1..)
|
|
.action(ArgAction::Append),
|
|
)
|
|
.arg(Arg::new("positional").help("tests positionals").index(1))
|
|
.arg(
|
|
Arg::new("flag")
|
|
.short('f')
|
|
.help("tests flags")
|
|
.long("flag")
|
|
.global(true)
|
|
.action(ArgAction::Append),
|
|
)
|
|
.arg(
|
|
Arg::new("flag2")
|
|
.short('F')
|
|
.help("tests flags with exclusions")
|
|
.conflicts_with("flag")
|
|
.requires("option2"),
|
|
)
|
|
.arg(
|
|
Arg::new("option2")
|
|
.help("tests long options with exclusions")
|
|
.conflicts_with("option")
|
|
.requires("positional2")
|
|
.action(ArgAction::Set)
|
|
.long("long-option-2"),
|
|
)
|
|
.arg(
|
|
Arg::new("positional2")
|
|
.index(3)
|
|
.help("tests positionals with exclusions"),
|
|
)
|
|
.arg(
|
|
Arg::new("option3")
|
|
.short('O')
|
|
.long("Option")
|
|
.action(ArgAction::Set)
|
|
.help("tests options with specific value sets")
|
|
.value_parser(OPT3_VALS),
|
|
)
|
|
.arg(
|
|
Arg::new("positional3")
|
|
.number_of_values(1..)
|
|
.help("tests positionals with specific values")
|
|
.index(4)
|
|
.value_parser(POS3_VALS),
|
|
)
|
|
.arg(
|
|
Arg::new("multvals")
|
|
.long("multvals")
|
|
.help("Tests multiple values, not mult occs")
|
|
.value_names(&["one", "two"]),
|
|
)
|
|
.arg(
|
|
Arg::new("multvalsmo")
|
|
.long("multvalsmo")
|
|
.action(ArgAction::Append)
|
|
.help("Tests multiple values, not mult occs")
|
|
.value_names(&["one", "two"]),
|
|
)
|
|
.arg(
|
|
Arg::new("minvals")
|
|
.long("minvals2")
|
|
.action(ArgAction::Append)
|
|
.help("Tests 2 min vals")
|
|
.number_of_values(2..),
|
|
)
|
|
.arg(
|
|
Arg::new("maxvals")
|
|
.long("maxvals3")
|
|
.action(ArgAction::Append)
|
|
.help("Tests 3 max vals")
|
|
.number_of_values(1..=3),
|
|
)
|
|
.subcommand(
|
|
Command::new("subcmd")
|
|
.about("tests subcommands")
|
|
.version("0.1")
|
|
.author("Kevin K. <kbknapp@gmail.com>")
|
|
.arg(
|
|
Arg::new("scoption")
|
|
.short('o')
|
|
.long("option")
|
|
.number_of_values(1..)
|
|
.action(ArgAction::Append)
|
|
.help("tests options"),
|
|
)
|
|
.arg(Arg::new("scpositional").index(1).help("tests positionals")),
|
|
)
|
|
})
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex(c: &mut Criterion) {
|
|
c.bench_function("parse_complex", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec![""]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_flag(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_flag", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec!["myprog", "-f"]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_opt(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_opt", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec!["myprog", "-o", "option1"]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_pos(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_pos", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec!["myprog", "arg1"]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_sc(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_sc", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec!["myprog", "subcmd"]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_sc_flag(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_sc_flag", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec!["myprog", "subcmd", "-f"]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_sc_opt(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_sc_opt", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec!["myprog", "subcmd", "-o", "option1"]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_sc_pos(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_sc_pos", |b| {
|
|
b.iter(|| create_app!().get_matches_from(vec!["myprog", "subcmd", "arg1"]))
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex1(c: &mut Criterion) {
|
|
c.bench_function("parse_complex1", |b| {
|
|
b.iter(|| {
|
|
create_app!().get_matches_from(vec![
|
|
"myprog",
|
|
"-ff",
|
|
"-o",
|
|
"option1",
|
|
"arg1",
|
|
"-O",
|
|
"fast",
|
|
"arg2",
|
|
"--multvals",
|
|
"one",
|
|
"two",
|
|
"emacs",
|
|
])
|
|
})
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex2(c: &mut Criterion) {
|
|
c.bench_function("parse_complex2", |b| {
|
|
b.iter(|| {
|
|
create_app!().get_matches_from(vec![
|
|
"myprog",
|
|
"arg1",
|
|
"-f",
|
|
"arg2",
|
|
"--long-option-2",
|
|
"some",
|
|
"-O",
|
|
"slow",
|
|
"--multvalsmo",
|
|
"one",
|
|
"two",
|
|
"--minvals2",
|
|
"3",
|
|
"2",
|
|
"1",
|
|
])
|
|
})
|
|
});
|
|
}
|
|
|
|
pub fn parse_args_negate_scs(c: &mut Criterion) {
|
|
c.bench_function("parse_args_negate_scs", |b| {
|
|
b.iter(|| {
|
|
create_app!()
|
|
.args_conflicts_with_subcommands(true)
|
|
.get_matches_from(vec![
|
|
"myprog",
|
|
"arg1",
|
|
"-f",
|
|
"arg2",
|
|
"--long-option-2",
|
|
"some",
|
|
"-O",
|
|
"slow",
|
|
"--multvalsmo",
|
|
"one",
|
|
"two",
|
|
"--minvals2",
|
|
"3",
|
|
"2",
|
|
"1",
|
|
])
|
|
})
|
|
});
|
|
}
|
|
|
|
pub fn parse_complex_with_sc_complex(c: &mut Criterion) {
|
|
c.bench_function("parse_complex_with_sc_complex", |b| {
|
|
b.iter(|| {
|
|
create_app!().get_matches_from(vec!["myprog", "subcmd", "-f", "-o", "option1", "arg1"])
|
|
})
|
|
});
|
|
}
|
|
|
|
criterion_group!(
|
|
benches,
|
|
build_from_builder,
|
|
parse_complex,
|
|
parse_complex_with_flag,
|
|
parse_complex_with_opt,
|
|
parse_complex_with_pos,
|
|
parse_complex_with_sc,
|
|
parse_complex_with_sc_flag,
|
|
parse_complex_with_sc_opt,
|
|
parse_complex_with_sc_pos,
|
|
parse_complex1,
|
|
parse_complex2,
|
|
parse_args_negate_scs,
|
|
parse_complex_with_sc_complex
|
|
);
|
|
|
|
criterion_main!(benches);
|