aster-ssg 0.3.0

A typst-native static site generator, inspired by Astro.
Documentation
use std::fmt;
use std::io::IsTerminal;

use anstyle::{AnsiColor, Style};
use aster::BuildOutcome;
use tracing::field::{Field, Visit};
use tracing::{Event, Level, Subscriber};
use tracing_subscriber::field::RecordFields;
use tracing_subscriber::filter::{LevelFilter, Targets};
use tracing_subscriber::fmt::format::{FmtSpan, FormatEvent, FormatFields, Writer};
use tracing_subscriber::fmt::{FmtContext, FormattedFields};
use tracing_subscriber::layer::{Layer, SubscriberExt};
use tracing_subscriber::registry::LookupSpan;

pub fn init(verbosity: u8) {
    let level = match verbosity {
        0 => LevelFilter::INFO,
        1 => LevelFilter::DEBUG,
        _ => LevelFilter::TRACE,
    };
    let targets = Targets::new().with_target(env!("CARGO_CRATE_NAME"), level);
    let ansi = std::io::stderr().is_terminal()
        && std::env::var_os("NO_COLOR").is_none_or(|value| value.is_empty());
    let layer = tracing_subscriber::fmt::layer()
        .fmt_fields(SentenceFields { ansi })
        .with_span_events(FmtSpan::CLOSE)
        .event_format(IndentedFormat { ansi })
        .with_writer(std::io::stderr)
        .with_filter(targets);
    let _ = tracing::subscriber::set_global_default(tracing_subscriber::registry().with(layer));
}

pub fn report_build(outcome: &BuildOutcome) {
    for warning in &outcome.warnings {
        tracing::warn!(warning = %warning, "{warning}");
    }
    let pages = outcome.pages.len();
    let generated = outcome.generated.len();
    let routes = if generated == 0 {
        format!("{pages} page{}", if pages == 1 { "" } else { "s" })
    } else {
        format!(
            "{pages} page{} and {generated} generated file{}",
            if pages == 1 { "" } else { "s" },
            if generated == 1 { "" } else { "s" }
        )
    };
    tracing::info!(
        pages,
        generated,
        elapsed = ?outcome.elapsed,
        "built {routes} in {:.1}s",
        outcome.elapsed.as_secs_f64()
    );
}

struct SentenceFields {
    ansi: bool,
}

impl<'writer> FormatFields<'writer> for SentenceFields {
    fn format_fields<R: RecordFields>(&self, writer: Writer<'writer>, fields: R) -> fmt::Result {
        let mut visitor = SentenceVisitor {
            writer,
            ansi: self.ansi,
            message: None,
            parts: Vec::new(),
        };
        fields.record(&mut visitor);
        visitor.finish()
    }
}

struct SentenceVisitor<'writer> {
    writer: Writer<'writer>,
    ansi: bool,
    message: Option<String>,
    parts: Vec<(&'static str, String)>,
}

impl SentenceVisitor<'_> {
    fn finish(mut self) -> fmt::Result {
        if let Some(message) = self.message {
            write!(self.writer, "{message}")?;
        }
        for (name, value) in self.parts {
            match name {
                "route" | "source" | "template" | "project" | "address" => {
                    write!(self.writer, " ")?;
                    write_accent(&mut self.writer, &value, self.ansi)?;
                }
                "output" => {
                    write!(self.writer, " with output ")?;
                    write_accent(&mut self.writer, &value, self.ansi)?;
                }
                "destination" => {
                    write!(self.writer, " to ")?;
                    write_accent(&mut self.writer, &value, self.ansi)?;
                }
                "language" => {
                    write!(self.writer, " ")?;
                    write_emphasis(&mut self.writer, &value, self.ansi)?;
                }
                "tool" => {
                    write!(self.writer, " with ")?;
                    write_emphasis(&mut self.writer, &value, self.ansi)?;
                }
                "time.busy" => {
                    write!(self.writer, " in ")?;
                    write_emphasis(&mut self.writer, &value, self.ansi)?;
                }
                _ => {}
            }
        }
        Ok(())
    }
}

impl Visit for SentenceVisitor<'_> {
    fn record_str(&mut self, field: &Field, value: &str) {
        match field.name() {
            "message" if value != "close" => self.message = Some(value.into()),
            "message" => {}
            name => self.parts.push((name, value.into())),
        }
    }

    fn record_debug(&mut self, field: &Field, value: &dyn fmt::Debug) {
        let value = format!("{value:?}");
        if field.name() == "message" {
            self.message = Some(value);
        } else {
            self.parts.push((field.name(), value));
        }
    }
}

fn write_accent(writer: &mut Writer<'_>, value: &str, ansi: bool) -> fmt::Result {
    if ansi {
        let style = Style::new().fg_color(Some(AnsiColor::Green.into()));
        write!(writer, "{style}{value}{style:#}")
    } else {
        write!(writer, "{value}")
    }
}

fn write_emphasis(writer: &mut Writer<'_>, value: &str, ansi: bool) -> fmt::Result {
    if ansi {
        let style = Style::new().bold();
        write!(writer, "{style}{value}{style:#}")
    } else {
        write!(writer, "{value}")
    }
}

struct IndentedFormat {
    ansi: bool,
}

impl<S, N> FormatEvent<S, N> for IndentedFormat
where
    S: Subscriber + for<'lookup> LookupSpan<'lookup>,
    N: for<'writer> FormatFields<'writer> + 'static,
{
    fn format_event(
        &self,
        context: &FmtContext<'_, S, N>,
        mut writer: Writer<'_>,
        event: &Event<'_>,
    ) -> fmt::Result {
        write_level(&mut writer, event.metadata().level(), self.ansi)?;

        let lifecycle = event.metadata().is_span();
        let scope_depth = context
            .event_scope()
            .map(|scope| scope.count())
            .unwrap_or_default();
        let depth = scope_depth.saturating_sub(usize::from(lifecycle));
        write!(writer, "{:width$}", "", width = depth * 2)?;

        if lifecycle {
            let span = context
                .event_scope()
                .and_then(|mut scope| scope.next())
                .expect("span lifecycle event has its originating span");
            let extensions = span.extensions();
            match extensions.get::<FormattedFields<N>>() {
                Some(fields) if !fields.is_empty() => write!(writer, "{fields}")?,
                _ => write!(writer, "{}", span.name())?,
            }
        }

        context
            .field_format()
            .format_fields(writer.by_ref(), event)?;
        writeln!(writer)
    }
}

fn write_level(writer: &mut Writer<'_>, level: &Level, ansi: bool) -> fmt::Result {
    let (label, color) = match *level {
        Level::TRACE => ("TRACE", AnsiColor::Magenta),
        Level::DEBUG => ("DEBUG", AnsiColor::Blue),
        Level::INFO => ("INFO ", AnsiColor::Green),
        Level::WARN => ("WARN ", AnsiColor::Yellow),
        Level::ERROR => ("ERROR", AnsiColor::Red),
    };
    if ansi {
        let style = Style::new().fg_color(Some(color.into())).bold();
        write!(writer, "{style}{label}{style:#} ")
    } else {
        write!(writer, "{label} ")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn semantic_styles_are_scoped_to_their_values() {
        let mut output = String::new();
        let mut writer = Writer::new(&mut output);

        write_accent(&mut writer, "/pages/index.typ", true).unwrap();
        write!(writer, " ").unwrap();
        write_emphasis(&mut writer, "12ms", true).unwrap();

        assert_eq!(output, "\x1b[32m/pages/index.typ\x1b[0m \x1b[1m12ms\x1b[0m");
    }

    #[test]
    fn semantic_styles_fall_back_to_plain_text() {
        let mut output = String::new();
        let mut writer = Writer::new(&mut output);

        write_accent(&mut writer, "/pages/index.typ", false).unwrap();
        write!(writer, " ").unwrap();
        write_emphasis(&mut writer, "12ms", false).unwrap();

        assert_eq!(output, "/pages/index.typ 12ms");
    }
}