mod artifact;
pub mod browser;
mod cache;
mod execute;
mod execution_plan;
mod lock;
mod manifest;
mod publication;
mod staging;
use std::fs;
use std::path::PathBuf;
use serde::Serialize;
use crate::diagnostic::{BuiltinDiagnostic, Diagnostic, Result};
use crate::preflight::PreparedPlan;
use crate::source::SourceSpan;
use execution_plan::ExecutionPlan;
use lock::{FileLock, sibling_lock_path};
use publication::PublicationTransaction;
#[derive(Clone, Debug, Serialize)]
pub struct RenderReport {
pub output: PathBuf,
pub manifest: PathBuf,
pub cache_hits: usize,
pub cache_misses: usize,
}
pub fn render(plan: &PreparedPlan) -> Result<RenderReport> {
plan.verify_tool_identities()?;
let source_directory = plan.entrypoint_source().base_directory().ok_or_else(|| {
Diagnostic::builtin(
BuiltinDiagnostic::InvalidPlan,
"prepared plan has no entrypoint base directory",
SourceSpan::source_start(plan.entrypoint_source().clone()),
)
})?;
let cache_directory = source_directory
.join(".clipasm")
.join("cache")
.join(plan.execution_namespace());
fs::create_dir_all(&cache_directory).map_err(|error| {
Diagnostic::builtin(
BuiltinDiagnostic::CacheIo,
format!(
"could not create cache directory `{}`: {error}",
cache_directory.display()
),
SourceSpan::source_start(plan.entrypoint_source().clone()),
)
})?;
let execution = ExecutionPlan::build(plan, &cache_directory)?.execute(plan)?;
let result_node = &plan.nodes()[plan.result().get() as usize];
let result_artifact = execution.artifact(plan.result(), &result_node.origin().span)?;
if let Some(parent) = plan.output().parent() {
fs::create_dir_all(parent).map_err(|error| {
Diagnostic::builtin(
BuiltinDiagnostic::OutputIo,
format!(
"could not create output directory `{}`: {error}",
parent.display()
),
SourceSpan::file_start(plan.output()),
)
})?;
}
let publication_lock_path = sibling_lock_path(plan.output(), "publication");
let _publication_lock = FileLock::acquire(
&publication_lock_path,
BuiltinDiagnostic::PublicationLock,
"publication",
&SourceSpan::file_start(plan.output()),
)?;
let publication = PublicationTransaction::new(plan.output(), plan.manifest())?;
let executor = execute::Executor::new(plan);
executor.stage_export(result_artifact, publication.staged_output(), result_node)?;
let manifest_json = manifest::serialize(
plan,
result_node,
execution.cache_hits(),
execution.cache_misses(),
)?;
publication.stage_manifest(&manifest_json)?;
publication.commit()?;
Ok(RenderReport {
output: plan.output().to_path_buf(),
manifest: plan.manifest().to_path_buf(),
cache_hits: execution.cache_hits(),
cache_misses: execution.cache_misses(),
})
}