263 lines
9.2 KiB
Rust
263 lines
9.2 KiB
Rust
//! Translation validation — checks DB rows and filesystem files for issues.
|
|
|
|
use std::path::Path;
|
|
|
|
use rusqlite::Connection;
|
|
|
|
use crate::db::queries::{post as post_q, post_translation};
|
|
use crate::engine::EngineResult;
|
|
use crate::model::PostStatus;
|
|
|
|
/// Normalize a language code for comparison (lowercase, strip region).
|
|
fn norm_lang(code: &str) -> String {
|
|
code.split(['-', '_']).next().unwrap_or("").to_lowercase()
|
|
}
|
|
|
|
/// Check if a file stem looks like a translation (e.g. "slug.de").
|
|
fn is_translation_stem(stem: &str) -> bool {
|
|
if let Some(dot_pos) = stem.rfind('.') {
|
|
let suffix = &stem[dot_pos + 1..];
|
|
suffix.len() == 2 && suffix.chars().all(|c| c.is_ascii_lowercase())
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
/// A single validation issue.
|
|
#[derive(Debug, Clone)]
|
|
pub struct TranslationIssue {
|
|
pub post_id: String,
|
|
pub translation_id: Option<String>,
|
|
pub file_path: Option<String>,
|
|
pub language: String,
|
|
pub kind: TranslationIssueKind,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum TranslationIssueKind {
|
|
MissingSourcePost,
|
|
SameLanguageAsCanonical,
|
|
DoNotTranslateHasTranslations,
|
|
ContentInDatabase,
|
|
/// Published post is missing a translation for a configured blog language.
|
|
MissingTranslation,
|
|
}
|
|
|
|
/// Result of translation validation.
|
|
#[derive(Debug)]
|
|
pub struct TranslationValidationReport {
|
|
pub db_issues: Vec<TranslationIssue>,
|
|
pub fs_issues: Vec<TranslationIssue>,
|
|
pub checked_db_rows: usize,
|
|
pub checked_fs_files: usize,
|
|
}
|
|
|
|
/// Per-item progress callback: (current_item, total_items, item_description).
|
|
pub type ItemProgressFn = Box<dyn Fn(usize, usize, &str) + Send>;
|
|
|
|
/// Validate all translations in a project against consistency rules.
|
|
pub fn validate_translations(
|
|
conn: &Connection,
|
|
data_dir: &Path,
|
|
project_id: &str,
|
|
blog_languages: &[String],
|
|
main_language: &str,
|
|
) -> EngineResult<TranslationValidationReport> {
|
|
validate_translations_with_progress(
|
|
conn,
|
|
data_dir,
|
|
project_id,
|
|
blog_languages,
|
|
main_language,
|
|
None,
|
|
)
|
|
}
|
|
|
|
/// Like `validate_translations` but with optional per-item progress.
|
|
pub fn validate_translations_with_progress(
|
|
conn: &Connection,
|
|
data_dir: &Path,
|
|
project_id: &str,
|
|
blog_languages: &[String],
|
|
main_language: &str,
|
|
on_item: Option<ItemProgressFn>,
|
|
) -> EngineResult<TranslationValidationReport> {
|
|
let posts = post_q::list_posts_by_project(conn, project_id)?;
|
|
|
|
let post_map: std::collections::HashMap<String, &crate::model::Post> =
|
|
posts.iter().map(|p| (p.id.clone(), p)).collect();
|
|
|
|
// Phase 1: database validation
|
|
let mut db_issues = Vec::new();
|
|
let mut checked_db_rows = 0usize;
|
|
let post_count = posts.len();
|
|
|
|
for (i, post) in posts.iter().enumerate() {
|
|
if let Some(ref cb) = on_item {
|
|
cb(i + 1, post_count, &post.title);
|
|
}
|
|
let translations = post_translation::list_post_translations_by_post(conn, &post.id)?;
|
|
|
|
for t in &translations {
|
|
checked_db_rows += 1;
|
|
|
|
// Check: translation language != canonical language
|
|
let post_lang = post.language.as_deref().unwrap_or("en");
|
|
if norm_lang(post_lang) == norm_lang(&t.language) {
|
|
db_issues.push(TranslationIssue {
|
|
post_id: post.id.clone(),
|
|
translation_id: Some(t.id.clone()),
|
|
file_path: Some(t.file_path.clone()),
|
|
language: t.language.clone(),
|
|
kind: TranslationIssueKind::SameLanguageAsCanonical,
|
|
});
|
|
}
|
|
|
|
// Check: do_not_translate
|
|
if post.do_not_translate {
|
|
db_issues.push(TranslationIssue {
|
|
post_id: post.id.clone(),
|
|
translation_id: Some(t.id.clone()),
|
|
file_path: Some(t.file_path.clone()),
|
|
language: t.language.clone(),
|
|
kind: TranslationIssueKind::DoNotTranslateHasTranslations,
|
|
});
|
|
}
|
|
|
|
// Check: published translation should not have content in DB
|
|
if t.status == PostStatus::Published && t.content.is_some() {
|
|
db_issues.push(TranslationIssue {
|
|
post_id: post.id.clone(),
|
|
translation_id: Some(t.id.clone()),
|
|
file_path: Some(t.file_path.clone()),
|
|
language: t.language.clone(),
|
|
kind: TranslationIssueKind::ContentInDatabase,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Check: published, translatable posts must have translations
|
|
// for each configured blog language (spec: ValidateTranslations rule)
|
|
if post.status == PostStatus::Published && !post.do_not_translate {
|
|
let available: std::collections::HashSet<String> = translations
|
|
.iter()
|
|
.map(|t| norm_lang(&t.language))
|
|
.collect();
|
|
let post_lang = norm_lang(post.language.as_deref().unwrap_or(main_language));
|
|
let main_norm = norm_lang(main_language);
|
|
|
|
for lang in blog_languages {
|
|
let lang_norm = norm_lang(lang);
|
|
if lang_norm == main_norm || lang_norm == post_lang {
|
|
continue;
|
|
}
|
|
if !available.contains(&lang_norm) {
|
|
db_issues.push(TranslationIssue {
|
|
post_id: post.id.clone(),
|
|
translation_id: None,
|
|
file_path: None,
|
|
language: lang.clone(),
|
|
kind: TranslationIssueKind::MissingTranslation,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Phase 2: filesystem validation
|
|
let mut fs_issues = Vec::new();
|
|
let mut checked_fs_files = 0usize;
|
|
|
|
let posts_dir = data_dir.join("posts");
|
|
if posts_dir.exists() {
|
|
// Collect translation files first so we know the total
|
|
let translation_files: Vec<_> = walkdir::WalkDir::new(&posts_dir)
|
|
.into_iter()
|
|
.filter_map(|e| e.ok())
|
|
.filter(|e| e.file_type().is_file())
|
|
.filter(|e| e.path().extension().is_some_and(|ext| ext == "md"))
|
|
.filter(|e| {
|
|
let stem = e.path().file_stem().and_then(|s| s.to_str()).unwrap_or("");
|
|
is_translation_stem(stem)
|
|
})
|
|
.collect();
|
|
|
|
let fs_total = translation_files.len();
|
|
|
|
for (i, entry) in translation_files.iter().enumerate() {
|
|
let path = entry.path();
|
|
let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
|
|
|
|
if let Some(ref cb) = on_item {
|
|
cb(i + 1, fs_total, stem);
|
|
}
|
|
|
|
checked_fs_files += 1;
|
|
|
|
// Parse frontmatter to check translation_for
|
|
let content = match std::fs::read_to_string(path) {
|
|
Ok(c) => c,
|
|
Err(_) => continue,
|
|
};
|
|
|
|
let Some((yaml_str, _body)) = crate::util::frontmatter::split_frontmatter(&content)
|
|
else {
|
|
continue;
|
|
};
|
|
|
|
let Ok(fm) = crate::util::frontmatter::TranslationFrontmatter::from_yaml(yaml_str)
|
|
else {
|
|
continue;
|
|
};
|
|
|
|
let translation_for = &fm.translation_for;
|
|
let language = &fm.language;
|
|
|
|
if translation_for.is_empty() {
|
|
continue;
|
|
}
|
|
|
|
// Check source post exists
|
|
if !post_map.contains_key(translation_for.as_str()) {
|
|
fs_issues.push(TranslationIssue {
|
|
post_id: translation_for.clone(),
|
|
translation_id: None,
|
|
file_path: Some(path.to_string_lossy().to_string()),
|
|
language: language.clone(),
|
|
kind: TranslationIssueKind::MissingSourcePost,
|
|
});
|
|
} else if let Some(source) = post_map.get(translation_for.as_str()) {
|
|
// Check same language
|
|
let post_lang = source.language.as_deref().unwrap_or("en");
|
|
if norm_lang(post_lang) == norm_lang(language) {
|
|
fs_issues.push(TranslationIssue {
|
|
post_id: translation_for.clone(),
|
|
translation_id: None,
|
|
file_path: Some(path.to_string_lossy().to_string()),
|
|
language: language.clone(),
|
|
kind: TranslationIssueKind::SameLanguageAsCanonical,
|
|
});
|
|
}
|
|
|
|
// Check do_not_translate
|
|
if source.do_not_translate {
|
|
fs_issues.push(TranslationIssue {
|
|
post_id: translation_for.clone(),
|
|
translation_id: None,
|
|
file_path: Some(path.to_string_lossy().to_string()),
|
|
language: language.clone(),
|
|
kind: TranslationIssueKind::DoNotTranslateHasTranslations,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(TranslationValidationReport {
|
|
db_issues,
|
|
fs_issues,
|
|
checked_db_rows,
|
|
checked_fs_files,
|
|
})
|
|
}
|