Skip to main content

aster/build/
pipeline.rs

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
16/// The complete build outcome. No build stage decides terminal formatting or
17/// exit status; the CLI renders this value after the pipeline finishes.
18pub struct BuildOutcome {
19    /// Root directory containing the complete published site.
20    pub output_dir: PathBuf,
21    /// Published page paths, in deterministic route order.
22    pub pages: Vec<PathBuf>,
23    /// Published generator output paths, in deterministic route order.
24    pub generated: Vec<PathBuf>,
25    /// Non-fatal diagnostics collected during the build.
26    pub warnings: Vec<BuildWarning>,
27    /// Total build and publication time.
28    pub elapsed: Duration,
29}
30
31impl BuildSession {
32    /// Build and publish the complete project output tree.
33    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}