mirror of
https://github.com/clap-rs/clap
synced 2024-12-14 23:02:31 +00:00
d43f1dbf6f
A couple of things happened when preparing to release 3.0
- We needed derive documentation
- I had liked how serde handled theres
- I had bad experiences finding things in structopt's documentation
- The examples were broken and we needed tests
- The examples seemed to follow a pattern of having tutorial content and
cookbook content
- We had been getting bug reports from people looking at master and
thinking they were looking at what is currently released
- We had gotten feedback to keep down the number of places that
documentation was located
From this, we went with a mix of docs.rs and github
- We kept the number of content locations at 2 rather than 3 by not
having an external site like serde
- We rewrote the examples into explicit tutorials and cookbooks to align
with the 4 styles of documentation
- We could test our examples by running `console` code blocks with
trycmd
- Documentation was versioned and the README pointed to the last release
This had downsides
- The tutorials didn't have the code inlined
- Users still had a hard time finding and navigating between the
different forms of documentation
- In practice, we were less likely to cross-link between the different
types of documentation
Moving to docs.rs would offer a lot of benefits, even if it is only
designed for Rust-reference documentation and isn't good for Rust derive
reference documentation, tutorials, cookbooks, etc. The big problem was
keeping the examples tested to keep maintenance costs down. Maybe its
just me but its easy to overlook
- You can pull documentation from a file using `#[doc = "path"]`
- Repeated doc attributes get concatenated rather than first or last
writer winning
Remember these when specifically thinking about Rust documentation made
me realize that we could get everything into docs.rs.
When doing this
- Tutorial code got brought in as was one of the aims
- We needed to split the lib documentation and the README to have all of
the linking work. This allowed us to specialize them according to
their rule (user vs contributor)
- We needed to avoid users getting caught up in making a decision
between Derive and Builder APIs so we put the focus on the derive API
with links to the FAQ to help users decide when to use one or the
other.
- Improved cross-referencing between different parts of the
documentation
- Limited inline comments were added to example code
- Introductory example code intentionally does not have teaching
comments in it as its meant to give a flavor or sense of things and
not meant to teach on its own.
This is a first attempt. There will be a lot of room for further
improvement. Current know downsides:
- Content source is more split up for the tutorials
This hopefully addresses #3189
91 lines
3.4 KiB
Rust
91 lines
3.4 KiB
Rust
use std::path::PathBuf;
|
|
|
|
use clap::{arg, command, value_parser, ArgAction, ErrorKind};
|
|
|
|
fn main() {
|
|
// Create application like normal
|
|
let mut cmd = command!() // requires `cargo` feature
|
|
// Add the version arguments
|
|
.arg(arg!(--"set-ver" <VER> "set version manually").required(false))
|
|
.arg(arg!(--major "auto inc major").action(ArgAction::SetTrue))
|
|
.arg(arg!(--minor "auto inc minor").action(ArgAction::SetTrue))
|
|
.arg(arg!(--patch "auto inc patch").action(ArgAction::SetTrue))
|
|
// Arguments can also be added to a group individually, these two arguments
|
|
// are part of the "input" group which is not required
|
|
.arg(arg!([INPUT_FILE] "some regular input").value_parser(value_parser!(PathBuf)))
|
|
.arg(
|
|
arg!(--"spec-in" <SPEC_IN> "some special input argument")
|
|
.required(false)
|
|
.value_parser(value_parser!(PathBuf)),
|
|
)
|
|
// Now let's assume we have a -c [config] argument which requires one of
|
|
// (but **not** both) the "input" arguments
|
|
.arg(
|
|
arg!(config: -c <CONFIG>)
|
|
.required(false)
|
|
.value_parser(value_parser!(PathBuf)),
|
|
);
|
|
let matches = cmd.get_matches_mut();
|
|
|
|
// Let's assume the old version 1.2.3
|
|
let mut major = 1;
|
|
let mut minor = 2;
|
|
let mut patch = 3;
|
|
|
|
// See if --set-ver was used to set the version manually
|
|
let version = if let Some(ver) = matches.get_one::<String>("set-ver") {
|
|
if *matches.get_one::<bool>("major").expect("defaulted by clap")
|
|
|| *matches.get_one::<bool>("minor").expect("defaulted by clap")
|
|
|| *matches.get_one::<bool>("patch").expect("defaulted by clap")
|
|
{
|
|
cmd.error(
|
|
ErrorKind::ArgumentConflict,
|
|
"Can't do relative and absolute version change",
|
|
)
|
|
.exit();
|
|
}
|
|
ver.to_string()
|
|
} else {
|
|
// Increment the one requested (in a real program, we'd reset the lower numbers)
|
|
let (maj, min, pat) = (
|
|
*matches.get_one::<bool>("major").expect("defaulted by clap"),
|
|
*matches.get_one::<bool>("minor").expect("defaulted by clap"),
|
|
*matches.get_one::<bool>("patch").expect("defaulted by clap"),
|
|
);
|
|
match (maj, min, pat) {
|
|
(true, false, false) => major += 1,
|
|
(false, true, false) => minor += 1,
|
|
(false, false, true) => patch += 1,
|
|
_ => {
|
|
cmd.error(
|
|
ErrorKind::ArgumentConflict,
|
|
"Can only modify one version field",
|
|
)
|
|
.exit();
|
|
}
|
|
};
|
|
format!("{}.{}.{}", major, minor, patch)
|
|
};
|
|
|
|
println!("Version: {}", version);
|
|
|
|
// Check for usage of -c
|
|
if matches.contains_id("config") {
|
|
let input = matches
|
|
.get_one::<PathBuf>("INPUT_FILE")
|
|
.or_else(|| matches.get_one::<PathBuf>("spec-in"))
|
|
.unwrap_or_else(|| {
|
|
cmd.error(
|
|
ErrorKind::MissingRequiredArgument,
|
|
"INPUT_FILE or --spec-in is required when using --config",
|
|
)
|
|
.exit()
|
|
})
|
|
.display();
|
|
println!(
|
|
"Doing work using input {} and config {}",
|
|
input,
|
|
matches.get_one::<PathBuf>("config").unwrap().display()
|
|
);
|
|
}
|
|
}
|