use lungo_build::{Error, LeanOptions, Result, RustOptions};
use serde::Deserialize;
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
pub const BINDINGS: &[&str] = &["c", "go", "python", "swift", "ts"];
#[derive(Debug, Clone, Default, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ProjectFile {
pub project: PathBuf,
#[serde(default)]
pub lean: LeanOptions,
#[serde(default)]
pub rust: RustOptions,
pub c: Option<Language>,
pub go: Option<Language>,
pub python: Option<Language>,
pub swift: Option<Language>,
pub ts: Option<Language>,
#[serde(default)]
pub plugins: BTreeMap<String, Language>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Language {
pub out: Option<PathBuf>,
#[serde(default)]
pub options: BTreeMap<String, String>,
#[serde(default, rename = "extern-types")]
pub extern_types: BTreeMap<String, lungo_build::codegen::plugin::ExternType>,
}
impl ProjectFile {
pub fn load(path: &Path) -> Result<ProjectFile> {
let text =
std::fs::read_to_string(path).map_err(|e| Error::io(format!("cannot read {}", path.display()), e))?;
let file: ProjectFile =
toml::from_str(&text).map_err(|e| Error::Configuration(format!("{}: {e}", path.display())))?;
for name in file.plugins.keys() {
if name == "rust" || BINDINGS.contains(&name.as_str()) {
return Err(Error::Configuration(format!(
"{}: `{name}` is a built-in generator, configured in its own [{name}] table, not as a plugin",
path.display()
)));
}
validate_language_name(name)?;
}
Ok(file)
}
pub fn language(&self, language: &str) -> Option<&Language> {
match language {
"c" => self.c.as_ref(),
"go" => self.go.as_ref(),
"python" => self.python.as_ref(),
"swift" => self.swift.as_ref(),
"ts" => self.ts.as_ref(),
other => self.plugins.get(other),
}
}
pub fn languages(&self) -> Vec<(String, &Language)> {
let mut out: Vec<(String, &Language)> =
BINDINGS.iter().filter_map(|l| self.language(l).map(|s| (l.to_string(), s))).collect();
out.extend(self.plugins.iter().map(|(k, v)| (k.clone(), v)));
out
}
}
pub fn validate_language_name(name: &str) -> Result<()> {
let valid = name.starts_with(|c: char| c.is_ascii_lowercase())
&& name.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-');
if valid {
Ok(())
} else {
Err(Error::Configuration(format!(
"`{name}` cannot name a generator: use lowercase letters, digits and `-`, starting with a letter"
)))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test0083_project_files_reject_unknown_keys_and_plugins_named_like_built_ins() {
let dir = std::env::temp_dir().join(format!("lungo-config-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let file = dir.join("lungo.toml");
std::fs::write(
&file,
"project = \"lean\"\n[lean]\nhost-externs = [\"h\"]\n[go]\nout = \"gen/go\"\noptions = { package = \"p\" }\n[plugins.kotlin]\nout = \"k\"\n",
)
.unwrap();
let p = ProjectFile::load(&file).unwrap();
assert_eq!(p.go.as_ref().unwrap().options["package"], "p");
assert_eq!(p.languages().iter().map(|(l, _)| l.as_str()).collect::<Vec<_>>(), ["go", "kotlin"]);
std::fs::write(&file, "project = \"lean\"\n[go]\npackage = \"p\"\n").unwrap();
assert!(ProjectFile::load(&file).is_err(), "options belong in `options`");
std::fs::write(&file, "project = \"lean\"\n[plugins.go]\nout = \"x\"\n").unwrap();
assert!(ProjectFile::load(&file).is_err(), "go is built in");
std::fs::write(&file, "project = \"lean\"\n[plugins.Bad_Name]\nout = \"x\"\n").unwrap();
assert!(ProjectFile::load(&file).is_err());
std::fs::remove_dir_all(&dir).unwrap();
}
}