Chapter 20: Real-World Example: Crafting a Learning Platform with Chapters

// src/frontmatter.rs

use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(default)] // Allows us to have default values for fields not present
pub struct FrontMatter {
    pub title: String,
    pub date: Option<String>, // Using Option<String> for flexibility
    pub draft: bool,
    pub description: Option<String>,
    pub slug: Option<String>,
    pub permalink: Option<String>,
    pub weight: Option<i32>,
    pub keywords: Vec<String>,
    pub tags: Vec<String>,
    pub categories: Vec<String>,
    pub author: Option<String>,
    pub show_reading_time: bool,
    pub show_table_of_contents: bool,
    pub show_comments: bool,
    pub toc: bool,
    pub template: Option<String>, // Custom template for this page
    pub extra: Option<HashMap<String, String>>, // For any extra, unstructured data

    // New fields for learning platform structure
    pub course_id: Option<String>,   // Unique identifier for the course
    pub module_id: Option<String>,   // Unique identifier for the module within a course
    pub chapter_order: Option<i32>,  // Order of this chapter/module within its parent
    pub chapter_title: Option<String>, // Specific title for the chapter in navigation
}

impl Default for FrontMatter {
    fn default() -> Self {
        FrontMatter {
            title: "Untitled".to_string(),
            date: None,
            draft: false,
            description: None,
            slug: None,
            permalink: None,
            weight: None,
            keywords: Vec::new(),
            tags: Vec::new(),
            categories: Vec::new(),
            author: None,
            show_reading_time: true,
            show_table_of_contents: true,
            show_comments: false,
            toc: true,
            template: None,
            extra: None,
            course_id: None,
            module_id: None,
            chapter_order: None,
            chapter_title: None,
        }
    }
}

+++
title = "My First Chapter"
course_id = "test-course-id"
module_id = "intro-module"
chapter_order = 1
chapter_title = "Introduction to Testing"
+++

This is the content of my first chapter.

// src/main.rs (temporary verification code)
// ... existing imports ...
use crate::content::{Content, ContentLoader}; // Ensure ContentLoader is public

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();
    log::info!("Starting SSG build process...");

    // ... existing content loader setup ...

    // Temporary: Load a specific file to test new frontmatter fields
    let temp_content_path = PathBuf::from("content/test-course/chapter-1.md");
    if temp_content_path.exists() {
        log::info!("Attempting to load test content: {:?}", temp_content_path);
        match ContentLoader::load(&temp_content_path, &PathBuf::from("content")) {
            Ok(content) => {
                log::info!("Successfully loaded test content.");
                log::info!("Test Content Frontmatter: {:?}", content.front_matter);
                assert_eq!(content.front_matter.course_id, Some("test-course-id".to_string()));
                assert_eq!(content.front_matter.module_id, Some("intro-module".to_string()));
                assert_eq!(content.front_matter.chapter_order, Some(1));
                assert_eq!(content.front_matter.chapter_title, Some("Introduction to Testing".to_string()));
                log::info!("Test frontmatter fields verified successfully!");
            },
            Err(e) => log::error!("Failed to load test content: {}", e),
        }
    } else {
        log::warn!("Test content file 'content/test-course/chapter-1.md' not found. Skipping frontmatter test.");
    }

    // ... rest of your build process ...
    // For now, let's just exit after the test
    Ok(()) // Or continue with the full build if you want
}

// src/content_tree.rs

use crate::content::Content;
use std::collections::BTreeMap; // BTreeMap keeps keys sorted

#[derive(Debug, Clone, PartialEq)]
pub struct ChapterItem {
    pub title: String,
    pub url: String,
    pub order: i32,
    pub content: Content, // Reference to the full content for rendering
}

#[derive(Debug, Clone, PartialEq)]
pub struct ModuleItem {
    pub id: String,
    pub title: String,
    pub order: i32,
    pub chapters: BTreeMap<i32, ChapterItem>, // Key: chapter_order
    pub module_page_url: Option<String>, // URL for the module's _index.md if it exists
}

#[derive(Debug, Clone, PartialEq)]
pub struct CourseItem {
    pub id: String,
    pub title: String,
    pub url: String, // URL to the course overview page (_index.md)
    pub modules: BTreeMap<i32, ModuleItem>, // Key: module_order
    pub content: Content, // Reference to the course overview content
}

#[derive(Debug, Clone, PartialEq, Default)]
pub struct ContentTree {
    pub courses: BTreeMap<String, CourseItem>, // Key: course_id
}

impl ContentTree {
    /// Builds a hierarchical content tree from a flat list of Content objects.
    pub fn build(all_content: &[Content]) -> Self {
        log::info!("Building content tree for learning platform...");
        let mut courses: BTreeMap<String, CourseItem> = BTreeMap::new();

        for content in all_content {
            if let Some(course_id) = &content.front_matter.course_id {
                let course_order = content.front_matter.weight.unwrap_or(0); // Use weight for course order

                // Handle course overview pages (_index.md for a course)
                if content.is_index_page() && content.file_path.parent().map_or(false, |p| p.ends_with(&format!("courses/{}", course_id))) {
                    let course_item = courses.entry(course_id.clone()).or_insert_with(|| CourseItem {
                        id: course_id.clone(),
                        title: content.front_matter.title.clone(),
                        url: content.permalink.clone(),
                        modules: BTreeMap::new(),
                        content: content.clone(),
                    });
                    // Update course title and URL if this is the canonical _index.md
                    course_item.title = content.front_matter.title.clone();
                    course_item.url = content.permalink.clone();
                    course_item.content = content.clone();
                    log::debug!("Found course overview: {} ({})", course_item.title, course_item.id);
                    continue; // Process other content for this course later
                }

                // Handle modules and chapters
                if let Some(module_id) = &content.front_matter.module_id {
                    let chapter_order = content.front_matter.chapter_order.unwrap_or(0);
                    let chapter_title = content.front_matter.chapter_title.clone().unwrap_or_else(|| content.front_matter.title.clone());

                    let course_item = courses.entry(course_id.clone()).or_insert_with(|| {
                        // Create a dummy course item if _index.md not yet processed
                        log::warn!("Course '{}' content found before its _index.md. Creating placeholder.", course_id);
                        CourseItem {
                            id: course_id.clone(),
                            title: format!("Course {}", course_id), // Placeholder title
                            url: format!("/courses/{}", course_id), // Placeholder URL
                            modules: BTreeMap::new(),
                            content: Content::default(), // Placeholder content
                        }
                    });

                    let module_order = content.front_matter.weight.unwrap_or(0); // Use weight for module order
                    let module_item = course_item.modules.entry(module_order).or_insert_with(|| ModuleItem {
                        id: module_id.clone(),
                        title: module_id.clone(), // Placeholder, will be updated by module _index.md
                        order: module_order,
                        chapters: BTreeMap::new(),
                        module_page_url: None,
                    });

                    // Update module title and URL if this is a module _index.md
                    if content.is_index_page() && content.file_path.parent().map_or(false, |p| p.ends_with(&format!("{}/{}", course_id, module_id))) {
                        module_item.title = content.front_matter.title.clone();
                        module_item.module_page_url = Some(content.permalink.clone());
                        log::debug!("Found module overview: {} ({})", module_item.title, module_item.id);
                        continue; // Skip adding _index.md as a regular chapter
                    }

                    // Add regular chapters
                    let chapter_item = ChapterItem {
                        title: chapter_title,
                        url: content.permalink.clone(),
                        order: chapter_order,
                        content: content.clone(),
                    };
                    log::debug!("Adding chapter: {} (Order: {}) to Module: {} in Course: {}", chapter_item.title, chapter_item.order, module_item.id, course_id);
                    module_item.chapters.insert(chapter_order, chapter_item);
                }
            }
        }

        // Ensure course titles/urls are set even if no _index.md, or if _index.md was processed last.
        // Also ensure module titles are set.
        for (_course_id, course) in courses.iter_mut() {
            // If course title is still placeholder, try to find a chapter with a good title
            if course.title.starts_with("Course ") {
                if let Some(first_module) = course.modules.values().next() {
                    if let Some(first_chapter) = first_module.chapters.values().next() {
                        course.title = first_chapter.content.front_matter.course_id
                            .as_ref()
                            .map(|id| id.replace('-', " ").to_string()) // Basic formatting
                            .unwrap_or_else(|| "Untitled Course".to_string());
                    }
                }
            }
            for (_module_order, module) in course.modules.iter_mut() {
                if module.title == module.id { // If module title is still placeholder
                    if let Some(first_chapter) = module.chapters.values().next() {
                        module.title = first_chapter.content.front_matter.module_id
                            .as_ref()
                            .map(|id| id.replace('-', " ").to_string()) // Basic formatting
                            .unwrap_or_else(|| "Untitled Module".to_string());
                    }
                }
            }
        }


        log::info!("Content tree built with {} courses.", courses.len());
        ContentTree { courses }
    }

    /// Gets previous and next chapter URLs for a given chapter permalink.
    pub fn get_prev_next_chapters(&self, current_permalink: &str) -> (Option<ChapterItem>, Option<ChapterItem>) {
        for course in self.courses.values() {
            for module in course.modules.values() {
                let chapter_urls: Vec<&ChapterItem> = module.chapters.values().collect();
                for (i, chapter) in chapter_urls.iter().enumerate() {
                    if chapter.url == current_permalink {
                        let prev = if i > 0 { Some(chapter_urls[i - 1].clone()) } else { None };
                        let next = if i < chapter_urls.len() - 1 { Some(chapter_urls[i + 1].clone()) } else { None };
                        return (prev, next);
                    }
                }
            }
        }
        (None, None)
    }

    /// Gets the CourseItem associated with a given permalink, if it's a chapter within that course.
    pub fn get_course_for_permalink(&self, permalink: &str) -> Option<CourseItem> {
        for course in self.courses.values() {
            if course.url == permalink {
                return Some(course.clone());
            }
            for module in course.modules.values() {
                if module.module_page_url.as_ref().map_or(false, |url| url == permalink) {
                    return Some(course.clone());
                }
                for chapter in module.chapters.values() {
                    if chapter.url == permalink {
                        return Some(course.clone());
                    }
                }
            }
        }
        None
    }
}

// src/build_context.rs

use std::collections::HashMap;
use tera::Tera;
use crate::content::Content;
use crate::component_processor::ComponentDefinitions;
use crate::content_tree::ContentTree; // New import

pub struct BuildContext<'a> {
    pub tera: Tera,
    pub all_content: Vec<Content>,
    pub component_definitions: ComponentDefinitions,
    pub output_dir: &'a Path,
    pub base_url: &'a str,
    pub content_tree: ContentTree, // Add the content tree
    // ... potentially other fields like search index, etc.
}

impl<'a> BuildContext<'a> {
    pub fn new(
        tera: Tera,
        all_content: Vec<Content>,
        component_definitions: ComponentDefinitions,
        output_dir: &'a Path,
        base_url: &'a str,
    ) -> Self {
        // Build the content tree as part of context creation
        let content_tree = ContentTree::build(&all_content);
        BuildContext {
            tera,
            all_content,
            component_definitions,
            output_dir,
            base_url,
            content_tree, // Initialize the content tree
        }
    }
}

+++
title = "All Courses"
template = "course_list.html"
slug = "courses"
+++
Welcome to our learning platform!

+++
title = "Rust Basics Course"
course_id = "rust-basics"
template = "course_page.html"
weight = 1 # Order of this course in a list
+++
Learn the fundamentals of Rust programming.

+++
title = "What is Rust?"
course_id = "rust-basics"
module_id = "01-introduction"
chapter_order = 1
chapter_title = "What is Rust?"
+++
Rust is a systems programming language that focuses on safety, speed, and concurrency.

+++
title = "Setting Up Rust"
course_id = "rust-basics"
module_id = "01-introduction"
chapter_order = 2
chapter_title = "Setting Up Your Environment"
+++
This chapter guides you through installing Rust.

+++
title = "Primitive Data Types"
course_id = "rust-basics"
module_id = "02-data-types"
chapter_order = 1
chapter_title = "Rust Primitives"
+++
Rust has several primitive data types...

// src/main.rs (temporary verification code)
// ... existing imports ...
use crate::build_context::BuildContext; // Ensure BuildContext is public
use crate::content::ContentLoader;
use crate::component_processor::ComponentDefinitions;
use tera::Tera;
use std::path::{Path, PathBuf};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();
    log::info!("Starting SSG build process...");

    let content_dir = PathBuf::from("content");
    let output_dir = PathBuf::from("public");
    let templates_dir = PathBuf::from("templates");
    let base_url = "/";

    // 1. Load all content
    let all_content = ContentLoader::load_all(&content_dir)?;
    log::info!("Loaded {} content files.", all_content.len());

    // 2. Load Tera templates
    let mut tera = Tera::new(templates_dir.join("**/*.html").to_str().unwrap())?;
    tera.autoescape_on(vec![".html", ".sql"]); // Example, adjust as needed

    // 3. Load component definitions (assuming this is set up)
    let component_definitions = ComponentDefinitions::load(&PathBuf::from("components"))?; // Adjust path if needed

    // 4. Create BuildContext, which now builds the ContentTree
    let build_context = BuildContext::new(
        tera,
        all_content,
        component_definitions,
        &output_dir,
        base_url,
    );

    // Temporary: Print the built content tree
    log::info!("--- Generated Content Tree ---");
    log::info!("{:#?}", build_context.content_tree);
    log::info!("------------------------------");

    // ... rest of your build process (to be added later) ...
    Ok(())
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{{ page.title | default(value="Untitled Page") }} - My Learning Platform</title>
    <link rel="stylesheet" href="/styles.css"> {# Assuming you have a CSS file #}
    {% block head_extra %}{% endblock head_extra %}
</head>
<body>
    <header>
        <nav>
            <a href="/">Home</a>
            <a href="/courses/">Courses</a>
            {# Add more global navigation links #}
        </nav>
    </header>

    <main>
        {% block content %}{% endblock content %}
    </main>

    <footer>
        <p>&copy; 2026 My Learning Platform</p>
        {% block footer_extra %}{% endblock footer_extra %}
    </footer>
</body>
</html>

{% extends "base.html" %}

{% block content %}
<div class="container">
    <h1>{{ page.title }}</h1>
    <p>{{ page.description | default(value="Browse our available courses.") }}</p>

    <div class="course-grid">
        {% for course_id, course in content_tree.courses %}
        <div class="course-card">
            <h2><a href="{{ course.url }}">{{ course.title }}</a></h2>
            <p>{{ course.content.front_matter.description | default(value="No description available.") }}</p>
            <a href="{{ course.url }}" class="btn">Start Learning</a>
        </div>
        {% endfor %}
    </div>
</div>
{% endblock content %}

{% extends "base.html" %}

{% block content %}
<div class="container course-layout">
    <aside class="sidebar">
        <h2>{{ course.title }}</h2>
        <nav>
            {% for module_order, module in course.modules %}
            <h3>{{ module.title }}</h3>
            <ul>
                {% for chapter_order, chapter in module.chapters %}
                <li {% if chapter.url == page.permalink %}class="active"{% endif %}>
                    <a href="{{ chapter.url }}">{{ chapter.title }}</a>
                </li>
                {% endfor %}
            </ul>
            {% endfor %}
        </nav>
    </aside>
    <article class="main-content">
        <h1>{{ page.title }}</h1>
        <div class="course-description">
            {{ page.content | safe }} {# Render the markdown content of the _index.md #}
        </div>
        
        {% if course.modules %}
        <h2>Modules</h2>
        <ul class="module-list">
            {% for module_order, module in course.modules %}
            <li>
                <h3>{{ module.title }}</h3>
                <ul>
                    {% for chapter_order, chapter in module.chapters %}
                    <li><a href="{{ chapter.url }}">{{ chapter.title }}</a></li>
                    {% endfor %}
                </ul>
            </li>
            {% endfor %}
        </ul>
        {% else %}
        <p>No modules found for this course yet.</p>
        {% endif %}
    </article>
</div>
{% endblock content %}

{% extends "base.html" %}

{% block content %}
<div class="container chapter-layout">
    <aside class="sidebar">
        {% if course %}
            <h2><a href="{{ course.url }}">{{ course.title }}</a></h2>
            <nav>
                {% for module_order, module in course.modules %}
                <h3>{{ module.title }}</h3>
                <ul>
                    {% for chapter_order, chapter in module.chapters %}
                    <li {% if chapter.url == page.permalink %}class="active"{% endif %}>
                        <a href="{{ chapter.url }}">{{ chapter.title }}</a>
                    </li>
                    {% endfor %}
                </ul>
                {% endfor %}
            </nav>
        {% else %}
            <p>Course navigation unavailable.</p>
        {% endif %}
    </aside>
    <article class="main-content">
        <h1>{{ page.title }}</h1>
        <div class="chapter-body">
            {{ page.content | safe }} {# Render the markdown content #}
        </div>

        <nav class="chapter-pagination">
            {% if prev_chapter %}
            <a href="{{ prev_chapter.url }}" class="prev-chapter">&larr; {{ prev_chapter.title }}</a>
            {% else %}
            <span>&larr; No Previous Chapter</span>
            {% endif %}

            {% if next_chapter %}
            <a href="{{ next_chapter.url }}" class="next-chapter">{{ next_chapter.title }} &rarr;</a>
            {% else %}
            <span>No Next Chapter &rarr;</span>
            {% endif %}
        </nav>
    </article>
</div>
{% endblock content %}

// src/renderer.rs

use crate::content::{Content, RenderedContent};
use crate::build_context::BuildContext;
use tera::{Context, Tera};
use std::path::{Path, PathBuf};
use std::fs;
use anyhow::{Result, anyhow};
use log::{info, error};

pub struct Renderer<'a> {
    build_context: &'a BuildContext<'a>,
}

impl<'a> Renderer<'a> {
    pub fn new(build_context: &'a BuildContext<'a>) -> Self {
        Renderer { build_context }
    }

    /// Renders a single Content item to its final HTML page.
    pub fn render_content_page(&self, content: &Content) -> Result<()> {
        let template_name = content.front_matter.template.as_deref().unwrap_or("chapter_page.html"); // Default to chapter_page
        info!("Rendering content: '{}' using template '{}'", content.permalink, template_name);

        let mut context = Context::new();
        context.insert("page", &content); // The current page's data

        // Provide the entire content tree to all templates
        context.insert("content_tree", &self.build_context.content_tree);

        // If this is a chapter, provide previous/next links and its parent course
        if content.front_matter.course_id.is_some() {
            let (prev, next) = self.build_context.content_tree.get_prev_next_chapters(&content.permalink);
            context.insert("prev_chapter", &prev);
            context.insert("next_chapter", &next);

            if let Some(course_item) = self.build_context.content_tree.get_course_for_permalink(&content.permalink) {
                context.insert("course", &course_item);
            }
        }

        // Render custom components
        let mut rendered_html = content.rendered_html.clone();
        for (component_key, component_data) in &content.component_data {
            if let Some(component_def) = self.build_context.component_definitions.get(component_key) {
                let component_context = component_data.iter()
                    .map(|(k, v)| (k.clone(), v.clone()))
                    .collect::<std::collections::HashMap<String, String>>();
                
                match self.build_context.tera.render(&component_def.template, &Context::from_serialize(component_context)?) {
                    Ok(rendered_component) => {
                        let placeholder = format!("<!--COMPONENT_{}-->", component_key); // Use the same placeholder from Chapter 14
                        rendered_html = rendered_html.replace(&placeholder, &rendered_component);
                        info!("Replaced component placeholder for '{}'", component_key);
                    },
                    Err(e) => error!("Failed to render component '{}': {}", component_key, e),
                }
            } else {
                error!("Component definition not found for key: {}", component_key);
            }
        }
        
        // Final render with Tera
        let final_html = self.build_context.tera.render(template_name, &context)
            .map_err(|e| anyhow!("Failed to render template '{}' for '{}': {}", template_name, content.permalink, e))?;

        // Determine output path
        let output_path = self.build_context.output_dir.join(&content.permalink.trim_start_matches('/'));
        let output_file_path = if output_path.extension().is_none() {
            output_path.join("index.html") // For clean URLs (e.g., /about/ -> /about/index.html)
        } else {
            output_path
        };

        // Ensure parent directories exist
        if let Some(parent) = output_file_path.parent() {
            fs::create_dir_all(parent)
                .map_err(|e| anyhow!("Failed to create output directory {}: {}", parent.display(), e))?;
        }

        fs::write(&output_file_path, final_html)
            .map_err(|e| anyhow!("Failed to write output file {}: {}", output_file_path.display(), e))?;

        info!("Successfully rendered and wrote: {}", output_file_path.display());
        Ok(())
    }

    /// Renders a custom page (e.g., a course list page) that doesn't correspond directly to a Content item.
    pub fn render_custom_page(&self, template_name: &str, output_path: &Path, context_data: serde_json::Value) -> Result<()> {
        info!("Rendering custom page: '{}' using template '{}'", output_path.display(), template_name);

        let mut context = Context::from_value(context_data)?;
        // Always provide the content tree to custom pages too
        context.insert("content_tree", &self.build_context.content_tree);

        let final_html = self.build_context.tera.render(template_name, &context)
            .map_err(|e| anyhow!("Failed to render custom template '{}' for '{}': {}", template_name, output_path.display(), e))?;

        let output_file_path = if output_path.extension().is_none() {
            self.build_context.output_dir.join(output_path).join("index.html")
        } else {
            self.build_context.output_dir.join(output_path)
        };

        if let Some(parent) = output_file_path.parent() {
            fs::create_dir_all(parent)
                .map_err(|e| anyhow!("Failed to create output directory {}: {}", parent.display(), e))?;
        }

        fs::write(&output_file_path, final_html)
            .map_err(|e| anyhow!("Failed to write output file {}: {}", output_file_path.display(), e))?;

        info!("Successfully rendered custom page: {}", output_file_path.display());
        Ok(())
    }
}

// src/main.rs

use std::path::{Path, PathBuf};
use std::fs;
use anyhow::{Result, anyhow};
use log::{info, error, debug};
use tera::Tera;

mod content;
mod frontmatter;
mod parser;
mod renderer;
mod build_context;
mod component_processor;
mod content_tree; // New module import

use crate::content::{Content, ContentLoader};
use crate::renderer::Renderer;
use crate::build_context::BuildContext;
use crate::component_processor::ComponentDefinitions;
use crate::content_tree::{ContentTree, CourseItem}; // Import CourseItem too

fn main() -> Result<()> {
    env_logger::init();
    info!("Starting SSG build process...");

    let content_dir = PathBuf::from("content");
    let output_dir = PathBuf::from("public");
    let templates_dir = PathBuf::from("templates");
    let base_url = "/"; // Configure your base URL

    // Clean output directory
    if output_dir.exists() {
        fs::remove_dir_all(&output_dir)
            .map_err(|e| anyhow!("Failed to clean output directory {}: {}", output_dir.display(), e))?;
        info!("Cleaned output directory: {}", output_dir.display());
    }
    fs::create_dir_all(&output_dir)
        .map_err(|e| anyhow!("Failed to create output directory {}: {}", output_dir.display(), e))?;

    // 1. Load component definitions
    let component_definitions = ComponentDefinitions::load(&PathBuf::from("components"))?;
    info!("Loaded {} component definitions.", component_definitions.len());

    // 2. Load all content files, parse frontmatter and markdown
    let mut all_content = ContentLoader::load_all(&content_dir)?;
    info!("Loaded and parsed {} content files.", all_content.len());

    // 3. Initialize Tera templates
    let mut tera = Tera::new(templates_dir.join("**/*.html").to_str().unwrap())?;
    tera.autoescape_on(vec![".html", ".sql"]); // Apply autoescaping rules
    info!("Loaded Tera templates from: {}", templates_dir.display());

    // 4. Create BuildContext (which now builds the ContentTree)
    let build_context = BuildContext::new(
        tera,
        all_content, // BuildContext takes ownership of all_content
        component_definitions,
        &output_dir,
        base_url,
    );

    // 5. Initialize Renderer
    let renderer = Renderer::new(&build_context);

    // 6. Render all content pages
    for content in build_context.all_content.iter() {
        if content.front_matter.draft {
            debug!("Skipping draft content: {}", content.permalink);
            continue;
        }
        renderer.render_content_page(content)?;
    }

    // 7. Handle custom pages, e.g., the main course listing page
    // Find the content item for the courses index page
    let courses_index_content = build_context.all_content.iter()
        .find(|c| c.permalink == "/courses/"); // Assuming /courses/ is the URL for the main course list

    if let Some(content) = courses_index_content {
        // If it specifies a template, use it, otherwise a default
        let template_name = content.front_matter.template.as_deref().unwrap_or("course_list.html");
        let output_path = PathBuf::from(content.permalink.trim_start_matches('/'));

        let mut context_data = serde_json::to_value(content)?; // Pass its own data
        // The `content_tree` is automatically added by `render_custom_page`
        renderer.render_custom_page(template_name, &output_path, context_data)?;
    } else {
        info!("No content file found for /courses/, skipping explicit course list page generation.");
        // Optionally, you could generate a default /courses/ page even if no _index.md exists
        // let default_course_list_context = serde_json::json!({ "title": "All Courses" });
        // renderer.render_custom_page("course_list.html", &PathBuf::from("courses"), default_course_list_context)?;
    }


    // 8. Copy static assets (if you have a static directory)
    // Example: copy_static_assets(&PathBuf::from("static"), &output_dir)?;

    info!("SSG build process completed successfully!");
    Ok(())
}

// Example function to copy static assets
fn copy_static_assets(src: &Path, dest: &Path) -> Result<()> {
    if !src.exists() {
        info!("Static assets directory '{}' not found. Skipping.", src.display());
        return Ok(());
    }

    info!("Copying static assets from '{}' to '{}'...", src.display(), dest.display());
    for entry in fs::read_dir(src)? {
        let entry = entry?;
        let path = entry.path();
        let relative_path = path.strip_prefix(src)?;
        let dest_path = dest.join(relative_path);

        if path.is_dir() {
            fs::create_dir_all(&dest_path)?;
            copy_static_assets(&path, &dest_path)?; // Recursive copy for subdirectories
        } else {
            fs::copy(&path, &dest_path)?;
        }
    }
    info!("Static assets copied.");
    Ok(())
}

template = "components/quiz.html"

<div class="quiz-component" data-question="{{ question | default(value='No question?') }}" data-answer="{{ answer | default(value='No answer?') }}">
    <p><strong>Quiz:</strong> {{ question | default(value='No question provided.') }}</p>
    <button onclick="alert('Answer: {{ answer | default(value='No answer provided.') }}')">Show Answer</button>
    {# For actual hydration, this would be a client-side JS component #}
</div>

+++
title = "What is Rust?"
course_id = "rust-basics"
module_id = "01-introduction"
chapter_order = 1
chapter_title = "What is Rust?"
+++
Rust is a systems programming language that focuses on safety, speed, and concurrency.

It's known for its strong memory safety guarantees without garbage collection.

<Quiz question="What is Rust primarily known for?" answer="Safety, speed, and concurrency." />