Refactor site generator

Author: paviro

src/site_generator.rs

@@ -0,0 +1,165 @@
+//! Asset management: directory creation, static file copying, and cover generation.
+
+use super::SiteGenerator;
+use crate::models::{Book, StatisticsData};
+use anyhow::{Context, Result};
+use futures::future;
+use log::info;
+use std::fs;
+use std::time::SystemTime;
+
+impl SiteGenerator {
+    pub(crate) async fn create_directories(&self, books: &[Book], stats_data: &Option<StatisticsData>) -> Result<()> {
+        fs::create_dir_all(&self.output_dir)?;
+        
+        // Only create books directory if we have books
+        if !books.is_empty() {
+            fs::create_dir_all(self.books_dir())?;
+            fs::create_dir_all(self.covers_dir())?;
+        }
+        
+        // Always create assets directories for CSS/JS as they're always needed
+        fs::create_dir_all(self.css_dir())?;
+        fs::create_dir_all(self.js_dir())?;
+        
+        // Create directories based on what we have
+        if stats_data.is_some() {
+            // Create JSON directories for statistics data
+            fs::create_dir_all(self.json_dir())?;
+            fs::create_dir_all(self.statistics_json_dir())?;
+            fs::create_dir_all(self.calendar_json_dir())?;
+            // Recap pages directory (static HTML)
+            fs::create_dir_all(self.recap_dir())?;
+            
+            // Create calendar directory
+            fs::create_dir_all(self.calendar_dir())?;
+            
+            // Only create statistics directory if we have books (if no books, stats render to root)
+            if !books.is_empty() {
+                fs::create_dir_all(self.statistics_dir())?;
+            }
+        }
+        
+        Ok(())
+    }
+    
+    pub(crate) async fn copy_static_assets(&self, books: &[Book], stats_data: &Option<StatisticsData>) -> Result<()> {
+        // Write the pre-compiled CSS (always needed for basic styling)
+        let css_content = include_str!(concat!(env!("OUT_DIR"), "/compiled_style.css"));
+        fs::write(self.css_dir().join("style.css"), css_content)?;
+        
+        // Copy book-related JavaScript files only if we have books
+        if !books.is_empty() {
+            let js_content = include_str!("../../assets/book_list.js");
+            fs::write(self.js_dir().join("book_list.js"), js_content)?;
+
+            let js_content = include_str!("../../assets/book_detail.js");
+            fs::write(self.js_dir().join("book_detail.js"), js_content)?;
+            
+            let lazy_loading_content = include_str!("../../assets/lazy-loading.js");
+            fs::write(self.js_dir().join("lazy-loading.js"), lazy_loading_content)?;
+
+            let section_toggle_content = include_str!("../../assets/section-toggle.js");
+            fs::write(self.js_dir().join("section-toggle.js"), section_toggle_content)?;
+        }
+        
+        // Copy statistics-related JavaScript files only if we have stats data
+        if stats_data.is_some() {
+            let stats_js_content = include_str!("../../assets/statistics.js");
+            fs::write(self.js_dir().join("statistics.js"), stats_js_content)?;
+            
+            let heatmap_js_content = include_str!("../../assets/heatmap.js");
+            fs::write(self.js_dir().join("heatmap.js"), heatmap_js_content)?;
+
+            let calendar_css = include_str!(concat!(env!("OUT_DIR"), "/event-calendar.min.css"));
+            fs::write(self.css_dir().join("event-calendar.min.css"), calendar_css)?;
+
+            let calendar_js = include_str!(concat!(env!("OUT_DIR"), "/event-calendar.min.js"));
+            fs::write(self.js_dir().join("event-calendar.min.js"), calendar_js)?;
+            
+            let calendar_map = include_str!(concat!(env!("OUT_DIR"), "/event-calendar.min.js.map"));
+            fs::write(self.js_dir().join("event-calendar.min.js.map"), calendar_map)?;
+            
+            let calendar_init_js_content = include_str!("../../assets/calendar.js");
+            fs::write(self.js_dir().join("calendar.js"), calendar_init_js_content)?;
+
+            // Storage utility
+            let storage_js_content = include_str!("../../assets/storage-manager.js");
+            fs::write(self.js_dir().join("storage-manager.js"), storage_js_content)?;
+
+            // Recap small UI logic
+            let recap_js_content = include_str!("../../assets/recap.js");
+            fs::write(self.js_dir().join("recap.js"), recap_js_content)?;
+        }
+        
+        Ok(())
+    }
+    
+    pub(crate) async fn generate_covers(&self, books: &[Book]) -> Result<()> {
+        info!("Generating book covers...");
+        
+        // Collect all cover generation tasks
+        let mut tasks = Vec::new();
+        
+        for book in books {
+            if let Some(ref cover_data) = book.epub_info.cover_data {
+                let cover_path = self.covers_dir().join(format!("{}.webp", book.id));
+                let epub_path = book.epub_path.clone();
+                let cover_data = cover_data.clone();
+
+                let should_generate = match (fs::metadata(&epub_path), fs::metadata(&cover_path)) {
+                    (Ok(epub_meta), Ok(cover_meta)) => {
+                        let epub_time = epub_meta.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+                        let cover_time = cover_meta.modified().unwrap_or(SystemTime::UNIX_EPOCH);
+                        epub_time > cover_time
+                    }
+                    (Ok(_), Err(_)) => true, // Cover missing
+                    _ => true, // If we can't get metadata, be safe and regenerate
+                };
+
+                if should_generate {
+                    // Spawn a task for each cover generation
+                    let task = tokio::task::spawn_blocking(move || -> Result<()> {
+                        let img = image::load_from_memory(&cover_data)
+                            .context("Failed to load cover image")?;
+                        
+                        // Resize to height of 600px while maintaining aspect ratio
+                        let (original_width, original_height) = (img.width(), img.height());
+                        let target_height = 600;
+                        let target_width = (original_width * target_height) / original_height;
+                        
+                        let resized = img.resize(target_width, target_height, image::imageops::FilterType::Lanczos3);
+                        
+                        // Convert to RGB8 format for WebP encoding
+                        let rgb_img = resized.to_rgb8();
+                        
+                        // Use webp crate for better quality control
+                        let encoder = webp::Encoder::from_rgb(&rgb_img, rgb_img.width(), rgb_img.height());
+                        let webp_data = encoder.encode(50.0);
+                        
+                        fs::write(&cover_path, &*webp_data)
+                            .with_context(|| format!("Failed to save cover: {:?}", cover_path))?;
+                        
+                        Ok(())
+                    });
+                    
+                    tasks.push(task);
+                }
+            }
+        }
+        
+        // Wait for all cover generation tasks to complete
+        let results = future::join_all(tasks).await;
+        
+        // Check for any errors
+        for (i, result) in results.into_iter().enumerate() {
+            match result {
+                Ok(Ok(())) => {}, // Success
+                Ok(Err(e)) => return Err(e.context(format!("Failed to generate cover {}", i))),
+                Err(e) => return Err(anyhow::Error::new(e).context(format!("Task {} panicked", i))),
+            }
+        }
+        
+        Ok(())
+    }
+}

src/site_generator/assets.rs

@@ -0,0 +1,190 @@
+//! Book list and detail page generation.
+
+use super::SiteGenerator;
+use crate::models::{Book, BookStatus, StatisticsData};
+use crate::statistics::BookStatistics;
+use crate::templates::{IndexTemplate, BookTemplate, BookMarkdownTemplate};
+use anyhow::Result;
+use askama::Template;
+use log::info;
+use std::fs;
+
+impl SiteGenerator {
+    pub(crate) async fn generate_book_list(&self, books: &[Book], recap_latest_href: Option<String>) -> Result<()> {
+        info!("Generating book list page...");
+        
+        let mut reading_books = Vec::new();
+        let mut completed_books = Vec::new();
+        let mut abandoned_books = Vec::new();
+        let mut unread_books = Vec::new();
+        
+        for book in books {
+            match book.status() {
+                BookStatus::Reading => reading_books.push(book.clone()),
+                BookStatus::Complete => completed_books.push(book.clone()),
+                BookStatus::Abandoned => abandoned_books.push(book.clone()),
+                BookStatus::Unknown => {
+                    // If it has KoReader metadata, add to reading; otherwise check if we should include unread
+                    if book.koreader_metadata.is_some() {
+                        reading_books.push(book.clone());
+                    } else if self.include_unread {
+                        unread_books.push(book.clone());
+                    }
+                    // If include_unread is false, we skip books without metadata
+                }
+            }
+        }
+        
+        // Sort by title
+        reading_books.sort_by(|a, b| a.epub_info.title.cmp(&b.epub_info.title));
+        completed_books.sort_by(|a, b| a.epub_info.title.cmp(&b.epub_info.title));
+        abandoned_books.sort_by(|a, b| a.epub_info.title.cmp(&b.epub_info.title));
+        unread_books.sort_by(|a, b| a.epub_info.title.cmp(&b.epub_info.title));
+        
+        // ------------------------------------------------------------------
+        // Generate books manifest JSON categorized by reading status.
+        // NOTE: This manifest is not consumed by the frontend code – it is
+        // generated purely for the convenience of users who may want a
+        // machine-readable list of all books and their export paths.
+        // ------------------------------------------------------------------
+
+        use serde_json::json;
+
+        let to_manifest_entry = |b: &Book| {
+            json!({
+                "id": b.id.clone(),
+                "title": b.epub_info.title.clone(),
+                "authors": b.epub_info.authors.clone(),
+                "json_path": format!("/books/{}/details.json", b.id),
+                "html_path":  format!("/books/{}/index.html",  b.id),
+            })
+        };
+
+        let reading_json: Vec<_> = reading_books.iter().map(to_manifest_entry).collect();
+        let completed_json: Vec<_> = completed_books.iter().map(to_manifest_entry).collect();
+        let abandoned_json: Vec<_> = abandoned_books.iter().map(to_manifest_entry).collect();
+        let new_json: Vec<_> = unread_books.iter().map(to_manifest_entry).collect();
+
+        let manifest = json!({
+            "reading": reading_json,
+            "completed": completed_json,
+            "abandoned": abandoned_json,
+            "new": new_json,
+            "generated_at": self.get_last_updated(),
+        });
+
+        fs::write(
+            self.books_dir().join("list.json"),
+            serde_json::to_string_pretty(&manifest)?,
+        )?;
+
+        // ------------------------------------------------------------------
+        // Render book list HTML
+        // ------------------------------------------------------------------
+
+        let template = IndexTemplate {
+            site_title: self.site_title.clone(),
+            reading_books,
+            completed_books,
+            abandoned_books,
+            unread_books,
+            version: self.get_version(),
+            last_updated: self.get_last_updated(),
+            navbar_items: self.create_navbar_items_with_recap("books", recap_latest_href.as_deref()),
+        };
+
+        let html = template.render()?;
+        self.write_minify_html(self.output_dir.join("index.html"), &html)?;
+        
+        Ok(())
+    }
+    
+    pub(crate) async fn generate_book_pages(&self, books: &[Book], stats_data: &mut Option<StatisticsData>, recap_latest_href: Option<String>) -> Result<()> {
+        info!("Generating book detail pages...");
+        
+        for book in books {
+            // Try to find matching statistics by MD5
+            let book_stats = stats_data.as_ref().and_then(|stats| {
+                // Try to match using the partial_md5_checksum from KoReader metadata
+                book.koreader_metadata
+                    .as_ref()
+                    .and_then(|metadata| metadata.partial_md5_checksum.as_ref())
+                    .and_then(|md5| stats.stats_by_md5.get(md5))
+                    .cloned()
+            });
+            
+            // Calculate session statistics if we have book stats
+            let session_stats = match (stats_data.as_ref(), &book_stats) {
+                (Some(stats), Some(book_stat)) => Some(book_stat.calculate_session_stats(&stats.page_stats, &self.time_config)),
+                _ => None,
+            };
+            
+            let template = BookTemplate {
+                site_title: self.site_title.clone(),
+                book: book.clone(),
+                book_stats: book_stats.clone(),
+                session_stats: session_stats.clone(),
+                version: self.get_version(),
+                last_updated: self.get_last_updated(),
+                navbar_items: self.create_navbar_items_with_recap("books", recap_latest_href.as_deref()),
+            };
+            
+            let html = template.render()?;
+            let book_dir = self.books_dir().join(&book.id);
+            fs::create_dir_all(&book_dir)?;
+            let book_path = book_dir.join("index.html");
+            self.write_minify_html(book_path, &html)?;
+
+            // Generate Markdown export
+            let md_template = BookMarkdownTemplate {
+                book: book.clone(),
+                book_stats: book_stats.clone(),
+                session_stats: session_stats.clone(),
+                version: self.get_version(),
+                last_updated: self.get_last_updated(),
+            };
+            let markdown = md_template.render()?;
+            fs::write(book_dir.join("details.md"), markdown)?;
+
+            // Generate JSON export / not used by the frontend code - only for the user's convenience
+            let json_data = serde_json::json!({
+                "book": {
+                    "title": book.epub_info.title,
+                    "authors": book.epub_info.authors,
+                    "series": book.series_display(),
+                    "language": book.language(),
+                    "publisher": book.publisher(),
+                    "description": book.epub_info.sanitized_description(),
+                    "rating": book.rating(),
+                    "review_note": book.review_note(),
+                    "status": book.status().to_string(),
+                    "progress_percentage": book.progress_percentage(),
+                    "subjects": book.subjects(),
+                    "identifiers": book.identifiers().iter().map(|id| {
+                        serde_json::json!({
+                            "scheme": id.scheme,
+                            "value": id.value,
+                            "display_scheme": id.display_scheme(),
+                            "url": id.url()
+                        })
+                    }).collect::<Vec<_>>()
+                },
+                "annotations": book.koreader_metadata.as_ref().map(|m| &m.annotations).unwrap_or(&vec![]),
+                "statistics": {
+                    "book_stats": book_stats,
+                    "session_stats": session_stats,
+                    "completions": book_stats.as_ref().and_then(|stats| stats.completions.as_ref())
+                },
+                "export_info": {
+                    "generated_by": "KoShelf",
+                    "version": self.get_version(),
+                    "generated_at": self.get_last_updated()
+                }
+            });
+            let json_str = serde_json::to_string_pretty(&json_data)?;
+            fs::write(book_dir.join("details.json"), json_str)?;
+        }
+        
+        Ok(())
+    }
+}