Struct SiteGenerator 

pub struct SiteGenerator {
    pub source_dir: PathBuf,
    pub output_dir: PathBuf,
    pub theme: Theme,
    pub site_config: SiteConfig,
    pub documents: Vec<Document>,
    pub document_cache: HashMap<String, Document>,
}

The main site generator that processes Markdown files and creates a static website.

SiteGenerator handles the entire process of creating a static site:

• Scanning and parsing Markdown files with front matter
• Processing internationalization and translations
• Applying themes and templates
• Generating HTML output with navigation features
• Creating Atom feeds

Example

use krik::generator::SiteGenerator;
use std::path::PathBuf;

let mut generator = SiteGenerator::new(
    "content",           // Source directory
    "_site",            // Output directory  
    Some("themes/custom") // Optional theme directory
)?;

generator.scan_files()?;
generator.generate_site()?;

Fields

source_dir: PathBuf

Source directory containing Markdown files and assets

output_dir: PathBuf

Output directory where the generated site will be written

theme: Theme

Theme configuration and templates

site_config: SiteConfig

Site-wide configuration loaded from site.toml

documents: Vec<Document>

Parsed documents ready for processing

document_cache: HashMap<String, Document>

Incremental cache: map from relative file path to Document

Implementations

impl SiteGenerator

pub fn new<P: AsRef<Path>>( source_dir: P, output_dir: P, theme_dir: Option<P>, ) -> KrikResult<Self>

Creates a new SiteGenerator instance.

Arguments

• source_dir - Directory containing Markdown files and content
• output_dir - Directory where generated HTML will be written
• theme_dir - Optional custom theme directory (defaults to themes/default)

Returns

Returns a Result containing the SiteGenerator or an error if initialization fails.

Example

use krik::generator::SiteGenerator;

// Using default theme
let generator = SiteGenerator::new("content", "_site", None::<&str>)?;

// Using custom theme
let generator = SiteGenerator::new("content", "_site", Some("my-theme"))?;

pub fn scan_files(&mut self) -> KrikResult<()>

Scan files in the source directory and parse markdown documents

pub fn generate_site(&self) -> KrikResult<()>

Generate the complete static site

This orchestrates the entire site generation process:

1. Copy non-markdown files and theme assets
2. Generate HTML pages from documents
3. Generate index page with post listings
4. Generate Atom feed
5. Generate XML sitemap
6. Generate robots.txt
7. Generate PDFs (if pandoc and typst are available)

pub fn generate_incremental_for_path<P: AsRef<Path>>( &mut self, changed_path: P, is_removed: bool, ) -> KrikResult<()>

Incrementally (re)generate outputs affected by a single changed content or asset file.

Behavior:

• If a markdown file changed: re-scan just that file, update/emit its HTML, and re-render index/feed/sitemap.
• If a non-markdown content asset changed: copy that single asset into the output.
• If a content file was removed: remove the mirrored output file and refresh index/feed/sitemap.
• If a theme file changed (templates/assets), fall back to full regeneration as templates affect many pages.

Trait Implementations

impl Debug for SiteGenerator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.