feat: more filling out of M4

crates/bds-core/src/engine/validate_site.rs

@@ -0,0 +1,133 @@
+use std::collections::HashSet;
+use std::path::Path;
+
+use rusqlite::Connection;
+use walkdir::WalkDir;
+
+use crate::db::queries;
+use crate::engine::{EngineError, EngineResult};
+use crate::model::{Post, PostStatus};
+use crate::render::build_site_render_artifacts;
+use crate::util::file_hash;
+
+#[derive(Debug, Clone, Default)]
+pub struct SiteValidationReport {
+    pub missing_pages: Vec<String>,
+    pub extra_pages: Vec<String>,
+    pub stale_pages: Vec<String>,
+}
+
+pub fn validate_site(
+    conn: &Connection,
+    data_dir: &Path,
+    project_id: &str,
+) -> EngineResult<SiteValidationReport> {
+    let metadata = crate::engine::meta::read_project_json(data_dir)?;
+    let output_dir = data_dir.to_path_buf();
+    let published_posts = load_published_posts(data_dir, conn, project_id)?;
+    let artifacts = build_site_render_artifacts(conn, data_dir, project_id, &metadata, &published_posts)
+        .map_err(|error| EngineError::Parse(error.to_string()))?;
+
+    let mut expected = artifacts
+        .pages
+        .iter()
+        .map(|page| page.relative_path.clone())
+        .collect::<HashSet<_>>();
+    expected.insert("calendar.json".to_string());
+    expected.insert("rss.xml".to_string());
+    for language in render_languages(&metadata) {
+        let prefix = if language == metadata.main_language.clone().unwrap_or_else(|| "en".to_string()) {
+            String::new()
+        } else {
+            format!("{language}/")
+        };
+        expected.insert(format!("{prefix}feed.xml"));
+        expected.insert(format!("{prefix}atom.xml"));
+        expected.insert(format!("{prefix}sitemap.xml"));
+    }
+
+    let mut actual = HashSet::new();
+    if output_dir.exists() {
+        for entry in WalkDir::new(&output_dir).into_iter().filter_map(Result::ok) {
+            if !entry.file_type().is_file() {
+                continue;
+            }
+            let rel = entry
+                .path()
+                .strip_prefix(&output_dir)
+                .unwrap_or(entry.path())
+                .to_string_lossy()
+                .replace('\\', "/");
+            if rel.starts_with("meta/")
+                || rel.starts_with("posts/")
+                || rel.starts_with("media/")
+                || rel.starts_with("assets/")
+            {
+                continue;
+            }
+            if rel.starts_with("pagefind") || rel.contains("/pagefind/") {
+                continue;
+            }
+            if rel.ends_with(".html") || rel.ends_with(".xml") || rel.ends_with(".json") {
+                actual.insert(rel);
+            }
+        }
+    }
+
+    let mut missing_pages = expected.difference(&actual).cloned().collect::<Vec<_>>();
+    let mut extra_pages = actual.difference(&expected).cloned().collect::<Vec<_>>();
+
+    let mut stale_pages = Vec::new();
+    for rel in expected.intersection(&actual) {
+        if let Ok(stored) = queries::generated_file_hash::get_generated_file_hash(conn, project_id, rel) {
+            let actual_hash = file_hash(&output_dir.join(rel))?;
+            if actual_hash != stored.content_hash {
+                stale_pages.push(rel.clone());
+            }
+        }
+    }
+
+    missing_pages.sort();
+    extra_pages.sort();
+    stale_pages.sort();
+
+    Ok(SiteValidationReport {
+        missing_pages,
+        extra_pages,
+        stale_pages,
+    })
+}
+
+fn load_published_posts(
+    data_dir: &Path,
+    conn: &Connection,
+    project_id: &str,
+) -> EngineResult<Vec<(Post, String)>> {
+    let posts = queries::post::list_posts_by_project(conn, project_id)?;
+    let mut published = Vec::new();
+    for post in posts.into_iter().filter(|post| post.status == PostStatus::Published) {
+        let body = if let Some(content) = &post.content {
+            content.clone()
+        } else if let Some(content) = &post.published_content {
+            content.clone()
+        } else {
+            let raw = std::fs::read_to_string(data_dir.join(post.file_path.trim_start_matches('/')))?;
+            crate::util::frontmatter::read_post_file(&raw)
+                .map(|(_, body)| body)
+                .map_err(EngineError::Parse)?
+        };
+        published.push((post, body));
+    }
+    Ok(published)
+}
+
+fn render_languages(metadata: &crate::model::ProjectMetadata) -> Vec<String> {
+    let main = metadata.main_language.clone().unwrap_or_else(|| "en".to_string());
+    let mut languages = vec![main.clone()];
+    for language in &metadata.blog_languages {
+        if !languages.iter().any(|existing| existing.eq_ignore_ascii_case(language)) {
+            languages.push(language.clone());
+        }
+    }
+    languages
+}