use super::args::{Args, Flag};
use crate::charset::builtin;
use crate::fix as engine;
use crate::judge::Config;
use crate::rules::Sources;
use std::path::{Path, PathBuf};
pub(super) const RULES: &str = ".ctrm";
pub(super) const SETS: &str = ".ctrm-sets";
pub(super) const MAP: &str = ".ctrm-map";
pub(super) const PEDANTIC: &str = "* !pedantic=warn";
enum Added {
Line(String),
File(String, String),
Fidelity(String),
}
#[cfg(test)]
pub(crate) fn from_argv(cwd: &Path, argv: &[String]) -> Result<Config, String> {
load(cwd, &super::args::parse(argv)?)
}
pub(super) fn load(cwd: &Path, args: &Args) -> Result<Config, String> {
let root = args
.value("-C")
.map_or_else(|| cwd.to_owned(), |d| cwd.join(d));
let mut config = seeded(root, args);
for flag in &args.flags {
absorb(&mut config, flag)?;
}
Ok(config)
}
#[must_use]
pub(crate) fn root_of(cwd: &Path) -> PathBuf {
let top = cwd.ancestors().find(|dir| dir.join(".git").exists());
top.map_or_else(|| cwd.to_owned(), Path::to_path_buf)
}
#[must_use]
pub(super) fn situated(cwd: &Path, args: &mut Args) -> PathBuf {
if args.has("-C") {
return cwd.to_owned();
}
let root = root_of(cwd);
let within = cwd.strip_prefix(&root).unwrap_or_else(|_| Path::new(""));
if within.as_os_str().is_empty() {
return root;
}
let moved = |word: &str| within.join(word).to_string_lossy().into_owned();
args.paths = args.paths.iter().map(|path| moved(path)).collect();
let files = args.flags.iter_mut().filter(|f| f.name.ends_with("-file"));
for flag in files {
flag.value = flag.value.as_deref().map(moved);
}
root
}
#[must_use]
pub(crate) fn discovered(root: &Path) -> Config {
seeded(root.to_owned(), &Args::default())
}
fn seeded(root: PathBuf, args: &Args) -> Config {
let sets = Some((builtin::SETS, "--no-builtin-sets"));
let map = Some((engine::BUILTIN, "--no-builtin-map"));
Config {
rules: seed(&root, args, RULES, None),
sets: seed(&root, args, SETS, sets),
map: seed(&root, args, MAP, map),
strict: args.has("--strict"),
root,
}
}
fn seed(
root: &Path,
args: &Args,
name: &str,
builtin: Option<(&str, &str)>,
) -> Sources {
let mut sources = Sources::new();
if let Some((text, _)) = builtin.filter(|(_, off)| !args.has(off)) {
sources = sources.builtin(text);
}
let read = || std::fs::read_to_string(root.join(name)).ok();
match (!args.has("--no-files")).then(read).flatten() {
Some(text) => sources.dotfile(name, text),
None => sources,
}
}
fn absorb(config: &mut Config, flag: &Flag) -> Result<(), String> {
let Some(added) = added(&config.root, flag)? else {
return Ok(());
};
let Some(sources) = kind(config, flag.name) else {
return Ok(());
};
let held = std::mem::take(sources);
*sources = match added {
Added::Line(line) => held.flag(flag.index, line),
Added::File(path, text) => held.file(path, text),
Added::Fidelity(family) => held.fidelity(flag.index, &family),
};
Ok(())
}
fn added(root: &Path, flag: &Flag) -> Result<Option<Added>, String> {
let value = flag.value.clone().unwrap_or_default();
Ok(Some(match flag.name {
"--rule" | "--set" | "--map" => Added::Line(value),
"--pedantic" => Added::Line(PEDANTIC.to_owned()),
"--fidelity" => Added::Fidelity(value),
"--rules-file" | "--sets-file" | "--map-file" => {
let text =
std::fs::read_to_string(root.join(&value)).map_err(|e| {
format!("{value}: {}", crate::judge::plain(&e.to_string()))
})?;
Added::File(value, text)
}
_ => return Ok(None),
}))
}
fn kind<'a>(config: &'a mut Config, flag: &str) -> Option<&'a mut Sources> {
match flag {
"--rule" | "--rules-file" | "--fidelity" | "--pedantic" => {
Some(&mut config.rules)
}
"--set" | "--sets-file" => Some(&mut config.sets),
"--map" | "--map-file" => Some(&mut config.map),
_ => None,
}
}
#[cfg(test)]
#[path = "config_test.rs"]
mod tests;