129 lines
4.8 KiB
Rust
129 lines
4.8 KiB
Rust
//! Minimal std-only argument parsing: positionals, `--key value` / `--key=value` / `-o value`
|
|
//! options, and boolean `--flag`s. Unknown options are usage errors.
|
|
|
|
use std::collections::BTreeMap;
|
|
|
|
use crate::{CliError, CliResult};
|
|
|
|
#[derive(Debug, Default)]
|
|
pub struct Args {
|
|
pub positional: Vec<String>,
|
|
values: BTreeMap<String, String>,
|
|
flags: Vec<String>,
|
|
}
|
|
|
|
impl Args {
|
|
pub fn parse(argv: &[String], valued: &[&str], flags: &[&str]) -> CliResult<Self> {
|
|
let mut a = Args::default();
|
|
let mut it = argv.iter();
|
|
while let Some(arg) = it.next() {
|
|
let name = if let Some(n) = arg.strip_prefix("--") {
|
|
n
|
|
} else if let Some(n) = arg.strip_prefix('-').filter(|n| n.len() == 1 && !n.starts_with(|c: char| c.is_ascii_digit())) {
|
|
n
|
|
} else {
|
|
a.positional.push(arg.clone());
|
|
continue;
|
|
};
|
|
let (name, inline) = match name.split_once('=') {
|
|
Some((n, v)) => (n, Some(v.to_string())),
|
|
None => (name, None),
|
|
};
|
|
if valued.contains(&name) {
|
|
let v = match inline {
|
|
Some(v) => v,
|
|
None => it.next().cloned().ok_or_else(|| CliError::Usage(format!("`{arg}` needs a value")))?,
|
|
};
|
|
a.values.insert(name.to_string(), v);
|
|
} else if flags.contains(&name) && inline.is_none() {
|
|
a.flags.push(name.to_string());
|
|
} else {
|
|
return Err(CliError::Usage(format!("unknown option `{arg}`")));
|
|
}
|
|
}
|
|
Ok(a)
|
|
}
|
|
|
|
pub fn value(&self, k: &str) -> Option<String> {
|
|
self.values.get(k).cloned()
|
|
}
|
|
|
|
pub fn flag(&self, k: &str) -> bool {
|
|
self.flags.iter().any(|f| f == k)
|
|
}
|
|
|
|
pub fn one_positional(&self, usage: &str) -> CliResult<String> {
|
|
match self.positional.as_slice() {
|
|
[one] => Ok(one.clone()),
|
|
_ => Err(CliError::Usage(format!("expected: {usage}"))),
|
|
}
|
|
}
|
|
|
|
/// PDF print options: `--bleed LENGTH` (points, or "3mm", "0.125in"), `--crop-marks`,
|
|
/// `--bleed-marks`, `--cmyk`.
|
|
pub fn print(&self) -> CliResult<figcraft_doc::PrintSettings> {
|
|
let bleed = match self.values.get("bleed") {
|
|
None => 0.0,
|
|
Some(s) => figcraft_doc::PrintSettings::parse_length(s)
|
|
.filter(|b| *b <= figcraft_doc::PrintSettings::MAX_BLEED)
|
|
.ok_or_else(|| CliError::Usage(format!("--bleed takes points or a length like 3mm or 0.125in (up to 2in), got `{s}`")))?,
|
|
};
|
|
Ok(figcraft_doc::PrintSettings { bleed, crop_marks: self.flag("crop-marks"), bleed_marks: self.flag("bleed-marks"), cmyk: self.flag("cmyk") })
|
|
}
|
|
|
|
pub fn scale(&self) -> CliResult<f64> {
|
|
match self.values.get("scale") {
|
|
None => Ok(1.0),
|
|
Some(s) => s
|
|
.trim_end_matches('x')
|
|
.parse::<f64>()
|
|
.ok()
|
|
.filter(|v| v.is_finite() && *v > 0.0 && *v <= 64.0)
|
|
.ok_or_else(|| CliError::Usage(format!("--scale must be a number in (0, 64], got `{s}`"))),
|
|
}
|
|
}
|
|
|
|
/// A comma-separated list of whole numbers (`--layers 1000,10_000`).
|
|
pub fn usizes(&self, k: &str, default: &[usize]) -> CliResult<Vec<usize>> {
|
|
match self.values.get(k) {
|
|
None => Ok(default.to_vec()),
|
|
Some(s) => s
|
|
.split(',')
|
|
.map(|v| v.trim().replace('_', "").parse::<usize>().map_err(|_| CliError::Usage(format!("--{k} must be whole numbers, got `{s}`"))))
|
|
.collect(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
fn v(s: &[&str]) -> Vec<String> {
|
|
s.iter().map(|x| x.to_string()).collect()
|
|
}
|
|
|
|
#[test]
|
|
fn parses_options_and_flags() {
|
|
let a = Args::parse(&v(&["in.figcraft", "-o", "out", "--scale=2", "--json"]), &["o", "scale"], &["json"]).unwrap();
|
|
assert_eq!(a.positional, ["in.figcraft"]);
|
|
assert_eq!(a.value("o").as_deref(), Some("out"));
|
|
assert_eq!(a.scale().unwrap(), 2.0);
|
|
assert!(a.flag("json"));
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_bad_input() {
|
|
assert!(matches!(Args::parse(&v(&["--nope"]), &[], &[]), Err(CliError::Usage(_))));
|
|
assert!(matches!(Args::parse(&v(&["-o"]), &["o"], &[]), Err(CliError::Usage(_))));
|
|
assert!(matches!(Args::parse(&v(&["--json=1"]), &[], &["json"]), Err(CliError::Usage(_))));
|
|
let a = Args::parse(&v(&["--scale", "abc"]), &["scale"], &[]).unwrap();
|
|
assert!(a.scale().is_err());
|
|
let a = Args::parse(&v(&["--scale", "-3"]), &["scale"], &[]).unwrap();
|
|
assert!(a.scale().is_err());
|
|
// Negative numbers are positionals, not options.
|
|
let a = Args::parse(&v(&["-5"]), &[], &[]).unwrap();
|
|
assert_eq!(a.positional, ["-5"]);
|
|
}
|
|
}
|