use std::collections::HashSet;
use std::path::{Path, PathBuf};
use telar_project::BuildFlavour;
use telar_transpiler::PackageOptions;
use super::config::find_package_dir;
pub(crate) fn transpile_workspace() -> bool {
let dir = find_package_dir(&[]);
let workspace_root = telar_project::find_workspace_root(&dir).unwrap_or_else(|| dir.clone());
let telar_version = telar_project::resolve_telar_version(&workspace_root)
.unwrap_or_else(|| env!("CARGO_PKG_VERSION").to_string());
super::config::warn_if_foreign_version(&telar_version);
let producer = format!("cargo-telar {}", env!("CARGO_PKG_VERSION"));
let members = telar_project::workspace_member_dirs(&workspace_root);
for member in &members {
for warning in telar_project::orphan_test_warnings(member) {
eprintln!("[cargo-telar] warning: {}: {warning}", member.display());
}
}
members
.iter()
.map(|member| transpile_member(member, &producer, &telar_version))
.collect::<Vec<bool>>()
.iter()
.all(|ok| *ok)
}
pub(super) fn transpile_member(member: &Path, producer: &str, telar_version: &str) -> bool {
let src_dir = member.join("src");
let has_markup = !telar_project::find_rsx_files(&src_dir).is_empty();
let placed = telar_project::invokes_placement_macro(&src_dir);
if !has_markup && !placed {
return true;
}
let name = member
.file_name()
.and_then(|n| n.to_str())
.unwrap_or("package");
let telar = match telar_project::TelarManifest::load(member) {
Ok(manifest) => manifest.telar,
Err(e) => {
eprintln!("[cargo-telar] error: {e}");
return false;
}
};
let assets = telar_project::AssetContext::load(member, &telar, telar_version);
let theme = telar_transpiler::resolve_theme_type(member, &telar);
let prelude = telar.prelude();
let library = telar.library;
let mut reported: Vec<String> = Vec::new();
let mut all_ok = true;
for flavour in BuildFlavour::ALL {
let generated_dir = telar_project::generated_dir(member, flavour);
let mut live: HashSet<PathBuf> = HashSet::new();
if has_markup {
let files = match telar_transpiler::transpile_package(&PackageOptions {
src_dir: &src_dir,
theme_type: theme.as_deref(),
assets: Some(&assets),
prelude,
library,
flavour,
}) {
Ok(files) => files,
Err(error) => {
all_ok = false;
let failure = error.to_build_failure(&src_dir);
if !reported.contains(&failure.message) {
eprintln!("[cargo-telar] error: {}", failure.message);
reported.push(failure.message.clone());
}
if let Err(e) = telar_project::write_build_failure(member, flavour, &failure) {
eprintln!(
"[cargo-telar] warning: could not record {name}'s transpile error: {e}"
);
}
continue;
}
};
telar_project::clear_build_failure(member, flavour);
match telar_transpiler::write_package(&files, &generated_dir) {
Ok(written) => live.extend(written),
Err(e) => {
eprintln!(
"[cargo-telar] warning: could not write {name}'s generated Rust: {e}"
);
return false;
}
}
let index = telar_transpiler::build_index(
&files,
&src_dir,
theme.as_deref(),
prelude,
producer,
telar_version,
);
if let Err(e) = telar_project::write_build_index(member, flavour, &index) {
eprintln!("[cargo-telar] warning: could not write {name}'s build index: {e}");
all_ok = false;
}
}
if placed {
let tree = telar_project::ModuleTree::discover(
&src_dir,
&generated_dir,
flavour.site_file_name(),
telar.module_visibility(),
);
for problem in tree.problems() {
all_ok = false;
if !reported.contains(problem) {
eprintln!("[cargo-telar] error: {problem}");
reported.push(problem.clone());
}
}
match tree.write() {
Ok(written) => live.extend(written),
Err(e) => {
eprintln!("[cargo-telar] warning: could not write {name}'s module tree: {e}");
return false;
}
}
}
telar_project::prune_stale_generated(&generated_dir, &live);
}
let sites: HashSet<PathBuf> = match placed {
true => telar_project::placement_sites(&src_dir)
.into_iter()
.collect(),
false => HashSet::new(),
};
telar_project::prune_stale_sites(&src_dir, &sites);
all_ok
}
#[cfg(test)]
#[path = "transpile.test.rs"]
mod tests;