const VALUED: &[&str] = &[
"--format",
"--fidelity",
"--rule",
"--map",
"--set",
"--rules-file",
"--map-file",
"--sets-file",
"-C",
"--as",
"--max",
"--containing",
];
const SWITCHES: &[&str] = &[
"--check",
"--bpe",
"--summary",
"--no-files",
"--no-builtin-map",
"--no-builtin-sets",
"--strict",
"--pedantic",
"--locales",
"--print",
"--keep-fixable",
"--no-color",
"--help",
"-h",
"--version",
"-V",
];
const OWNED: &[(&str, &str)] = &[
("--check", "fix"),
("--bpe", "stats"),
("--as", "explain"),
("--summary", "check"),
("--max", "check"),
("--locales", "sets"),
("--containing", "sets"),
("--print", "init"),
("--keep-fixable", "init"),
];
const END: &str = "--";
#[derive(Debug, Clone, PartialEq, Eq)]
pub(super) struct Flag {
pub name: &'static str,
pub value: Option<String>,
pub index: usize,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(super) struct Args {
pub verb: Option<String>,
pub flags: Vec<Flag>,
pub paths: Vec<String>,
}
impl Args {
#[must_use]
pub(super) fn value(&self, name: &str) -> Option<&str> {
let named = self.flags.iter().rev().find(|flag| flag.name == name);
named.and_then(|flag| flag.value.as_deref())
}
#[must_use]
pub(super) fn has(&self, name: &str) -> bool {
self.flags.iter().any(|flag| flag.name == name)
}
}
pub(super) fn parse(args: &[String]) -> Result<Args, String> {
let mut parsed = Args::default();
let mut words = args.iter().enumerate();
while let Some((at, word)) = words.next() {
if word == END {
parsed.paths.extend(words.map(|(_, rest)| rest.clone()));
break;
}
match flag_of(word)? {
None if parsed.verb.is_none() => parsed.verb = Some(word.clone()),
None => parsed.paths.push(word.clone()),
Some(name) => parsed.flags.push(take(name, at, &mut words)?),
}
}
owned(&parsed)?;
Ok(parsed)
}
pub(super) fn verb_in(args: &[String]) -> Option<&str> {
let mut words = args.iter().map(String::as_str);
while let Some(word) = words.next() {
if word == END {
return None;
}
if VALUED.contains(&word) {
words.next();
} else if !word.starts_with('-') {
return Some(word);
}
}
None
}
fn flag_of(word: &str) -> Result<Option<&'static str>, String> {
if !word.starts_with('-') {
return Ok(None);
}
let known = VALUED.iter().chain(SWITCHES).find(|name| **name == word);
let name = known.ok_or_else(|| format!("unknown flag `{word}`"))?;
Ok(Some(*name))
}
fn owned(read: &Args) -> Result<(), String> {
let verb = read.verb.as_deref().unwrap_or_default();
if !super::usage::VERBS.contains(&verb) {
return Ok(());
}
for flag in &read.flags {
let owner = OWNED.iter().find(|(name, _)| *name == flag.name);
if let Some((name, owner)) = owner.filter(|(_, o)| *o != verb) {
return Err(format!("`{name}` belongs to `{owner}`, not `{verb}`"));
}
}
Ok(())
}
fn take<'a, I>(
name: &'static str,
at: usize,
words: &mut I,
) -> Result<Flag, String>
where
I: Iterator<Item = (usize, &'a String)>,
{
let (at, value) = if VALUED.contains(&name) {
let next = words.next();
let (at, value) =
next.ok_or_else(|| format!("`{name}` needs a value"))?;
(at, Some(value.clone()))
} else {
(at, None)
};
let index = at.saturating_add(1);
Ok(Flag { name, value, index })
}
#[cfg(test)]
mod tests {
use super::{Args, parse};
use crate::cli::testkit::argv;
fn parsed(words: &[&str]) -> Args {
let read = parse(&argv(words));
assert!(read.is_ok(), "{read:?}");
read.unwrap_or_default()
}
fn refused(words: &[&str]) -> String {
parse(&argv(words)).err().unwrap_or_default()
}
#[test]
fn a_value_is_never_a_path_whatever_it_looks_like() {
let read = parsed(&["check", "--rule", "*.md caveman", "a.md"]);
assert_eq!(read.paths, vec!["a.md"]);
assert_eq!(read.value("--rule"), Some("*.md caveman"));
let read = parsed(&["fix", "--map", "-- x", "--check"]);
assert_eq!(read.value("--map"), Some("-- x"));
assert!(read.has("--check") && read.paths.is_empty());
}
#[test]
fn a_flag_carries_the_argv_position_of_its_value() {
let read = parsed(&["check", "--rule", "* box", "--strict"]);
let at: Vec<usize> = read.flags.iter().map(|f| f.index).collect();
assert_eq!(at, vec![3, 4]);
}
#[test]
fn an_unknown_flag_is_refused() {
assert!(refused(&["check", "--stirct"]).contains("--stirct"));
assert!(refused(&["check", "--format=json"]).contains("unknown"));
assert!(refused(&["check", "-"]).contains("unknown"));
}
#[test]
fn a_valued_flag_with_nothing_after_it_is_refused() {
assert!(refused(&["check", "--rule"]).contains("needs a value"));
}
#[test]
fn a_verb_specific_flag_is_refused_on_another_verb() {
assert!(refused(&["check", "--bpe"]).contains("`stats`"));
assert!(refused(&["stats", "--check"]).contains("`fix`"));
assert!(refused(&["check", "--as", "args"]).contains("`explain`"));
assert!(parsed(&["stats", "--bpe"]).has("--bpe"));
}
#[test]
fn a_flag_may_come_before_the_verb() {
let read = parsed(&["-C", "..", "check", "--rule", "* box", "a.md"]);
assert_eq!(read.verb.as_deref(), Some("check"));
assert_eq!(read.value("-C"), Some(".."));
assert_eq!(read.paths, vec!["a.md"]);
let at: Vec<usize> = read.flags.iter().map(|f| f.index).collect();
assert_eq!(at, vec![2, 5]);
assert!(refused(&["--bpe", "check"]).contains("`stats`"));
assert_eq!(parsed(&["--strict"]).verb, None);
}
#[test]
fn a_double_dash_ends_the_flags() {
let read = parsed(&["check", "--", "-odd", "--strict"]);
assert_eq!(read.paths, vec!["-odd", "--strict"]);
assert!(read.flags.is_empty());
}
#[test]
fn the_usage_names_every_flag() {
for flag in super::VALUED.iter().chain(super::SWITCHES) {
assert!(crate::cli::usage::USAGE.contains(flag), "{flag}");
}
}
#[test]
fn no_color_is_accepted_by_every_verb() {
for verb in ["check", "fix", "stats", "explain", "sets"] {
assert!(parsed(&[verb, "--no-color"]).has("--no-color"), "{verb}");
}
}
#[test]
fn the_last_value_of_a_repeated_flag_wins() {
let read = parsed(&["check", "--format", "json", "--format", "sarif"]);
assert_eq!(read.value("--format"), Some("sarif"));
assert_eq!(read.value("--fidelity"), None);
}
}