fix: address bugs, improve architecture, and add features

Fix preprocess_math dead branch eating backticks before ~~, remove TOML
frontmatter retry loop that masked parse errors, fix CLI version mismatch,
remove global MARKDOWN_RENDERER that ignored configured syntax themes.

Replace all eprintln warnings with proper error propagation. Make
MarkdownRenderer::with_theme return Result, image processing and JS
minification failures are now real errors.

Parallelize content loading with rayon, skip raw_content in template
serialization, gate static/asset copying and asset processing on full
builds, make Sass compilation atomic (compile all then write all).

Add nested collection support, custom permalink frontmatter field,
theme partial sharing with shortcode templates, and builtin default
partials for shortcode Tera.

Author: matthewjberger

apps/cli/Cargo.toml

@@ -16,7 +16,7 @@ name = "bamboo"
 path = "src/main.rs"
 
 [dependencies]
-bamboo-ssg = { version = "0.1.1", path = "../../crates/bamboo" }
+bamboo-ssg = { version = "0.1.2", path = "../../crates/bamboo" }
 clap = { version = "4", features = ["derive"] }
 notify = "8"
 open = "5"

apps/cli/src/commands.rs

@@ -177,6 +177,10 @@ pub fn build_site(
     if !shortcode_dirs.is_empty() {
         builder = builder.shortcode_dirs(&shortcode_dirs)?;
     }
+    let theme_templates = theme_path.join("templates");
+    if theme_templates.is_dir() {
+        builder = builder.theme_templates_dir(&theme_templates);
+    }
 
     let site = builder.build()?;
 
@@ -255,6 +259,10 @@ fn build_site_incremental(
     if !shortcode_dirs.is_empty() {
         builder = builder.shortcode_dirs(&shortcode_dirs)?;
     }
+    let theme_templates = theme_path.join("templates");
+    if theme_templates.is_dir() {
+        builder = builder.theme_templates_dir(&theme_templates);
+    }
 
     let site = builder.build()?;
 

crates/bamboo/src/assets.rs

@@ -193,23 +193,14 @@ fn minify_js_files(output_dir: &Path) -> Result<()> {
         let session = minify_js::Session::new();
         let source = fs::read(file_path)?;
         let mut output = Vec::new();
-        match minify_js::minify(
+        minify_js::minify(
             &session,
             minify_js::TopLevelMode::Global,
             &source,
             &mut output,
-        ) {
-            Ok(()) => {
-                fs::write(file_path, output)?;
-            }
-            Err(error) => {
-                eprintln!(
-                    "Warning: failed to minify {}: {}",
-                    file_path.display(),
-                    error
-                );
-            }
-        }
+        )
+        .map_err(|error| std::io::Error::other(format!("{}: {}", file_path.display(), error)))?;
+        fs::write(file_path, output)?;
         Ok(())
     })
 }
@@ -225,6 +216,8 @@ fn compile_sass_files(output_dir: &Path, load_paths: &[std::path::PathBuf]) -> R
         return Ok(());
     }
 
+    let mut compiled_results: Vec<(std::path::PathBuf, std::path::PathBuf, String)> = Vec::new();
+
     for file_path in &all_sass_files {
         let filename = file_path
             .file_name()
@@ -258,11 +251,25 @@ fn compile_sass_files(output_dir: &Path, load_paths: &[std::path::PathBuf]) -> R
         })?;
 
         let css_path = file_path.with_extension("css");
-        fs::write(&css_path, compiled)?;
+        compiled_results.push((file_path.clone(), css_path, compiled));
+    }
+
+    for (_sass_path, css_path, compiled_css) in &compiled_results {
+        fs::write(css_path, compiled_css)?;
+    }
+
+    for (sass_path, _css_path, _compiled_css) in &compiled_results {
+        if sass_path.exists() {
+            fs::remove_file(sass_path)?;
+        }
     }
 
     for file_path in &all_sass_files {
-        if file_path.exists() {
+        let filename = file_path
+            .file_name()
+            .and_then(|name| name.to_str())
+            .unwrap_or("");
+        if filename.starts_with('_') && file_path.exists() {
             fs::remove_file(file_path)?;
         }
     }

crates/bamboo/src/images.rs

@@ -92,30 +92,21 @@ pub fn process_images(output_dir: &Path, config: &ImageConfig) -> Result<ImageMa
         .map(|entry| entry.path().to_path_buf())
         .collect();
 
-    let results: Vec<Option<(String, Vec<ImageVariant>)>> = image_paths
+    type ImageResult = Result<Option<(String, Vec<ImageVariant>)>>;
+    let results: Vec<ImageResult> = image_paths
         .par_iter()
-        .map(|path| -> Option<(String, Vec<ImageVariant>)> {
-            let source_image = match ImageReader::open(path) {
-                Ok(reader) => match reader.decode() {
-                    Ok(image) => image,
-                    Err(error) => {
-                        eprintln!(
-                            "Warning: failed to decode image {}: {}",
-                            path.display(),
-                            error
-                        );
-                        return None;
-                    }
-                },
-                Err(error) => {
-                    eprintln!(
-                        "Warning: failed to open image {}: {}",
-                        path.display(),
-                        error
-                    );
-                    return None;
+        .map(|path| -> Result<Option<(String, Vec<ImageVariant>)>> {
+            let reader = ImageReader::open(path).map_err(|error| {
+                crate::error::BambooError::ImageProcessing {
+                    message: format!("failed to open {}: {}", path.display(), error),
                 }
-            };
+            })?;
+            let source_image =
+                reader
+                    .decode()
+                    .map_err(|error| crate::error::BambooError::ImageProcessing {
+                        message: format!("failed to decode {}: {}", path.display(), error),
+                    })?;
 
             let original_width = source_image.width();
             let original_height = source_image.height();
@@ -179,14 +170,13 @@ pub fn process_images(output_dir: &Path, config: &ImageConfig) -> Result<ImageMa
                         }
                     };
 
-                    if let Err(error) = write_result {
-                        eprintln!(
-                            "Warning: failed to write image variant {}: {}",
+                    write_result.map_err(|error| crate::error::BambooError::ImageProcessing {
+                        message: format!(
+                            "failed to write variant {}: {}",
                             variant_path.display(),
                             error
-                        );
-                        continue;
-                    }
+                        ),
+                    })?;
 
                     let relative_variant = variant_path
                         .strip_prefix(output_dir)
@@ -203,16 +193,18 @@ pub fn process_images(output_dir: &Path, config: &ImageConfig) -> Result<ImageMa
             }
 
             if !image_variants.is_empty() {
-                Some((relative_original, image_variants))
+                Ok(Some((relative_original, image_variants)))
             } else {
-                None
+                Ok(None)
             }
         })
         .collect();
 
     let mut variants: HashMap<String, Vec<ImageVariant>> = HashMap::new();
-    for result in results.into_iter().flatten() {
-        variants.insert(result.0, result.1);
+    for result in results {
+        if let Some((key, value)) = result? {
+            variants.insert(key, value);
+        }
     }
 
     Ok(ImageManifest { variants })

crates/bamboo/src/lib.rs

@@ -20,7 +20,7 @@ pub use cache::{
 pub use error::{BambooError, IoContext, Result};
 pub use parsing::{
     MarkdownRenderer, RenderedMarkdown, extract_excerpt, extract_frontmatter,
-    parse_date_from_filename, parse_markdown, reading_time, slugify, word_count,
+    parse_date_from_filename, reading_time, slugify, word_count,
 };
 pub use site::SiteBuilder;
 pub use theme::{ThemeEngine, clean_output_dir};

crates/bamboo/src/parsing.rs

@@ -5,13 +5,10 @@ use pulldown_cmark::{CodeBlockKind, Event, HeadingLevel, Options, Parser, Tag, T
 use serde_json::Value;
 use std::collections::{HashMap, HashSet};
 use std::path::Path;
-use std::sync::LazyLock;
 use syntect::highlighting::ThemeSet;
 use syntect::html::highlighted_html_for_string;
 use syntect::parsing::SyntaxSet;
 
-static MARKDOWN_RENDERER: LazyLock<MarkdownRenderer> = LazyLock::new(MarkdownRenderer::new);
-
 pub struct MarkdownRenderer {
     syntax_set: SyntaxSet,
     theme_set: ThemeSet,
@@ -38,22 +35,18 @@ impl MarkdownRenderer {
         }
     }
 
-    pub fn with_theme(theme_name: &str) -> Self {
+    pub fn with_theme(theme_name: &str) -> Result<Self> {
         let theme_set = ThemeSet::load_defaults();
-        let validated_theme_name = if theme_set.themes.contains_key(theme_name) {
-            theme_name.to_string()
-        } else {
-            eprintln!(
-                "Warning: syntax theme '{}' not found, falling back to 'base16-ocean.dark'",
-                theme_name
-            );
-            "base16-ocean.dark".to_string()
-        };
-        Self {
+        if !theme_set.themes.contains_key(theme_name) {
+            return Err(BambooError::ThemeNotFound {
+                name: format!("syntax theme '{}' not found", theme_name),
+            });
+        }
+        Ok(Self {
             syntax_set: SyntaxSet::load_defaults_newlines(),
             theme_set,
-            theme_name: validated_theme_name,
-        }
+            theme_name: theme_name.to_string(),
+        })
     }
 
     pub fn render(&self, content: &str) -> RenderedMarkdown {
@@ -238,10 +231,6 @@ fn escape_html(input: &str) -> String {
     crate::xml::escape(input)
 }
 
-pub fn parse_markdown(content: &str) -> RenderedMarkdown {
-    MARKDOWN_RENDERER.render(content)
-}
-
 pub fn word_count(text: &str) -> usize {
     text.split_whitespace().count()
 }
@@ -301,11 +290,6 @@ pub fn preprocess_math(content: &str) -> String {
                     position += 1;
                 }
                 continue;
-            } else if position + 2 < length
-                && chars[position + 1] == '~'
-                && chars[position + 2] == '~'
-            {
-                continue;
             } else {
                 in_inline_code = true;
                 output.push(chars[position]);
@@ -561,32 +545,20 @@ pub fn extract_frontmatter(content: &str, path: &Path) -> Result<(Frontmatter, S
 fn parse_toml_frontmatter(content: &str, path: &Path) -> Result<(Frontmatter, String)> {
     let rest = &content[3..];
 
-    let mut search_offset = 0;
-    loop {
-        let end_index = find_closing_delimiter(&rest[search_offset..], "+++")
-            .map(|position| search_offset + position)
-            .ok_or_else(|| BambooError::InvalidFrontmatter {
-                path: path.to_path_buf(),
-            })?;
-
-        let frontmatter_str = &rest[..end_index];
-        match toml::from_str::<HashMap<String, Value>>(frontmatter_str) {
-            Ok(raw) => {
-                let body = &rest[end_index + 3..];
-                return Ok((Frontmatter { raw }, body.trim().to_string()));
-            }
-            Err(error) => {
-                let next_start = end_index + 3;
-                if next_start >= rest.len() {
-                    return Err(BambooError::TomlParse {
-                        path: path.to_path_buf(),
-                        message: error.to_string(),
-                    });
-                }
-                search_offset = next_start;
-            }
-        }
-    }
+    let end_index =
+        find_closing_delimiter(rest, "+++").ok_or_else(|| BambooError::InvalidFrontmatter {
+            path: path.to_path_buf(),
+        })?;
+
+    let frontmatter_str = &rest[..end_index];
+    let raw: HashMap<String, Value> =
+        toml::from_str(frontmatter_str).map_err(|error| BambooError::TomlParse {
+            path: path.to_path_buf(),
+            message: error.to_string(),
+        })?;
+
+    let body = &rest[end_index + 3..];
+    Ok((Frontmatter { raw }, body.trim().to_string()))
 }
 
 fn parse_yaml_frontmatter(content: &str, path: &Path) -> Result<(Frontmatter, String)> {
@@ -661,10 +633,14 @@ mod tests {
     use super::*;
     use std::path::PathBuf;
 
+    fn render(input: &str) -> RenderedMarkdown {
+        MarkdownRenderer::new().render(input)
+    }
+
     #[test]
     fn test_parse_markdown() {
         let input = "# Hello\n\nThis is **bold**.";
-        let output = parse_markdown(input);
+        let output = render(input);
         assert!(output.html.contains("<h1"));
         assert!(output.html.contains("Hello"));
         assert!(output.html.contains("<strong>bold</strong>"));
@@ -673,23 +649,23 @@ mod tests {
     #[test]
     fn test_parse_markdown_with_code() {
         let input = "```rust\nfn main() {}\n```";
-        let output = parse_markdown(input);
+        let output = render(input);
         assert!(output.html.contains("fn"));
         assert!(output.html.contains("main"));
     }
 
     #[test]
     fn test_heading_anchors() {
         let input = "## My Heading";
-        let output = parse_markdown(input);
+        let output = render(input);
         assert!(output.html.contains("id=\"my-heading\""));
         assert!(output.html.contains("href=\"#my-heading\""));
     }
 
     #[test]
     fn test_toc_generation() {
         let input = "# Title\n## Section One\n### Subsection\n## Section Two";
-        let output = parse_markdown(input);
+        let output = render(input);
         assert_eq!(output.toc.len(), 4);
         assert_eq!(output.toc[0].level, 1);
         assert_eq!(output.toc[0].title, "Title");
@@ -826,4 +802,19 @@ mod tests {
         let output = preprocess_math(input);
         assert_eq!(output, input);
     }
+
+    #[test]
+    fn test_preprocess_math_backtick_followed_by_tildes() {
+        let input = "`~~something~~`";
+        let output = preprocess_math(input);
+        assert_eq!(output, input);
+    }
+
+    #[test]
+    fn test_toml_frontmatter_malformed_returns_error() {
+        let content = "+++\ntitle = \n+++\n\nBody content";
+        let path = PathBuf::from("test.md");
+        let result = extract_frontmatter(content, &path);
+        assert!(result.is_err());
+    }
 }