custom front matter parser for showing errors + make all extras configurable from the page side

src/builder.rs

@@ -3,7 +3,6 @@
 use std::{collections::HashMap, path::PathBuf};
 
 use eyre::{eyre, Context, OptionExt};
-use gray_matter::{engine::YAML, Matter};
 use handlebars::Handlebars;
 use lol_html::{element, html_content::ContentType, HtmlRewriter, Settings};
 use pulldown_cmark::{Options, Parser};
@@ -32,8 +31,6 @@ struct TemplateData<'a, T> {
 
 /// Struct used to build the site.
 pub struct SiteBuilder<'a> {
-	/// The matter instance used to extract front matter.
-	pub(crate) matter: Matter<YAML>,
 	/// The Handlebars registry used to render templates.
 	pub(crate) reg: Handlebars<'a>,
 	/// The site info used to build the site.
@@ -59,7 +56,6 @@ impl<'a> SiteBuilder<'a> {
 		}
 
 		Self {
-			matter: Matter::new(),
 			reg: Handlebars::new(),
 			resource_builders: HashMap::new(),
 			site,
@@ -257,16 +253,14 @@ impl<'a> SiteBuilder<'a> {
 	/// Helper to build a page without writing it to disk.
 	pub fn build_page_raw_with_extra_data<T>(
 		&self,
-		page_metadata: PageMetadata,
+		mut page_metadata: PageMetadata,
 		page_html: &str,
 		extra_data: T,
 	) -> eyre::Result<String>
 	where
 		T: Serialize,
 	{
-		let extra = page_metadata
-			.extra
-			.and_then(|extra| crate::extras::get_extra(&extra));
+		let extra = page_metadata.extra.take();
 
 		let title = match &page_metadata.title {
 			Some(page_title) => format!("{} / {}", self.site.config.title, page_title),
@@ -293,8 +287,10 @@ impl<'a> SiteBuilder<'a> {
 		// Modify HTML output
 		let mut out = self.rewrite_html(out)?;
 
-		if let Some(extra) = extra {
-			out = extra.handle(out, self)?;
+		if let Some(data) = extra {
+			if let Some(extra) = crate::extras::get_extra(&data.name) {
+				out = extra.handle(out, self, &data)?;
+			}
 		}
 
 		if !self.serving {
@@ -310,19 +306,13 @@ impl<'a> SiteBuilder<'a> {
 
 		let input = std::fs::read_to_string(page_path)
 			.with_context(|| format!("Failed to read page at {}", page_path.display()))?;
-		let page = self.matter.parse(&input);
-
-		let page_metadata = if let Some(data) = page.data {
-			data.deserialize()?
-		} else {
-			PageMetadata::default()
-		};
+		let page = crate::frontmatter::FrontMatter::parse(input)?;
 
 		let parser = Parser::new_ext(&page.content, Options::all());
 		let mut page_html = String::new();
 		pulldown_cmark::html::push_html(&mut page_html, parser);
 
-		let out = self.build_page_raw(page_metadata, &page_html)?;
+		let out = self.build_page_raw(page.data.unwrap_or_default(), &page_html)?;
 
 		let out_path = self.build_path.join(page_name).with_extension("html");
 		std::fs::create_dir_all(out_path.parent().unwrap())

src/extras.rs

@@ -1,32 +1,58 @@
 use lol_html::{element, RewriteStrSettings};
-use serde::Serialize;
+use serde::{Deserialize, Serialize};
 
 use crate::{builder::SiteBuilder, resource::ResourceTemplateData};
 
+/// Types of extras.
 #[derive(Debug)]
 pub enum Extra {
-	Basic(&'static str),
-	HtmlModification(fn(page: String, builder: &SiteBuilder) -> eyre::Result<String>),
+	/// Simply appends to the page within content.
+	Basic,
+	/// May modify the HTML output in any way.
+	HtmlModification(
+		fn(page: String, builder: &SiteBuilder, data: &ExtraData) -> eyre::Result<String>,
+	),
 }
 
 impl Extra {
 	/// runs the handler for the extra
-	pub fn handle(&self, page: String, builder: &SiteBuilder) -> eyre::Result<String> {
+	pub fn handle(
+		&self,
+		page: String,
+		builder: &SiteBuilder,
+		data: &ExtraData,
+	) -> eyre::Result<String> {
+		#[derive(Debug, Deserialize)]
+		struct BasicData {
+			template: String,
+		}
+
 		match self {
-			Self::Basic(template) => {
-				let content = builder.reg.render(template, &())?;
+			Self::Basic => {
+				let data: BasicData = serde_yml::from_value(data.inner.clone())?;
+				let content = builder.reg.render(&data.template, &())?;
 				append_to(&page, &content, "main.page")
 			}
-			Self::HtmlModification(f) => (f)(page, builder),
+			Self::HtmlModification(f) => (f)(page, builder, data),
 		}
 	}
 }
 
+/// Data for extras.
+#[derive(Debug, Deserialize)]
+pub struct ExtraData {
+	/// The name of the extra to run.
+	pub name: String,
+	/// The inner data for the extra.
+	#[serde(flatten)]
+	pub inner: serde_yml::Value,
+}
+
 /// Gets the extra for the given value.
 pub fn get_extra(extra: &str) -> Option<Extra> {
 	match extra {
-		"index" => Some(Extra::HtmlModification(index)),
-		"click" => Some(Extra::Basic("extras/click")),
+		"basic" => Some(Extra::Basic),
+		"resource-list-outside" => Some(Extra::HtmlModification(resource_list_outside)),
 		_ => None,
 	}
 }
@@ -46,22 +72,35 @@ fn append_to(page: &str, content: &str, selector: &str) -> eyre::Result<String>
 }
 
 /// Extra to add a sidebar to the index page with recent blog posts on it.
-fn index(page: String, builder: &SiteBuilder) -> eyre::Result<String> {
+fn resource_list_outside(
+	page: String,
+	builder: &SiteBuilder,
+	data: &ExtraData,
+) -> eyre::Result<String> {
+	#[derive(Debug, Deserialize)]
+	struct ResourceListData {
+		template: String,
+		resource: String,
+		count: usize,
+	}
+
 	#[derive(Debug, Serialize)]
-	struct SidebarTemplateData<'r> {
+	struct ResourceListTemplateData<'r> {
 		resources: Vec<ResourceTemplateData<'r>>,
 	}
 
-	let sidebar = builder.reg.render(
-		"extras/index-injection",
-		&SidebarTemplateData {
+	let data: ResourceListData = serde_yml::from_value(data.inner.clone())?;
+
+	let resource_list = builder.reg.render(
+		&data.template,
+		&ResourceListTemplateData {
 			resources: builder
 				.resource_builders
-				.get("blog")
-				.expect("missing blog builder")
+				.get(&data.resource)
+				.ok_or_else(|| eyre::eyre!("missing resource builder: {}", data.resource))?
 				.loaded_metadata
 				.iter()
-				.take(3)
+				.take(data.count)
 				.map(|(id, v)| ResourceTemplateData {
 					resource: v,
 					id: id.clone(),
@@ -71,5 +110,5 @@ fn index(page: String, builder: &SiteBuilder) -> eyre::Result<String> {
 		},
 	)?;
 
-	append_to(&page, &sidebar, "#content")
+	append_to(&page, &resource_list, "#content")
 }

src/frontmatter.rs

@@ -0,0 +1,32 @@
+use serde::de::DeserializeOwned;
+
+/// Very basic YAML front matter parser.
+#[derive(Debug)]
+pub struct FrontMatter<T> {
+	/// The content past the front matter.
+	pub content: String,
+	/// The front matter found, if any.
+	pub data: Option<T>,
+}
+
+impl<T> FrontMatter<T>
+where
+	T: DeserializeOwned,
+{
+	/// Parses the given input for front matter.
+	pub fn parse(input: String) -> eyre::Result<Self> {
+		if input.starts_with("---\n") {
+			if let Some((frontmatter, content)) = input[3..].split_once("---\n") {
+				let data = serde_yml::from_str(frontmatter)?;
+				return Ok(Self {
+					content: content.to_string(),
+					data,
+				});
+			}
+		}
+		Ok(Self {
+			content: input,
+			data: None,
+		})
+	}
+}

src/lib.rs

@@ -1,5 +1,6 @@
 mod builder;
 mod extras;
+mod frontmatter;
 mod link_list;
 mod resource;
 #[cfg(feature = "serve")]
@@ -11,6 +12,7 @@ use std::{
 	path::{Path, PathBuf},
 };
 
+use extras::ExtraData;
 use eyre::Context;
 use rayon::prelude::*;
 use resource::{EmbedMetadata, ResourceBuilderConfig};
@@ -73,7 +75,8 @@ pub struct PageMetadata {
 	#[serde(default)]
 	pub styles: Vec<String>,
 	/// The extra stuff to run for the page, if any.
-	pub extra: Option<String>,
+	#[serde(default)]
+	pub extra: Option<ExtraData>,
 }
 
 /// Struct containing information about the site.

src/resource.rs

@@ -10,7 +10,7 @@ use rss::{validation::Validate, ChannelBuilder, ItemBuilder};
 use serde::{Deserialize, Serialize, Serializer};
 use time::{format_description::well_known::Rfc2822, OffsetDateTime};
 
-use crate::{builder::SiteBuilder, link_list::Link, PageMetadata};
+use crate::{builder::SiteBuilder, frontmatter::FrontMatter, link_list::Link, PageMetadata};
 
 /// Source base path for resources.
 pub const RESOURCES_PATH: &str = "resources";
@@ -194,21 +194,22 @@ impl ResourceBuilder {
 		let id = Self::get_id(path);
 
 		let input = std::fs::read_to_string(path)?;
-		let mut page = builder
-			.matter
-			.parse_with_struct::<ResourceMetadata>(&input)
-			.ok_or_else(|| eyre::anyhow!("Failed to parse resource front matter"))?;
+		let page = FrontMatter::<ResourceMetadata>::parse(input)
+			.wrap_err_with(|| eyre::eyre!("Failed to parse resource front matter"))?;
 
 		let parser = Parser::new_ext(&page.content, Options::all());
 		let mut html = String::new();
 		pulldown_cmark::html::push_html(&mut html, parser);
 
-		page.data.content = html;
-		if let Some(cdn_file) = page.data.cdn_file {
-			page.data.cdn_file = Some(builder.site.config.cdn_url(&cdn_file)?.to_string());
+		let mut data = page
+			.data
+			.ok_or_else(|| eyre::eyre!("missing front matter for file at {path:?}"))?;
+		data.content = html;
+		if let Some(cdn_file) = data.cdn_file {
+			data.cdn_file = Some(builder.site.config.cdn_url(&cdn_file)?.to_string());
 		}
 
-		Ok((id, page.data))
+		Ok((id, data))
 	}
 
 	/// Loads all resource metadata from the given config.