Added dynamically generated index

Fleefie · Fleefie · commit e9f9b8e1a57e · 2025-05-09T01:07:52.000+02:00
diff --git a/README.md b/README.md
@@ -52,7 +52,7 @@ In order to create your own Goupiblog, you need to:
 
 - Set up your directory structure
 - Create your prelude (Or use the one provided!)
-- Add an index
+- (In the future!) create an index template
 - Set up site-wide options
 - Create your first post
 - Host the post on a simple file server
@@ -61,8 +61,9 @@ We'll get into each of the steps below.
 
 #### The index
 
-The index will be generated for you in the future. For now,
-make your own called "index.html" in the root of the sources directory.
+For now, the index is generated automatically, but is very basic.
+I'll figure out how to make it templated too soon:tm:. Regardless,
+it's available under ``target_dir/index.html``
 
 #### The prelude and the options
 
diff --git a/src/builder.rs b/src/builder.rs
@@ -5,7 +5,6 @@ use std::path::PathBuf;
 use std::process;
 
 use std::fs;
-use std::fs::copy;
 use std::io;
 use std::path::Path;
 
@@ -16,12 +15,15 @@ use markdown::Constructs;
 use markdown::Options;
 use markdown::ParseOptions;
 
+use chrono::{DateTime, Local};
+
 #[derive(Debug)]
 #[allow(dead_code)]
 pub enum PostBuildError {
     GeneralIOError(std::io::Error),
     TemplateBuildError(std::io::Error),
     MissingRequiredKey(String),
+    PostFilesMissing,
 }
 
 #[derive(Debug)]
@@ -34,6 +36,14 @@ pub enum SiteBuildError {
     MissingRequiredKey(String),
 }
 
+struct PostInfo {
+    name: String,
+    title: String,
+    description: String,
+    timestamp_display: String,
+    timestamp: i64,
+}
+
 pub fn build_site(source_dir: &PathBuf, output_dir: &PathBuf) -> Result<(), SiteBuildError> {
     match fs::create_dir_all(&output_dir) {
         Ok(_) => (),
@@ -66,14 +76,6 @@ pub fn build_site(source_dir: &PathBuf, output_dir: &PathBuf) -> Result<(), Site
         };
     }
 
-    let site_index = source_dir.join("index.html");
-    if site_index.exists() {
-        match copy(&site_index, &output_dir.join("index.html")) {
-            Ok(_) => (),
-            Err(e) => return Err(SiteBuildError::GeneralIOError(e)),
-        }
-    }
-
     let prelude_path = source_dir.join("prelude.html");
     let prelude = match fs::read_to_string(&prelude_path) {
         Ok(content) => content,
@@ -94,6 +96,9 @@ pub fn build_site(source_dir: &PathBuf, output_dir: &PathBuf) -> Result<(), Site
         Err(e) => return Err(SiteBuildError::GeneralIOError(e)),
     };
 
+    // Impure, but I'm lazy.
+    let mut post_infos: Vec<PostInfo> = Vec::new();
+
     for entry in entries {
         let post_dir = match entry {
             Ok(p) => p.path(),
@@ -102,7 +107,11 @@ pub fn build_site(source_dir: &PathBuf, output_dir: &PathBuf) -> Result<(), Site
 
         if post_dir.is_dir() {
             match process_post(&post_dir, &output_dir, &site_config, &prelude) {
-                Ok(_) => continue,
+                Ok(post) => {
+                    if let Some(post_info) = post {
+                        post_infos.push(post_info);
+                    }
+                }
                 Err(e) => {
                     eprintln!("Failed to build post: {e:?}. Continuing...");
                     continue;
@@ -111,6 +120,27 @@ pub fn build_site(source_dir: &PathBuf, output_dir: &PathBuf) -> Result<(), Site
         }
     }
 
+    // Sort posts by timestamps
+    post_infos.sort_by(|a, b| b.timestamp.cmp(&a.timestamp));
+
+    // Make a simple posts index.
+    // THIS IS DOGSHIT LMAO
+
+    let mut posts_index = String::new();
+    posts_index.push_str("<html><head><title>Posts</title></head><body>");
+    posts_index.push_str("<h1>Posts</h1><ul>");
+    for post in &post_infos {
+        posts_index.push_str(&format!(
+            "<li><a href=\"{}/index.html\">{}</a> - {} - {}</li>",
+            post.name, post.title, post.description, post.timestamp_display
+        ));
+    }
+    posts_index.push_str("</ul></body></html>");
+    match fs::write(output_dir.join("index.html"), posts_index) {
+        Ok(_) => (),
+        Err(e) => return Err(SiteBuildError::GeneralIOError(e)),
+    }
+
     Ok(())
 }
 
@@ -119,12 +149,12 @@ fn process_post(
     output_dir: &Path,
     site_config: &HashMap<String, toml::Value>,
     prelude: &str,
-) -> Result<(), PostBuildError> {
+) -> Result<Option<PostInfo>, PostBuildError> {
     let post_toml_path = post_dir.join("post.toml");
     let content_path = post_dir.join("content.md");
 
     if !post_toml_path.exists() || !content_path.exists() {
-        return Ok(());
+        return Err(PostBuildError::PostFilesMissing);
     }
 
     println!("Processing post: {}", post_dir.display());
@@ -183,6 +213,31 @@ fn process_post(
 
     let post_name = post_dir.file_name().unwrap().to_string_lossy();
     let post_output_dir = output_dir.join(&*post_name);
+
+    // Check if post is built by checking if the target directory has any
+    // timestamps older than any timestamp in the source directory.
+    // If it's older, continue.
+    // If it's newer, return Ok(None).
+    let post_build_timestamp = match fs::metadata(&post_output_dir) {
+        Ok(metadata) => metadata.modified().unwrap(),
+        Err(_) => std::time::SystemTime::UNIX_EPOCH,
+    };
+    let post_source_timestamp = match fs::metadata(&post_dir) {
+        Ok(metadata) => metadata.modified().unwrap(),
+        Err(_) => {
+            return Err(PostBuildError::GeneralIOError(
+                std::io::Error::new(
+                    std::io::ErrorKind::NotFound,
+                    "Failed to get post directory metadata",
+                ), // NOTE: I should migrate to these errors instead of general IO handling whatever
+            ));
+        }
+    };
+
+    if post_source_timestamp < post_build_timestamp {
+        return Ok(None);
+    }
+
     match fs::create_dir_all(&post_output_dir) {
         Ok(_) => (),
         Err(e) => return Err(PostBuildError::GeneralIOError(e)),
@@ -208,13 +263,22 @@ fn process_post(
                     Err(e) => return Err(PostBuildError::GeneralIOError(e)),
                 }
             }
-
             println!("  Built post: {}", post_name);
         }
         Err(e) => return Err(PostBuildError::TemplateBuildError(e)),
     }
 
-    Ok(())
+    let current_local: DateTime<Local> = Local::now();
+    let current_time = current_local.format("%Y-%m-%d %H:%M:%S").to_string();
+
+    Ok(Some(PostInfo {
+        // Unwrapping is fine here bc we error checked earlier
+        name: post_name.to_string(),
+        title: post_config.get("Title").unwrap().to_string(),
+        description: post_config.get("Description").unwrap().to_string(),
+        timestamp_display: current_time,
+        timestamp: current_local.timestamp(),
+    }))
 }
 
 pub fn copy_directory(src: &Path, dst: &Path) -> io::Result<()> {
