1use std::path::PathBuf;
2use std::time::{Duration, Instant};
3
4use anyhow::{Context, Result};
5
6use crate::build::output::OutputPublication;
7use crate::build::transform::DocumentTransform;
8use crate::foundation::ProjectLayout;
9use crate::foundation::config::AsterConfig;
10
11mod route_plan;
12
13use self::route_plan::{plan_generators, plan_pages};
14use super::{BuildSession, BuildWarning, postprocess, world};
15
16pub struct BuildOutcome {
19 pub output_dir: PathBuf,
21 pub pages: Vec<PathBuf>,
23 pub generated: Vec<PathBuf>,
25 pub warnings: Vec<BuildWarning>,
27 pub elapsed: Duration,
29}
30
31impl BuildSession {
32 pub fn build(&mut self) -> Result<BuildOutcome> {
34 let started = Instant::now();
35 self.reset();
36 let outcome = (|| {
37 let stage = tracing::info_span!("configure", message = "configured project").entered();
38 let config_file = self.project().config_file();
39 let config_path = self.project().config_path();
40 let content = self
41 .project_files()
42 .read(&config_path)
43 .context("failed to read aster.toml")?;
44 let config = AsterConfig::parse(content.as_slice(), &config_file)
45 .context("failed to parse aster.toml")?;
46 let layout = ProjectLayout::new(&config).context("invalid project layout")?;
47 let output_dir = self.project().realize(layout.output());
48 tracing::debug!(
49 project = %self.project().root().display(),
50 output = %output_dir.display(),
51 "configured project"
52 );
53 for path in layout.watch_paths() {
54 self.files
55 .watch(path)
56 .context("failed to inspect configured watch paths")?;
57 }
58 drop(stage);
59
60 let stage = tracing::info_span!("fonts", message = "loaded fonts").entered();
61 world::configure_fonts(self, &config.typst.fonts, &layout)?;
62 drop(stage);
63
64 let session = &*self;
65 let stage = tracing::info_span!("prepare", message = "prepared build").entered();
66 let project = session.project().clone();
67 let mut warnings = Vec::new();
68 let mut publication = OutputPublication::new(&project, &layout)?;
69 publication
70 .add_public_tree(session.project_files(), layout.public())
71 .context("failed to collect public files")?;
72
73 let mut transform = DocumentTransform::new(
74 session.project_files(),
75 project.root(),
76 &config.assets,
77 &config.css,
78 &config.highlight,
79 &mut warnings,
80 )?;
81
82 let runtime =
83 super::content::load(session.project_files(), layout.content(), session.dev)
84 .context("failed to load content collections")?;
85 drop(stage);
86
87 let stage = tracing::info_span!("plan", message = "planned routes").entered();
88 let pages = plan_pages(session, &layout, &runtime, &mut warnings)?;
89 let page_paths = pages
90 .iter()
91 .map(|job| job.output.page_url_path())
92 .collect::<Vec<_>>();
93 tracing::debug!(
94 pages = pages.len(),
95 "planned {} page{}",
96 pages.len(),
97 if pages.len() == 1 { "" } else { "s" }
98 );
99 let runtime = runtime.with_page_routes(page_paths);
100 drop(stage);
101
102 let stage = tracing::info_span!("render", message = "rendered pages").entered();
103 let mut site_pages = Vec::with_capacity(pages.len());
104 for job in &pages {
105 let path = job.output.page_url_path();
106 let route = tracing::info_span!("page", route = %path, message = "rendered page");
107 let _route = route.enter();
108 let context = runtime.for_route(path, &job.params);
109 let stage = tracing::debug_span!(
110 "compile",
111 source = %job.template.get_with_slash(),
112 message = "compiled"
113 )
114 .entered();
115 let document =
116 world::compile_document(session, &job.template, &context, &mut warnings)?;
117 drop(stage);
118 let page = transform
119 .render(
120 document,
121 publication.page(&job.template, &job.output),
122 config.output.pretty,
123 )
124 .with_context(|| format!("failed to build {}", job.output))?;
125 site_pages.push(page);
126 }
127 drop(stage);
128
129 let stage = tracing::info_span!("generate", message = "ran generators").entered();
130 let runtime = runtime.with_site(&site_pages);
131 let generators = plan_generators(session, &layout, &runtime, &pages, &mut warnings)?;
132 tracing::debug!(
133 generators = generators.len(),
134 "planned {} generator{}",
135 generators.len(),
136 if generators.len() == 1 { "" } else { "s" }
137 );
138 for job in &generators {
139 let path = job.output.url_path();
140 let route = tracing::info_span!(
141 "generator",
142 route = %path,
143 message = "ran generator"
144 );
145 let _route = route.enter();
146 let context = runtime.for_route(path, &job.params);
147 let stage = tracing::debug_span!(
148 "compile",
149 source = %job.template.get_with_slash(),
150 message = "compiled"
151 )
152 .entered();
153 let content =
154 world::evaluate_generator(session, &job.template, &context, &mut warnings)
155 .context("invalid generator output")?;
156 drop(stage);
157 publication
158 .add_generator_output(job.output.clone(), content)
159 .with_context(|| format!("failed to generate {}", job.output))?;
160 }
161 drop(stage);
162
163 let stage = tracing::info_span!("publish", message = "published output").entered();
164 let mut staged = publication.stage()?;
165 postprocess::run(&config.postprocess, project.root(), &mut staged)?;
166 let published = staged.publish()?;
167 drop(stage);
168 Ok(BuildOutcome {
169 output_dir: published.output_dir,
170 pages: published.pages,
171 generated: published.generated,
172 warnings,
173 elapsed: started.elapsed(),
174 })
175 })();
176 comemo::evict(10);
177 outcome
178 }
179}