use assert_cmd::Command;
use std::collections::{BTreeMap, BTreeSet};
const DIR: &str = env!("CARGO_MANIFEST_DIR");
const EXEMPT: &[(&str, &str, &str)] = &[
("check", "--bpe", "pinned, not selectable"),
];
const UNPROBED: &[&str] = &["--ollama", "--help"];
#[test]
fn section_i_promises_no_flag_the_build_refuses() {
let broken: Vec<String> = documented()
.into_iter()
.flat_map(|(verb, flags)| refused(verb, flags))
.collect();
assert!(
broken.is_empty(),
"section I promises what the binary refuses -- build it, or mark \
it PLANNED as `cap` and `headroom` do (V106/B31):\n{broken:#?}"
);
}
fn refused(verb: String, flags: BTreeSet<String>) -> Vec<String> {
flags
.into_iter()
.filter(|f| !skip(&verb, f) && refuses(&verb, f))
.map(|f| format!("{verb} {f}"))
.collect()
}
#[test]
fn the_advertised_surface_is_documented() {
let spec = documented();
let mut missing = Vec::new();
for (verb, flags) in advertised() {
let named = spec.get(&verb).cloned().unwrap_or_default();
for flag in flags {
if !named.contains(&flag) {
missing.push(format!("{verb} {flag}"));
}
}
}
assert!(
missing.is_empty(),
"the binary advertises what section I never names:\n{missing:#?}"
);
}
#[test]
fn no_exemption_hides_a_flag_the_build_accepts() {
let stale: Vec<String> = EXEMPT
.iter()
.filter(|(verb, flag, _)| {
!UNPROBED.contains(flag)
&& !feature_gated(flag)
&& !refuses(verb, flag)
})
.map(|(verb, flag, why)| format!("{verb} {flag} -- claims: {why}"))
.collect();
assert!(
stale.is_empty(),
"these flags WORK; delete their EXEMPT rows and let section I say \
so (B36):\n{stale:#?}"
);
}
fn skip(verb: &str, flag: &str) -> bool {
UNPROBED.contains(&flag)
|| feature_gated(flag)
|| EXEMPT.iter().any(|(v, f, _)| *v == verb && *f == flag)
}
fn feature_gated(flag: &str) -> bool {
(!cfg!(feature = "bpe") && flag == "--bpe")
|| (!cfg!(feature = "session") && flag == "--session")
}
fn refuses(verb: &str, flag: &str) -> bool {
let Ok(mut probe) = Command::cargo_bin("itok") else {
return false;
};
let out = probe
.current_dir(sandbox())
.env_remove("GIT_DIR")
.env_remove("GIT_WORK_TREE")
.env_remove("GIT_INDEX_FILE")
.args([verb, flag])
.write_stdin("")
.output();
out.is_ok_and(|o| {
let err = String::from_utf8_lossy(&o.stderr);
err.contains("unknown") && err.contains(flag)
})
}
fn sandbox() -> std::path::PathBuf {
let dir = std::env::temp_dir().join("itok-surface-probe");
std::fs::create_dir_all(&dir).ok();
dir
}
fn documented() -> BTreeMap<String, BTreeSet<String>> {
let path = std::path::Path::new(DIR).join("SPEC.md");
let text = std::fs::read_to_string(path).unwrap_or_default();
let verbs: BTreeSet<String> = advertised().into_keys().collect();
let mut out: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
for line in text.lines() {
if let Some(rest) = line.strip_prefix("- `itok ") {
let owner = rest.split_whitespace().next().unwrap_or("");
absorb(&mut out, &verbs, owner.trim_matches('`'), line);
} else if line.starts_with("- `--") {
shared_flag(&mut out, line);
}
}
out
}
fn absorb(
out: &mut BTreeMap<String, BTreeSet<String>>,
verbs: &BTreeSet<String>,
owner: &str,
line: &str,
) {
for (i, span) in line.split('`').enumerate() {
let inside = i % 2 == 1;
let who = if inside {
owner_of(verbs, span, owner)
} else {
owner
};
let mut found = long_flags(span);
if inside && short_flag(span.trim()) {
found.insert(span.trim().to_owned());
}
out.entry(who.to_owned()).or_default().extend(found);
}
}
fn owner_of<'a>(
verbs: &BTreeSet<String>,
span: &'a str,
fallback: &'a str,
) -> &'a str {
let first = span.split_whitespace().next().unwrap_or("");
if verbs.contains(first) {
first
} else {
fallback
}
}
fn shared_flag(out: &mut BTreeMap<String, BTreeSet<String>>, line: &str) {
let Some(flag) = long_flags(line).into_iter().next() else {
return;
};
let Some(after) = line.split_once('(') else {
return;
};
let Some((verbs, _)) = after.1.split_once(')') else {
return;
};
for verb in verbs.split('/') {
out.entry(verb.trim().to_owned())
.or_default()
.insert(flag.clone());
}
}
fn advertised() -> BTreeMap<String, BTreeSet<String>> {
let path = std::path::Path::new(DIR).join("src/docs.rs");
let text = std::fs::read_to_string(path).unwrap_or_default();
let mut out: BTreeMap<String, BTreeSet<String>> = BTreeMap::new();
for line in text.lines() {
let Some(rest) = line.trim().strip_prefix("synopsis: \"") else {
continue;
};
let Some(verb) = rest.split_whitespace().next() else {
continue;
};
out.entry(verb.to_owned()).or_default().extend(flags(rest));
}
out
}
fn flags(line: &str) -> BTreeSet<String> {
let mut out = BTreeSet::new();
out.extend(long_flags(line));
for span in line.split('`').skip(1).step_by(2) {
let name = span.trim();
if short_flag(name) {
out.insert(name.to_owned());
}
}
out
}
fn long_flags(line: &str) -> BTreeSet<String> {
let mut out = BTreeSet::new();
for word in line.split(|c: char| !(c.is_alphanumeric() || c == '-')) {
let name = word.trim_end_matches('-');
if name.starts_with("--") && name.len() > 2 {
out.insert(name.to_owned());
}
}
out
}
fn short_flag(name: &str) -> bool {
let mut chars = name.chars();
chars.next() == Some('-')
&& chars.next().is_some_and(char::is_alphabetic)
&& chars.next().is_none()
}