use super::export::{self, Shape};
use super::prompt;
use crate::judge::{Checker, Config};
use crate::render::explain as render_explain;
use crate::render::{Explanation, Format, InForce};
use crate::rules::{self, Resolution, Sourced};
pub(crate) fn run(
config: &Config,
paths: &[String],
format: Format,
) -> Result<String, String> {
let checker = Checker::configured(config)?;
let asked = paths.first().map(String::as_str);
let (set, winner) = checker.effective(asked.unwrap_or(""))?;
let rules = config.rules()?;
let found = rules::resolve(asked.unwrap_or(""), &rules, &rules::matches);
Ok(render_explain(
format,
&Explanation {
path: asked,
set: &set,
rule: winner.as_ref(),
in_force: in_force(&found),
},
))
}
fn in_force<'a>(found: &'a Resolution<'a>) -> InForce<'a> {
let level = found.leveller.and_then(|rule| {
let value = rule.default_level?;
Some(Sourced {
value,
origin: &rule.origin,
})
});
InForce {
family: &found.family,
family_origin: found.fidelity.map(|rule| &rule.origin),
level,
levels: found.sourced.clone(),
}
}
pub(crate) fn exported(
config: &Config,
paths: &[String],
format: Format,
form: &str,
) -> Result<String, String> {
let shape = Shape::named(form)?;
if format != Format::Human {
return Err(String::from("--as writes text and takes no --format"));
}
let asked = paths.first().map(String::as_str);
match shape {
Shape::Args => export::args(config, asked),
Shape::Lines => export::lines(config, asked),
Shape::Prompt => prompt::render(config, asked),
}
}
#[cfg(test)]
mod tests {
use super::{Config, run};
use crate::cli::testkit::fixture;
use crate::render::Format;
use std::path::Path;
fn explained(root: &Path, path: &[String]) -> String {
run(&crate::cli::config::discovered(root), path, Format::Human)
.unwrap_or_else(|why| why)
}
#[test]
fn explain_names_the_rule_that_won_and_the_line_behind_it() {
let rules = "*.md ascii\ndocs/*.md ascii+caveman\n";
let files = [(".ctrm", rules)];
let Some(root) = fixture("ctrm-explain-fixture", &files) else {
return;
};
let said = explained(&root, &["docs/a.md".to_owned()]);
assert!(said.contains("set ascii+caveman"), "{said}");
assert!(said.contains("pattern docs/*.md"), "{said}");
assert!(said.contains(".ctrm:2"), "{said}");
}
#[test]
fn explain_says_when_no_rule_matched() {
let files = [(".ctrm", "docs/*.md ascii+caveman\n")];
let Some(root) = fixture("ctrm-explain-bare-fixture", &files) else {
return;
};
let said = explained(&root, &["src/main.rs".to_owned()]);
assert!(said.contains("set ascii"), "{said}");
assert!(said.contains("rule none"), "{said}");
}
#[test]
fn explain_names_a_family_and_a_level_the_winner_did_not_set() {
let Some(root) = fixture("ctrm-explain-in-force-fixture", &[]) else {
return;
};
let flags = "--rule|*.md marks|--fidelity|emoji|--rule|*.md !warn";
let said = run(&argued(&root, flags), &["m.md".to_owned()], HUMAN)
.unwrap_or_else(|why| why);
assert!(said.contains("effective family emoji argv[5]"), "{said}");
assert!(said.contains("effective level warn argv[7]"), "{said}");
}
const HUMAN: Format = Format::Human;
fn argued(root: &Path, flags: &str) -> Config {
let words = std::iter::once("explain").chain(flags.split('|'));
let argv: Vec<String> = words.map(str::to_owned).collect();
crate::cli::config::from_argv(root, &argv).unwrap_or_default()
}
#[test]
fn an_undeclared_family_is_refused() {
let Some(root) = fixture("ctrm-sets-bad-family-fixture", &[]) else {
return;
};
let why = argued(&root, "--fidelity|emjoi").validate();
let why = why.err().unwrap_or_default();
assert!(why.contains("argv[3]") && why.contains("emjoi"), "{why}");
assert!(argued(&root, "--rule|* @ascii").validate().is_ok());
}
}