use indexmap::IndexMap;
use std::fmt;
use std::path::PathBuf;
use crate::checker::check_module;
use crate::cli::{check_files, file_tag, open_universe};
use crate::module::{run_universe, Bind, Module};
use crate::parse::parse_source;
use crate::pipeline::run_pipeline;
pub use crate::pipeline::{evaluate_source, Report};
use crate::render::{absolute, declared_form, emit_root, resolve_in, Emission, Emitted, Form};
use crate::semantics::{read_json, Diag};
use crate::yaml::{is_yaml_path, read_yaml, to_json as json_text, to_yaml as yaml_text};
use std::rc::Rc;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Diagnostic {
pub file: String,
pub code: Option<String>,
pub id: Option<String>,
pub severity: String,
pub message: String,
pub path: String,
pub location: Option<(String, usize, usize)>,
}
#[derive(Clone, Debug)]
pub struct DeclError {
pub message: String,
pub diagnostics: Vec<Diagnostic>,
}
impl fmt::Display for DeclError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.message)
}
}
impl std::error::Error for DeclError {}
#[derive(Clone, Debug)]
pub enum Document {
File(PathBuf),
Json(String),
}
#[derive(Clone, Debug, Default)]
pub struct EvaluateOptions {
pub inputs: Vec<(String, Document)>,
pub outputs: Vec<String>,
}
fn tagged(file: &str, d: &Diag) -> Diagnostic {
Diagnostic {
file: file.to_string(),
code: d.code.clone(),
id: d.id.clone(),
severity: d.severity.clone(),
message: d.message.clone(),
path: d.path.clone(),
location: d
.loc
.as_ref()
.map(|l| (file.to_string(), l.sl + 1, l.sc + 1)),
}
}
fn fail<T>(fallback: &str, diagnostics: Vec<Diagnostic>) -> Result<T, DeclError> {
let message = diagnostics
.first()
.map(|d| d.message.clone())
.unwrap_or_else(|| fallback.to_string());
Err(DeclError {
message,
diagnostics,
})
}
fn bind_inputs(
modules: &[Rc<Module>],
file: &str,
inputs: &[(String, Document)],
) -> Result<Vec<Bind>, DeclError> {
let mut binds = vec![];
for (name, doc) in inputs {
let Some(module) = modules
.iter()
.find(|m| m.env.inputs.borrow().contains_key(name))
else {
return Err(DeclError {
message: format!("no input named {name}"),
diagnostics: vec![],
});
};
let e6004 = |message: String| Diagnostic {
file: file.to_string(),
code: Some("E6004".into()),
id: None,
severity: "error".into(),
location: None,
message,
path: name.clone(),
};
let (text, place) = match doc {
Document::File(p) => match std::fs::read_to_string(p) {
Ok(t) => (t, p.display().to_string()),
Err(_) => {
return fail(
"",
vec![e6004(format!(
"bound document cannot be read: {}",
p.display()
))],
)
}
},
Document::Json(t) => (t.clone(), name.clone()),
};
let yaml = matches!(doc, Document::File(p) if is_yaml_path(&p.display().to_string()));
let raw = if yaml {
match read_yaml(&text) {
Ok(v) => v,
Err(e) => {
return fail(
"",
vec![e6004(format!(
"bound document is not well-formed YAML: {place}: {e}"
))],
)
}
}
} else {
match read_json(&text) {
Ok(v) => v,
Err(_) => {
return fail(
"",
vec![e6004(format!(
"bound document is not well-formed JSON: {place}"
))],
)
}
}
};
binds.push(Bind {
module: Some(module.clone()),
input: name.clone(),
raw,
});
}
Ok(binds)
}
pub fn evaluate(path: &str, opts: &EvaluateOptions) -> Result<IndexMap<String, String>, DeclError> {
let r = open_universe(path);
let Some(entry) = r.entry.clone() else {
return fail(
&format!("{path}: cannot be loaded"),
r.diags.iter().map(|d| tagged(path, d)).collect(),
);
};
if !r.diags.is_empty() {
return fail("", r.diags.iter().map(|d| tagged(path, d)).collect());
}
let checks: Vec<Diagnostic> = r
.modules
.iter()
.flat_map(|m| {
let tag = file_tag(path, Some(entry.path.as_path()), &m.path);
check_module(&m.decls, Some(m.env.clone()), None)
.iter()
.map(|d| tagged(&tag, d))
.collect::<Vec<_>>()
})
.collect();
if checks.iter().any(|d| d.severity == "error") {
return fail("", checks);
}
let binds = bind_inputs(&r.modules, path, &opts.inputs)?;
let (eng, diags) = run_universe(&r.modules, &entry, binds);
let report: Vec<Diagnostic> = diags.iter().map(|d| tagged(path, d)).collect();
if report.iter().any(|d| d.severity == "error") {
return fail("", report);
}
let names: Vec<String> = if opts.outputs.is_empty() {
entry
.decls
.iter()
.filter(|d| d.exported)
.filter_map(|d| match &d.body {
crate::ast::DeclBody::Output { name, .. } => Some(name.clone()),
_ => None,
})
.collect()
} else {
opts.outputs.clone()
};
let mut out = IndexMap::new();
for n in &names {
let Some(v) = entry.env.root(n) else {
return Err(DeclError {
message: format!("no root named {n}"),
diagnostics: report,
});
};
out.insert(n.clone(), eng.serialize(&v, n, false));
}
Ok(out)
}
#[derive(Debug, Clone)]
pub enum TemplateSource {
File(PathBuf),
Text(String),
}
#[derive(Debug, Clone, Default)]
pub struct RenderOptions {
pub inputs: Vec<(String, Document)>,
pub outputs: Vec<String>,
pub yaml: Option<bool>,
pub indent: Option<usize>,
pub templates: Vec<(String, TemplateSource)>,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Rendered {
Text(String),
Files(IndexMap<String, String>),
}
pub fn render(path: &str, opts: &RenderOptions) -> Result<IndexMap<String, Rendered>, DeclError> {
let r = open_universe(path);
let Some(entry) = r.entry.clone() else {
return fail(
&format!("{path}: cannot be loaded"),
r.diags.iter().map(|d| tagged(path, d)).collect(),
);
};
if !r.diags.is_empty() {
return fail("", r.diags.iter().map(|d| tagged(path, d)).collect());
}
let checks: Vec<Diagnostic> = r
.modules
.iter()
.flat_map(|m| {
let tag = file_tag(path, Some(entry.path.as_path()), &m.path);
check_module(&m.decls, Some(m.env.clone()), None)
.iter()
.map(|d| tagged(&tag, d))
.collect::<Vec<_>>()
})
.collect();
if checks.iter().any(|d| d.severity == "error") {
return fail("", checks);
}
let binds = bind_inputs(&r.modules, path, &opts.inputs)?;
let (eng, diags) = run_universe(&r.modules, &entry, binds);
let report: Vec<Diagnostic> = diags.iter().map(|d| tagged(path, d)).collect();
if report.iter().any(|d| d.severity == "error") {
return fail("", report);
}
let names: Vec<String> = if opts.outputs.is_empty() {
entry
.decls
.iter()
.filter(|d| d.exported)
.filter_map(|d| match &d.body {
crate::ast::DeclBody::Output { name, .. } => Some(name.clone()),
_ => None,
})
.collect()
} else {
opts.outputs.clone()
};
let texts: std::cell::RefCell<std::collections::HashMap<String, Option<String>>> =
std::cell::RefCell::new(std::collections::HashMap::new());
let read_tpl = |abs: &str| -> Option<String> {
if !texts.borrow().contains_key(abs) {
let t = std::fs::read_to_string(abs).ok();
texts.borrow_mut().insert(abs.to_string(), t);
}
texts.borrow().get(abs).cloned().flatten()
};
let e7003 = |file: &str, n: &str| -> DeclError {
DeclError {
message: "template cannot be read".into(),
diagnostics: vec![Diagnostic {
file: file.to_string(),
code: Some("E7003".into()),
id: None,
severity: "error".into(),
message: "template cannot be read".into(),
path: n.to_string(),
location: None,
}],
}
};
let mut out: IndexMap<String, Rendered> = IndexMap::new();
for n in &names {
let Some(v) = entry.env.root(n) else {
return Err(DeclError {
message: format!("no root named {n}"),
diagnostics: report,
});
};
let found = r.modules.iter().find_map(|m| {
m.decls
.iter()
.find(|d| matches!(&d.body, crate::ast::DeclBody::Output { name, .. } if name == n))
.map(|d| (d, m))
});
let form = match found {
Some((d, _)) => match declared_form(d) {
Ok(f) => f,
Err(m) => {
return fail(
"",
vec![Diagnostic {
file: path.to_string(),
code: Some("E7004".into()),
id: None,
severity: "error".into(),
message: m,
path: n.clone(),
location: None,
}],
)
}
},
None => Form::default(),
};
let src = opts
.templates
.iter()
.find(|(k, _)| k == n)
.or_else(|| opts.templates.iter().find(|(k, _)| k == "*"))
.map(|(_, t)| t);
let template: Option<(String, String, String)> = match src {
Some(TemplateSource::File(p)) => {
let given = p.to_string_lossy().to_string();
let abs = absolute(&given);
let Some(text) = read_tpl(&abs) else {
return Err(e7003(&given, n));
};
Some((given, text, parent_of(&abs)))
}
Some(TemplateSource::Text(t)) => {
let cwd = std::env::current_dir()
.map(|p| p.to_string_lossy().to_string())
.unwrap_or_else(|_| ".".into());
Some(("<text>".into(), t.clone(), cwd))
}
None => match &form.template {
Some(t) => {
let dir = found
.and_then(|(_, m)| m.path.parent().map(|p| p.to_string_lossy().to_string()))
.unwrap_or_else(|| ".".into());
let abs = resolve_in(&dir, t);
let Some(text) = read_tpl(&abs) else {
return Err(e7003(t, n));
};
Some((t.clone(), text, parent_of(&abs)))
}
None => None,
},
};
match emit_root(&Emission {
eng: eng.clone(),
menv: entry.env.clone(),
root_name: n.clone(),
value: v,
form,
yaml: opts.yaml,
indent: opts.indent,
template,
read_template: &read_tpl,
}) {
Ok(Emitted::One(text)) => {
out.insert(n.clone(), Rendered::Text(text));
}
Ok(Emitted::Many(files)) => {
out.insert(n.clone(), Rendered::Files(files.into_iter().collect()));
}
Err(e) => {
return fail(
"",
vec![tagged(e.file.as_deref().unwrap_or(path), &e.diag())],
)
}
}
}
Ok(out)
}
fn parent_of(p: &str) -> String {
std::path::Path::new(p)
.parent()
.map(|d| d.to_string_lossy().to_string())
.unwrap_or_else(|| ".".into())
}
pub fn check(paths: &[&str]) -> Vec<Diagnostic> {
let owned: Vec<String> = paths.iter().map(|p| p.to_string()).collect();
check_files(&owned)
.iter()
.map(|(file, d)| tagged(file, d))
.collect()
}
pub fn validate(path: &str, inputs: &[(String, Document)]) -> Result<Vec<Diagnostic>, DeclError> {
let src = std::fs::read_to_string(path).map_err(|_| DeclError {
message: format!("{path}: cannot be read"),
diagnostics: vec![],
})?;
let parsed = parse_source(&src);
if !parsed.errors.is_empty() {
return Err(DeclError {
message: format!("{path}: {} parse error(s)", parsed.errors.len()),
diagnostics: vec![],
});
}
let checks: Vec<Diagnostic> = check_module(&parsed.decls, None, None)
.iter()
.map(|d| tagged(path, d))
.collect();
if checks.iter().any(|d| d.severity == "error") {
return Ok(checks);
}
let mut all = checks;
if !inputs.is_empty() {
let r = open_universe(path);
let Some(entry) = r.entry.clone() else {
return fail(
&format!("{path}: cannot be loaded"),
r.diags.iter().map(|d| tagged(path, d)).collect(),
);
};
let binds = bind_inputs(&r.modules, path, inputs)?;
let (_, diags) = run_universe(&r.modules, &entry, binds);
all.extend(diags.iter().map(|d| tagged(path, d)));
return Ok(all);
}
all.extend(
run_pipeline(&parsed.decls)
.diags
.iter()
.map(|d| tagged(path, d)),
);
Ok(all)
}
pub fn format_source(text: &str) -> Result<String, DeclError> {
crate::fmt::format(text).map_err(|message| DeclError {
message,
diagnostics: vec![],
})
}
fn raw_of(text: &str) -> Result<crate::semantics::Value, DeclError> {
read_json(text).map_err(|_| DeclError {
message: "not well-formed JSON".into(),
diagnostics: vec![],
})
}
pub fn to_json(text: &str, indent: usize) -> Result<String, DeclError> {
Ok(json_text(&raw_of(text)?, indent))
}
pub fn to_yaml(text: &str, indent: usize) -> Result<String, DeclError> {
Ok(yaml_text(&raw_of(text)?, indent))
}