133 lines
4.5 KiB
Rust
133 lines
4.5 KiB
Rust
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
|
|
} |