use std::fs;
use std::path::{Path, PathBuf};
use super::fault::{Fault, Span};
use super::{Use, parse, plat};
use crate::survey::Dialect;
pub(super) struct Shared {
pub path: PathBuf,
pub root: Option<String>,
pub language: Option<&'static dyn Dialect>,
pub facade: Vec<String>,
pub uses: Vec<Use>,
pub max_hops: Option<u32>,
}
pub(super) fn enclosing(
zone: &Path,
fallback: &'static dyn Dialect,
) -> Result<Option<Shared>, Fault> {
let home = plat::anchor(zone);
let home = home.canonicalize().unwrap_or(home);
let ceiling = crate::repo_root(&home);
for dir in home.ancestors().skip(1).take_while(|d| d.starts_with(&ceiling)) {
for candidate in plat::charters(dir) {
let Some(shared) = claimed(&candidate, dir, &home, fallback)? else { continue };
return Ok(Some(shared));
}
}
Ok(None)
}
fn claimed(
candidate: &Path,
dir: &Path,
home: &Path,
fallback: &'static dyn Dialect,
) -> Result<Option<Shared>, Fault> {
let Ok(source) = fs::read_to_string(candidate) else { return Ok(None) };
let Ok(tree) = parse::parse(&source, candidate) else { return Ok(None) };
let Some(workspace) = tree.workspace else { return Ok(None) };
let Ok(rel) = home.strip_prefix(dir) else { return Ok(None) };
let members = crate::pattern::Globs::new(workspace.members.iter().map(|m| &m.text));
if !members.matches(&plat::posix(rel)) {
return Ok(None);
}
let language = match &workspace.language {
Some(named) => Some(crate::survey::dialect(&named.text).ok_or_else(|| {
let known: Vec<&str> = crate::survey::dialects().iter().map(|d| d.name()).collect();
Fault::at(
format!(
"no language named `{}` — this build reads {}",
named.text,
known.join(", ")
),
named.span.clone(),
&source,
)
})?),
None => None,
};
let dialect = language.unwrap_or(fallback);
let shared = scoped(&workspace.uses, &source)?;
let mut uses = super::resolve_uses(shared, &[], dialect, candidate, &source)?;
for grant in &mut uses {
grant.inherited = true;
}
Ok(Some(Shared {
path: candidate.to_path_buf(),
root: workspace.root.as_ref().map(|t| t.text.clone()),
language,
facade: workspace.facade.iter().map(|t| t.text.clone()).collect(),
uses,
max_hops: workspace.reach.map(|(hops, _)| hops),
}))
}
fn scoped<'a>(uses: &'a [parse::Use], source: &str) -> Result<&'a [parse::Use], Fault> {
for grant in uses {
for word in &grant.scope {
if !word.text.contains(['/', '*', '?', '[', '.']) {
return Err(Fault::at(
format!(
"`{}` is a zone name, and a workspace has no zones — every member \
names its own. Scope a shared grant with a path glob, or leave the \
`by` off to grant every member",
word.text
),
word.span.clone(),
source,
));
}
}
}
Ok(uses)
}
pub(super) fn blame(shared: &Shared, message: &str, span: Span, source: &str) -> Fault {
let file =
shared.path.file_name().map_or_else(String::new, |n| n.to_string_lossy().into_owned());
Fault::at(format!("{message} — inherited from `{file}`"), span, source)
}