use crate::charset::{self, SetCatalog, SetDefinition, builtin};
use crate::fix::{self as engine, Map};
use crate::rules::{self, Place, Rule, Sources};
use std::path::PathBuf;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub(crate) struct Config {
pub(crate) root: PathBuf,
pub(crate) rules: Sources,
pub(crate) sets: Sources,
pub(crate) map: Sources,
pub(crate) strict: bool,
}
impl Config {
pub(crate) fn validate(&self) -> Result<(), String> {
let catalog = self.catalog()?;
let map = self.map()?;
for rule in self.rules()? {
declared(&map, &rule)?;
granted(&catalog, &rule)?;
}
Ok(())
}
pub(crate) fn rules(&self) -> Result<Vec<Rule>, String> {
self.rules.rules().map_err(|bad| bad.to_string())
}
pub(crate) fn catalog(&self) -> Result<SetCatalog, String> {
let mut catalog = self.declared()?;
if self.sets.has_builtin() {
let wanted = self.rules()?.into_iter().flat_map(|rule| rule.sets);
charset::adopt(&mut catalog, wanted)
.map_err(|bad| bad.to_string())?;
}
Ok(catalog)
}
pub(crate) fn listing(&self) -> Result<SetCatalog, String> {
let mut catalog = self.declared()?;
if self.sets.has_builtin() {
charset::adopt_all(&mut catalog).map_err(|bad| bad.to_string())?;
}
Ok(catalog)
}
fn declared(&self) -> Result<SetCatalog, String> {
let declared = self.sets.assemble(set_line);
let declared = declared.map_err(|bad| bad.to_string())?;
let mut catalog = builtin::intrinsic_catalog();
for definition in declared {
catalog.insert(definition);
}
Ok(catalog)
}
pub(crate) fn map(&self) -> Result<Map, String> {
let mut map = Map::default();
for (place, text) in self.map.layers() {
let line = one_line(place, text)?;
let named = |bad| located(place, &bad);
map = map.layer(&line, &|n| place.origin(n)).map_err(named)?;
}
Ok(map)
}
}
fn declared(map: &Map, rule: &Rule) -> Result<(), String> {
let Some(family) = &rule.family else {
return Ok(());
};
match map.tree().path(family) {
Ok(_) => Ok(()),
Err(bad) => Err(format!("{}: {bad}", rules::describe(&rule.origin))),
}
}
fn granted(catalog: &SetCatalog, rule: &Rule) -> Result<(), String> {
let family = rule.family.as_deref().unwrap_or(rules::TEXT);
match catalog.resolve_union(&rule.pattern, &rule.sets, family) {
Ok(_) => Ok(()),
Err(bad) => {
let hint = suggested(catalog, &bad);
Err(format!("{}: {bad}{hint}", rules::describe(&rule.origin)))
}
}
}
fn suggested(catalog: &SetCatalog, bad: &charset::ComposeError) -> String {
let charset::ComposeError::Unknown(name) = bad else {
return String::new();
};
super::nearest(name, catalog.names())
.map(|near| format!(" (did you mean '{near}'?)"))
.unwrap_or_default()
}
fn one_line(place: Place<'_>, text: &str) -> Result<String, String> {
let Place::Argument(index) = place else {
return Ok(text.to_owned());
};
let kept = rules::parse_flag(text, index, |line, _| Ok(line.to_owned()));
let kept = kept.map_err(|bad| bad.to_string())?;
Ok(kept.unwrap_or_default())
}
fn located(place: Place<'_>, bad: &engine::Error) -> String {
match (place, bad.line()) {
(Place::Argument(_), Some(_)) => {
format!("{}: {}", at(place), bad.reason())
}
(_, Some(line)) => format!("{}:{line}: {}", at(place), bad.reason()),
(_, None) => format!("{}: {bad}", at(place)),
}
}
fn at(place: Place<'_>) -> String {
match place {
Place::Builtin => String::from("builtin"),
Place::File(path) => path.display().to_string(),
Place::Argument(index) => format!("argv[{index}]"),
}
}
fn set_line(
line: &str,
origin: rules::Origin,
) -> Result<SetDefinition, rules::ParseError> {
match charset::parse_line(line) {
Ok(Some(declared)) => unreserved(declared, origin),
Ok(None) => Err(rules::error(origin, "declares no set")),
Err(bad) => Err(rules::error(origin, bad.to_string())),
}
}
fn unreserved(
declared: SetDefinition,
origin: rules::Origin,
) -> Result<SetDefinition, rules::ParseError> {
let name = declared.name.as_str();
let reserved =
name == charset::ASCII || name == "any" || name.starts_with("hazard");
if !reserved || matches!(origin, rules::Origin::Builtin { .. }) {
return Ok(declared);
}
let why = format!(
"set `{name}` is reserved and cannot be redeclared \
(`ascii`, `any` and `hazard*` are the tool's own) -- pick another name"
);
Err(rules::error(origin, why))
}