use std::collections::BTreeSet;
use unic_langid::LanguageIdentifier;
use crate::common::error::CrawlRsError;
use super::catalog;
pub type Locale = LanguageIdentifier;
pub struct I18nBundle {
default_locale: Locale,
supported_locales: Vec<Locale>,
}
impl I18nBundle {
pub fn load(default_locale: &str, supported: &[&str]) -> Result<Self, CrawlRsError> {
catalog::register_all();
let default_locale: Locale = default_locale
.parse()
.map_err(|e| CrawlRsError::Config(format!("Invalid default locale: {e}")))?;
let supported_locales: Vec<Locale> = supported
.iter()
.map(|s| {
s.parse().map_err(|e| {
CrawlRsError::Config(format!("Invalid supported locale '{s}': {e}"))
})
})
.collect::<Result<Vec<_>, _>>()?;
for locale in &supported_locales {
if catalog::sources_for(&locale.to_string()).is_none() {
return Err(CrawlRsError::Config(format!(
"No embedded message catalog for supported locale '{locale}' \
(only en-US/zh-CN are built in)"
)));
}
}
Ok(Self {
default_locale,
supported_locales,
})
}
pub fn translate(&self, locale: &Locale, key: &str) -> String {
self.translate_inner(&locale.to_string(), key, &[])
}
pub fn translate_with_args(
&self,
locale: &Locale,
key: &str,
args: &[(&str, String)],
) -> String {
self.translate_inner(&locale.to_string(), key, args)
}
fn translate_inner(&self, locale: &str, key: &str, args: &[(&str, String)]) -> String {
let primary = sdforge::i18n::translate_for(locale, key, args);
if primary != key {
return primary;
}
if self.default_locale != locale {
let fallback =
sdforge::i18n::translate_for(&self.default_locale.to_string(), key, args);
if fallback != key {
return fallback;
}
}
log::warn!("Translation key '{key}' not found for locale '{locale}'");
key.to_string()
}
pub fn default_locale(&self) -> &Locale {
&self.default_locale
}
pub fn supported_locales(&self) -> &[Locale] {
&self.supported_locales
}
pub fn validate_key_consistency(&self) -> Vec<String> {
let mut warnings = Vec::new();
let default_str = self.default_locale.to_string();
let default_keys = self.keys_for(&default_str);
for locale in &self.supported_locales {
let locale_str = locale.to_string();
if locale_str == default_str {
continue;
}
warnings.extend(self.diff_locale_keys(&locale_str, &default_keys));
}
warnings
}
fn keys_for(&self, locale: &str) -> BTreeSet<String> {
catalog::sources_for(locale)
.map(|sources| {
sources
.iter()
.flat_map(|s| catalog::parse_entries(s))
.map(|(k, _)| k.to_string())
.collect()
})
.unwrap_or_default()
}
fn placeholders_for(&self, locale: &str) -> Vec<(String, BTreeSet<&'static str>)> {
catalog::sources_for(locale)
.map(|sources| {
sources
.iter()
.flat_map(|s| catalog::parse_entries(s))
.map(|(k, v)| (k.to_string(), catalog::placeholders(v)))
.collect()
})
.unwrap_or_default()
}
fn diff_locale_keys(&self, locale: &str, default_keys: &BTreeSet<String>) -> Vec<String> {
let mut warnings = Vec::new();
let locale_keys = self.keys_for(locale);
for key in default_keys {
if !locale_keys.contains(key) {
warnings.push(format!(
"Locale '{locale}' missing key '{key}' (present in default '{}')",
self.default_locale
));
}
}
for key in &locale_keys {
if !default_keys.contains(key) {
warnings.push(format!(
"Locale '{locale}' has extra key '{key}' (not in default '{}')",
self.default_locale
));
}
}
let default_placeholders: std::collections::BTreeMap<String, BTreeSet<&str>> = self
.placeholders_for(&self.default_locale.to_string())
.into_iter()
.collect();
for (key, vars) in self.placeholders_for(locale) {
if let Some(default_vars) = default_placeholders.get(&key) {
if vars != *default_vars {
warnings.push(format!(
"Locale '{locale}' key '{key}' placeholders {vars:?} differ from \
default '{default_vars:?}'"
));
}
}
}
warnings
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_load_bundle() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
assert_eq!(bundle.default_locale().to_string(), "en-US");
assert_eq!(bundle.supported_locales().len(), 2);
}
#[test]
fn test_load_unsupported_locale_returns_error() {
let result = I18nBundle::load("en-US", &["en-US", "fr-FR"]);
assert!(result.is_err(), "unsupported locale must be rejected");
}
#[test]
fn test_load_invalid_locale_string_returns_error() {
let result = I18nBundle::load("not a locale!!", &["en-US"]);
assert!(result.is_err());
}
#[test]
fn test_translate_no_args() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
let locale: Locale = "en-US".parse().unwrap();
let msg = bundle.translate(&locale, "error-database");
assert_eq!(msg, "Database operation failed. Please try again later.");
let msg = bundle.translate(&locale, "error-permission");
assert_eq!(msg, "Permission denied.");
}
#[test]
fn test_translate_zh_cn() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
let locale: Locale = "zh-CN".parse().unwrap();
let msg = bundle.translate(&locale, "error-database");
assert_eq!(msg, "数据库操作失败,请稍后重试。");
}
#[test]
fn test_translate_with_args() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
let locale: Locale = "en-US".parse().unwrap();
let msg = bundle.translate_with_args(
&locale,
"error-validation",
&[("message", "invalid email".to_string())],
);
assert_eq!(msg, "Validation error: invalid email");
}
#[test]
fn test_translate_with_args_zh_cn() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
let locale: Locale = "zh-CN".parse().unwrap();
let msg = bundle.translate_with_args(
&locale,
"error-validation",
&[("message", "无效邮箱".to_string())],
);
assert!(msg.contains("无效邮箱"), "got: {msg}");
}
#[test]
fn test_fallback_to_default_locale() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
let unknown_locale: Locale = "fr-FR".parse().unwrap();
let msg = bundle.translate(&unknown_locale, "error-database");
assert_eq!(msg, "Database operation failed. Please try again later.");
}
#[test]
fn test_missing_key_returns_key() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
let locale: Locale = "en-US".parse().unwrap();
let msg = bundle.translate(&locale, "nonexistent-key");
assert_eq!(msg, "nonexistent-key");
}
#[test]
fn test_validate_key_consistency() {
let bundle = I18nBundle::load("en-US", &["en-US", "zh-CN"]).unwrap();
let warnings = bundle.validate_key_consistency();
assert!(
warnings.is_empty(),
"Key consistency warnings: {warnings:?}"
);
}
}