use std::path::PathBuf;
use std::time::{Duration, Instant};
use anyhow::{Context, Result};
use crate::build::output::OutputPublication;
use crate::build::transform::DocumentTransform;
use crate::foundation::ProjectLayout;
use crate::foundation::config::AsterConfig;
mod route_plan;
use self::route_plan::{plan_generators, plan_pages};
use super::{BuildSession, BuildWarning, postprocess, world};
pub struct BuildOutcome {
pub output_dir: PathBuf,
pub pages: Vec<PathBuf>,
pub generated: Vec<PathBuf>,
pub warnings: Vec<BuildWarning>,
pub elapsed: Duration,
}
impl BuildSession {
pub fn build(&mut self) -> Result<BuildOutcome> {
let started = Instant::now();
self.reset();
let outcome = (|| {
let stage = tracing::info_span!("configure", message = "configured project").entered();
let config_file = self.project().config_file();
let config_path = self.project().config_path();
let content = self
.project_files()
.read(&config_path)
.context("failed to read aster.toml")?;
let config = AsterConfig::parse(content.as_slice(), &config_file)
.context("failed to parse aster.toml")?;
let layout = ProjectLayout::new(&config).context("invalid project layout")?;
let output_dir = self.project().realize(layout.output());
tracing::debug!(
project = %self.project().root().display(),
output = %output_dir.display(),
"configured project"
);
for path in layout.watch_paths() {
self.files
.watch(path)
.context("failed to inspect configured watch paths")?;
}
drop(stage);
let stage = tracing::info_span!("fonts", message = "loaded fonts").entered();
world::configure_fonts(self, &config.typst.fonts, &layout)?;
drop(stage);
let session = &*self;
let stage = tracing::info_span!("prepare", message = "prepared build").entered();
let project = session.project().clone();
let mut warnings = Vec::new();
let mut publication = OutputPublication::new(&project, &layout)?;
publication
.add_public_tree(session.project_files(), layout.public())
.context("failed to collect public files")?;
let mut transform = DocumentTransform::new(
session.project_files(),
project.root(),
&config.assets,
&config.css,
&config.highlight,
&mut warnings,
)?;
let runtime =
super::content::load(session.project_files(), layout.content(), session.dev)
.context("failed to load content collections")?;
drop(stage);
let stage = tracing::info_span!("plan", message = "planned routes").entered();
let pages = plan_pages(session, &layout, &runtime, &mut warnings)?;
let page_paths = pages
.iter()
.map(|job| job.output.page_url_path())
.collect::<Vec<_>>();
tracing::debug!(
pages = pages.len(),
"planned {} page{}",
pages.len(),
if pages.len() == 1 { "" } else { "s" }
);
let runtime = runtime.with_page_routes(page_paths);
drop(stage);
let stage = tracing::info_span!("render", message = "rendered pages").entered();
let mut site_pages = Vec::with_capacity(pages.len());
for job in &pages {
let path = job.output.page_url_path();
let route = tracing::info_span!("page", route = %path, message = "rendered page");
let _route = route.enter();
let context = runtime.for_route(path, &job.params);
let stage = tracing::debug_span!(
"compile",
source = %job.template.get_with_slash(),
message = "compiled"
)
.entered();
let document =
world::compile_document(session, &job.template, &context, &mut warnings)?;
drop(stage);
let page = transform
.render(
document,
publication.page(&job.template, &job.output),
config.output.pretty,
)
.with_context(|| format!("failed to build {}", job.output))?;
site_pages.push(page);
}
drop(stage);
let stage = tracing::info_span!("generate", message = "ran generators").entered();
let runtime = runtime.with_site(&site_pages);
let generators = plan_generators(session, &layout, &runtime, &pages, &mut warnings)?;
tracing::debug!(
generators = generators.len(),
"planned {} generator{}",
generators.len(),
if generators.len() == 1 { "" } else { "s" }
);
for job in &generators {
let path = job.output.url_path();
let route = tracing::info_span!(
"generator",
route = %path,
message = "ran generator"
);
let _route = route.enter();
let context = runtime.for_route(path, &job.params);
let stage = tracing::debug_span!(
"compile",
source = %job.template.get_with_slash(),
message = "compiled"
)
.entered();
let content =
world::evaluate_generator(session, &job.template, &context, &mut warnings)
.context("invalid generator output")?;
drop(stage);
publication
.add_generator_output(job.output.clone(), content)
.with_context(|| format!("failed to generate {}", job.output))?;
}
drop(stage);
let stage = tracing::info_span!("publish", message = "published output").entered();
let mut staged = publication.stage()?;
postprocess::run(&config.postprocess, project.root(), &mut staged)?;
let published = staged.publish()?;
drop(stage);
Ok(BuildOutcome {
output_dir: published.output_dir,
pages: published.pages,
generated: published.generated,
warnings,
elapsed: started.elapsed(),
})
})();
comemo::evict(10);
outcome
}
}