mod fault;
mod law;
mod lex;
mod parse;
use std::collections::HashMap;
use std::fs;
use std::path::{Path, PathBuf};
pub use fault::{Fault, Span};
pub use law::Law;
use crate::pattern::{Globs, Pattern};
pub struct Zone {
pub name: String,
pub rank: usize,
pub paths: Globs,
}
pub struct Seal {
pub path: String,
pub entry: String,
pub open: Globs,
}
pub struct Keep {
pub subject: Pattern,
pub importers: Globs,
}
pub struct Variance {
pub law: Law,
pub subject: String,
pub reason: String,
pub source: String,
}
pub struct Ordinance {
pub path: PathBuf,
pub package: String,
pub module_root: PathBuf,
pub facade: Globs,
pub exclude: Vec<Pattern>,
pub zones: Vec<Zone>,
pub seals: Vec<Seal>,
pub keeps: Vec<Keep>,
pub max_hops: Option<u32>,
pub variances: Vec<Variance>,
granted: HashMap<(Law, String), usize>,
}
impl Ordinance {
pub fn read(path: &Path) -> Result<Self, Fault> {
let source =
fs::read_to_string(path).map_err(|e| Fault::at(e.to_string(), Span::head(path), ""))?;
resolve(parse::parse(&source, path)?, path, &source)
}
#[must_use]
pub fn variance(&self, law: Law, subject: &str) -> Option<&Variance> {
self.granted.get(&(law, subject.to_owned())).map(|&i| &self.variances[i])
}
#[must_use]
pub fn is_facade(&self, rel: &str) -> bool {
self.facade.matches(rel)
}
pub fn zones_claiming(&self, rel: &str) -> impl Iterator<Item = &Zone> {
self.zones.iter().filter(move |z| z.paths.matches(rel))
}
#[must_use]
pub fn zone_of(&self, rel: &str) -> Option<&Zone> {
let mut found = self.zones_claiming(rel);
found.next().filter(|_| found.next().is_none())
}
}
#[must_use]
pub fn cycle_subject(members: &[String]) -> String {
let mut sorted: Vec<&str> = members.iter().map(String::as_str).collect();
sorted.sort_unstable();
sorted.join(" + ")
}
fn resolve(tree: parse::Tree, path: &Path, source: &str) -> Result<Ordinance, Fault> {
let pkg = tree.package;
let root = pkg.root.as_ref().map_or("src", |t| t.text.as_str());
let base = path.parent().and_then(Path::parent).unwrap_or(Path::new("."));
let module_root = base.join(root);
if !module_root.is_dir() {
let blame = pkg.root.as_ref().unwrap_or(&pkg.name);
return Err(Fault::at(
format!("source root `{root}` is not a directory"),
blame.span.clone(),
source,
));
}
let module_root = module_root.canonicalize().unwrap_or(module_root);
let zones = resolve_zones(&tree.zones, source)?;
let seals = resolve_seals(&tree.seals, &module_root, root, source)?;
let keeps = resolve_keeps(&tree.keeps, source)?;
let (variances, granted) = resolve_variances(&tree.variances, path, source)?;
Ok(Ordinance {
path: path.to_path_buf(),
package: pkg.name.text,
module_root,
facade: Globs::new(pkg.facade.iter().map(|t| &t.text)),
exclude: pkg.exclude.iter().map(|t| Pattern::new(&t.text)).collect(),
zones,
seals,
keeps,
max_hops: tree.reach.map(|(n, _)| n),
variances,
granted,
})
}
fn resolve_zones(declared: &[parse::Zone], source: &str) -> Result<Vec<Zone>, Fault> {
let mut zones = Vec::with_capacity(declared.len());
let mut seen: HashMap<&str, usize> = HashMap::new();
for (rank, zone) in declared.iter().enumerate() {
if let Some(line) = seen.insert(&zone.name.text, zone.name.span.line) {
return Err(Fault::at(
format!("zone `{}` was already declared on line {line}", zone.name.text),
zone.name.span.clone(),
source,
));
}
zones.push(Zone {
name: zone.name.text.clone(),
rank,
paths: Globs::new(zone.globs.iter().map(|g| &g.text)),
});
}
Ok(zones)
}
fn resolve_seals(
declared: &[parse::Seal],
module_root: &Path,
root: &str,
source: &str,
) -> Result<Vec<Seal>, Fault> {
let mut seals = Vec::with_capacity(declared.len());
for seal in declared {
let directory = &seal.path.text;
if !module_root.join(directory).is_dir() {
return Err(Fault::at(
format!("`{directory}` is not a directory under {root}/"),
seal.path.span.clone(),
source,
));
}
let inside = format!("{directory}/{}", seal.entry.text);
let beside = match directory.rsplit_once('/') {
Some((parent, _)) => format!("{parent}/{}", seal.entry.text),
None => seal.entry.text.clone(),
};
let Some(entry) = [inside, beside].into_iter().find(|c| module_root.join(c).is_file())
else {
return Err(Fault::at(
format!(
"seal entry `{}` is neither inside `{directory}/` nor beside it",
seal.entry.text
),
seal.entry.span.clone(),
source,
));
};
seals.push(Seal {
path: directory.clone(),
entry,
open: Globs::new(seal.open.iter().map(|g| &g.text)),
});
}
Ok(seals)
}
fn resolve_keeps(declared: &[parse::Keep], source: &str) -> Result<Vec<Keep>, Fault> {
let mut keeps = Vec::with_capacity(declared.len());
let mut kept: HashMap<&str, usize> = HashMap::new();
for keep in declared {
if let Some(line) = kept.insert(&keep.subject.text, keep.subject.span.line) {
return Err(Fault::at(
format!(
"`{}` is already kept on line {line} — merge the guest lists so one \
line names everyone who may reach it",
keep.subject.text
),
keep.subject.span.clone(),
source,
));
}
keeps.push(Keep {
subject: Pattern::new(&keep.subject.text),
importers: Globs::new(keep.importers.iter().map(|g| &g.text)),
});
}
Ok(keeps)
}
type Ratified = (Vec<Variance>, HashMap<(Law, String), usize>);
fn resolve_variances(
declared: &[parse::Variance],
path: &Path,
source: &str,
) -> Result<Ratified, Fault> {
let file = path.file_name().map_or_else(String::new, |n| n.to_string_lossy().into_owned());
let mut variances: Vec<Variance> = Vec::with_capacity(declared.len());
let mut granted: HashMap<(Law, String), usize> = HashMap::new();
for variance in declared {
let Some(law) = Law::parse(&variance.law.text) else {
return Err(Fault::at(
format!("`{}` is not one of the six laws", variance.law.text),
variance.law.span.clone(),
source,
));
};
let words: Vec<String> = variance.subject.iter().map(|t| t.text.clone()).collect();
let subject = if law == Law::Cycle {
cycle_subject(&words)
} else {
format!("{} -> {}", words[0], words[1])
};
if let Some(&prior) = granted.get(&(law, subject.clone())) {
return Err(Fault::at(
format!(
"a second `variance {law}` for the same subject — already ratified at {}",
variances[prior].source
),
variance.law.span.clone(),
source,
));
}
granted.insert((law, subject.clone()), variances.len());
variances.push(Variance {
law,
subject,
reason: variance.reason.text.trim().to_owned(),
source: format!("{file}:{}", variance.law.span.line),
});
}
Ok((variances, granted))
}
#[must_use]
pub fn discover(repo_root: &Path, roots: &[String]) -> Vec<PathBuf> {
let mut found = zone_files(&repo_root.join("contract"));
for root in roots {
let base = repo_root.join(root);
let Ok(entries) = fs::read_dir(&base) else { continue };
let mut packages: Vec<PathBuf> =
entries.flatten().map(|e| e.path()).filter(|p| p.is_dir()).collect();
packages.sort();
for package in packages {
found.extend(zone_files(&package.join("contract")));
}
}
found
}
fn zone_files(dir: &Path) -> Vec<PathBuf> {
let Ok(entries) = fs::read_dir(dir) else { return Vec::new() };
let mut found: Vec<PathBuf> = entries
.flatten()
.map(|e| e.path())
.filter(|p| p.extension().is_some_and(|e| e == "zone") && p.is_file())
.collect();
found.sort();
found
}