use crate::log_err::LogErr as _;
use std::collections::HashMap;
use std::sync::{Arc, OnceLock};
use axum::http::{header, HeaderMap};
use rustango::i18n::{Locale, Translator};
pub(crate) const UI_LOCALES: &[(&str, &str)] = &[
("en", "English"),
("uk", "Українська"),
("pl", "Polski"),
("fr", "Français"),
("de", "Deutsch"),
("zh-Hans", "中文"),
("ja", "日本語"),
];
pub(crate) const ADMIN_LANG_COOKIE: &str = "rcms_admin_lang";
#[must_use]
pub(crate) fn is_ui_locale(code: &str) -> bool {
UI_LOCALES.iter().any(|(c, _)| *c == code)
}
#[must_use]
pub(crate) fn negotiate(
cookie_header: Option<&str>,
accept_language: Option<&str>,
user_pref: Option<&str>,
tenant_default: Option<&str>,
) -> String {
if let Some(h) = cookie_header {
for part in h.split(';') {
if let Some(v) = part.trim().strip_prefix(&format!("{ADMIN_LANG_COOKIE}=")) {
let v = v.trim();
if is_ui_locale(v) {
return v.to_owned();
}
}
}
}
if let Some(p) = user_pref {
if is_ui_locale(p) {
return p.to_owned();
}
}
if let Some(al) = accept_language {
for tag in al.split(',') {
let code = tag.split(';').next().unwrap_or("").trim();
if code.is_empty() {
continue;
}
if is_ui_locale(code) {
return code.to_owned();
}
let base = code.split('-').next().unwrap_or("").to_lowercase();
if base == "zh" {
return "zh-Hans".to_owned();
}
if let Some((c, _)) = UI_LOCALES.iter().find(|(c, _)| *c == base) {
return (*c).to_owned();
}
}
}
if let Some(t) = tenant_default {
if is_ui_locale(t) {
return t.to_owned();
}
}
"en".to_owned()
}
#[must_use]
pub(crate) fn tenant_default_locale() -> Option<String> {
static DEFAULT: std::sync::OnceLock<Option<String>> = std::sync::OnceLock::new();
DEFAULT
.get_or_init(|| {
crate::config::var("DEFAULT_ADMIN_LOCALE")
.map(|s| s.trim().to_owned())
.filter(|s| is_ui_locale(s))
})
.clone()
}
fn parse(json: &str) -> HashMap<String, String> {
serde_json::from_str(json).unwrap_or_default()
}
fn parse_plural(json: &str) -> HashMap<String, HashMap<String, String>> {
serde_json::from_str(json).unwrap_or_default()
}
fn catalog_json(code: &str) -> &'static str {
match code {
"en" => include_str!("locales/en.json"),
"uk" => include_str!("locales/uk.json"),
"pl" => include_str!("locales/pl.json"),
"fr" => include_str!("locales/fr.json"),
"de" => include_str!("locales/de.json"),
"zh-Hans" => include_str!("locales/zh-Hans.json"),
"ja" => include_str!("locales/ja.json"),
_ => "{}",
}
}
fn plural_catalog_json(code: &str) -> &'static str {
match code {
"en" => include_str!("locales/en.plurals.json"),
"uk" => include_str!("locales/uk.plurals.json"),
"pl" => include_str!("locales/pl.plurals.json"),
"fr" => include_str!("locales/fr.plurals.json"),
"de" => include_str!("locales/de.plurals.json"),
"zh-Hans" => include_str!("locales/zh-Hans.plurals.json"),
"ja" => include_str!("locales/ja.plurals.json"),
_ => "{}",
}
}
#[cfg(test)]
#[must_use]
pub(crate) fn launch_locales() -> Vec<&'static str> {
UI_LOCALES
.iter()
.map(|(c, _)| *c)
.filter(|c| *c != "en")
.collect()
}
pub(crate) fn admin_translator() -> Arc<Translator> {
let mut t = Translator::new(Locale::new("en")).with_fallback_chain(&["en"]);
for (code, _) in UI_LOCALES {
t = t.add_locale(Locale::new(*code), parse(catalog_json(code)));
t = t.add_plural_locale(Locale::new(*code), parse_plural(plural_catalog_json(code)));
}
Arc::new(t)
}
pub(crate) fn cached_translator() -> &'static Arc<Translator> {
static T: OnceLock<Arc<Translator>> = OnceLock::new();
T.get_or_init(admin_translator)
}
pub fn extend_ui_catalog(extra: HashMap<String, HashMap<String, String>>) {
let tr = cached_translator();
for (code, entries) in extra {
let mut merged = entries;
merged.extend(parse(catalog_json(&code)));
tr.insert_locale(Locale::new(&code), merged);
}
}
pub(crate) async fn maybe_refresh_overrides(pool: &rustango::sql::Pool) {
use std::time::{Duration, Instant};
const REFRESH_TTL: Duration = Duration::from_secs(10);
static LAST: OnceLock<std::sync::Mutex<Option<Instant>>> = OnceLock::new();
let slot = LAST.get_or_init(|| std::sync::Mutex::new(None));
{
let mut guard = slot.lock().expect("override-refresh clock poisoned");
if matches!(*guard, Some(t) if t.elapsed() < REFRESH_TTL) {
return;
}
*guard = Some(Instant::now());
}
rustango::i18n::db::refresh_overrides_pool(cached_translator(), pool)
.await
.log_warn("admin translation overrides not refreshed");
}
#[must_use]
pub(crate) fn tr(headers: &HeaderMap, source: &str, params: &[(&str, &str)]) -> String {
let lang = negotiate(
headers.get(header::COOKIE).and_then(|v| v.to_str().ok()),
headers
.get(header::ACCEPT_LANGUAGE)
.and_then(|v| v.to_str().ok()),
None,
tenant_default_locale().as_deref(),
);
cached_translator().translate(&lang, source, params)
}
#[must_use]
pub(crate) fn tr_plural(headers: &HeaderMap, key: &str, n: i64, params: &[(&str, &str)]) -> String {
let lang = negotiate(
headers.get(header::COOKIE).and_then(|v| v.to_str().ok()),
headers
.get(header::ACCEPT_LANGUAGE)
.and_then(|v| v.to_str().ok()),
None,
tenant_default_locale().as_deref(),
);
cached_translator().translate_plural(&lang, key, n, params)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn translates_known_key_and_falls_back_to_source() {
let t = admin_translator();
assert_eq!(t.translate("fr", "Forms", &[]), "Formulaires");
assert_eq!(t.translate("de", "Pages", &[]), "Seiten");
assert_eq!(
t.translate("fr", "Totally Untranslated", &[]),
"Totally Untranslated"
);
assert_eq!(t.translate("en", "Pages", &[]), "Pages");
}
#[test]
fn negotiate_precedence() {
assert_eq!(
negotiate(
Some("a=1; rcms_admin_lang=fr; b=2"),
Some("de"),
Some("pl"),
Some("ja")
),
"fr"
);
assert_eq!(negotiate(None, Some("de"), Some("pl"), Some("ja")), "pl");
assert_eq!(
negotiate(
Some("rcms_admin_lang=ru"),
Some("de,en;q=0.9"),
Some("xx"),
None
),
"de"
);
assert_eq!(negotiate(None, Some("fr-FR,fr;q=0.9"), None, None), "fr");
assert_eq!(negotiate(None, Some("zh-CN"), None, None), "zh-Hans");
assert_eq!(negotiate(None, Some("ru,es"), None, Some("de")), "de");
assert_eq!(negotiate(None, Some("ru,es"), Some("xx"), Some("xx")), "en");
assert_eq!(negotiate(None, None, None, None), "en");
}
fn extract_template_keys() -> std::collections::BTreeSet<String> {
let root =
std::path::PathBuf::from(concat!(env!("CARGO_MANIFEST_DIR"), "/src/admin/templates"));
let filter_re = regex::Regex::new(r#""([^"\n]*)"\s*\|\s*translate\b"#).unwrap();
let fn_re = regex::Regex::new(r#"translate\(\s*key\s*=\s*"([^"\n]*)""#).unwrap();
let mut keys = std::collections::BTreeSet::new();
let mut stack = vec![root];
while let Some(dir) = stack.pop() {
for entry in std::fs::read_dir(&dir).expect("read templates dir") {
let path = entry.expect("dir entry").path();
if path.is_dir() {
stack.push(path);
continue;
}
if path.extension().and_then(|e| e.to_str()) != Some("html") {
continue;
}
let src = std::fs::read_to_string(&path).expect("read template");
for cap in filter_re.captures_iter(&src) {
keys.insert(cap[1].to_string());
}
for cap in fn_re.captures_iter(&src) {
keys.insert(cap[1].to_string());
}
}
}
keys
}
#[test]
fn catalogs_parse_with_no_empty_values() {
for (code, _) in UI_LOCALES {
let map = parse(catalog_json(code));
for (k, v) in &map {
assert!(
!v.trim().is_empty(),
"[{code}] key {k:?} maps to an empty string"
);
}
}
}
#[test]
fn launch_catalogs_cover_every_template_key() {
let keys = extract_template_keys();
assert!(
keys.len() > 50,
"expected the admin templates to use many translate() keys, found {} — extraction likely broken",
keys.len()
);
let mut gaps: Vec<String> = Vec::new();
for code in launch_locales() {
let map = parse(catalog_json(code));
for k in &keys {
if map.get(k).map(|v| v.trim().is_empty()).unwrap_or(true) {
gaps.push(format!("[{code}] {k:?}"));
}
}
}
assert!(
gaps.is_empty(),
"{} untranslated admin string(s) across launch locales:\n{}",
gaps.len(),
gaps.join("\n")
);
}
#[test]
fn all_admin_templates_parse() {
let mut tera = tera::Tera::default();
crate::admin::register_templates(&mut tera)
.expect("admin templates parse + inheritance resolves");
}
#[test]
fn unknown_key_falls_back_to_source_in_every_locale() {
let t = admin_translator();
for (code, _) in UI_LOCALES {
assert_eq!(
t.translate(code, "A Definitely Untranslated String", &[]),
"A Definitely Untranslated String"
);
}
}
#[test]
fn plural_catalogs_cover_every_key_in_all_locales() {
let en = parse_plural(plural_catalog_json("en"));
assert!(!en.is_empty(), "en.plurals.json is empty");
for (code, _) in UI_LOCALES {
let cat = parse_plural(plural_catalog_json(code));
for key in en.keys() {
let forms = cat
.get(key)
.unwrap_or_else(|| panic!("[{code}] missing plural key {key:?}"));
assert!(!forms.is_empty(), "[{code}] no forms for {key:?}");
for (form, v) in forms {
assert!(
!v.trim().is_empty(),
"[{code}] blank {form} form for {key:?}"
);
}
}
}
}
#[test]
fn plural_flash_selects_form() {
let t = admin_translator();
let key = "Deleted {count} page(s).";
let tr =
|code: &str, n: i64| t.translate_plural(code, key, n, &[("count", &n.to_string())]);
assert_eq!(tr("en", 1), "Deleted 1 page.");
assert_eq!(tr("en", 3), "Deleted 3 pages.");
assert_eq!(tr("pl", 1), "Usunięto 1 stronę.");
assert_eq!(tr("pl", 2), "Usunięto 2 strony.");
assert_eq!(tr("pl", 5), "Usunięto 5 stron.");
}
#[test]
fn report_metadata_covered_in_all_launch_locales() {
use crate::admin::report::registered_reports;
let mut keys: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
for r in registered_reports() {
keys.insert(r.title().to_string());
if let Some(d) = r.description() {
keys.insert(d.to_string());
}
for col in r.columns() {
keys.insert(col.label.to_string());
}
}
assert!(
!keys.is_empty(),
"no report metadata found — registry empty?"
);
let mut gaps: Vec<String> = Vec::new();
for code in launch_locales() {
let map = parse(catalog_json(code));
for k in &keys {
if map.get(k).map(|v| v.trim().is_empty()).unwrap_or(true) {
gaps.push(format!("[{code}] {k:?}"));
}
}
}
assert!(
gaps.is_empty(),
"{} untranslated report-metadata string(s) across launch locales:\n{}",
gaps.len(),
gaps.join("\n")
);
}
}