use std::collections::HashMap;
use std::sync::Arc;
#[derive(Clone, Debug)]
pub struct TranslationSystem {
current_language: String,
translations: HashMap<String, HashMap<String, String>>,
fallback_language: String,
direct_translations: Option<Arc<HashMap<String, String>>>,
}
impl TranslationSystem {
pub fn new() -> Self {
Self {
current_language: "en".to_string(),
translations: HashMap::new(),
fallback_language: "en".to_string(),
direct_translations: None,
}
}
pub fn from_view_translations(translations: Arc<HashMap<String, String>>) -> Self {
Self {
current_language: "current".to_string(),
translations: HashMap::new(),
fallback_language: "current".to_string(),
direct_translations: Some(translations),
}
}
pub fn set_language(&mut self, language: &str) {
self.current_language = language.to_string();
}
pub fn set_fallback(&mut self, language: &str) {
self.fallback_language = language.to_string();
}
pub fn add_translations(&mut self, language: &str, translations: HashMap<String, String>) {
self.translations.insert(language.to_string(), translations);
}
pub fn load_from_json(&mut self, language: &str, json: &serde_json::Value) {
if let serde_json::Value::Object(map) = json {
let mut translations = HashMap::new();
for (key, value) in map {
if let serde_json::Value::String(text) = value {
translations.insert(key.clone(), text.clone());
}
}
self.add_translations(language, translations);
}
}
pub fn translate_key(&self, key: &str) -> String {
if let Some(translations) = &self.direct_translations {
return translations
.get(key)
.cloned()
.unwrap_or_else(|| format!("[{}]", key));
}
if let Some(lang_translations) = self.translations.get(&self.current_language) {
if let Some(translation) = lang_translations.get(key) {
return translation.clone();
}
}
if self.fallback_language != self.current_language {
if let Some(lang_translations) = self.translations.get(&self.fallback_language) {
if let Some(translation) = lang_translations.get(key) {
return translation.clone();
}
}
}
format!("[{}]", key)
}
pub fn translate_text(&self, text: &str) -> String {
if let Some(translations) = &self.direct_translations {
return translations
.get(text)
.cloned()
.unwrap_or_else(|| text.to_string());
}
if let Some(lang_translations) = self.translations.get(&self.current_language) {
for (key, translation) in lang_translations {
if key == text {
return translation.clone();
}
}
}
if self.fallback_language != self.current_language {
if let Some(lang_translations) = self.translations.get(&self.fallback_language) {
for (key, translation) in lang_translations {
if key == text {
return translation.clone();
}
}
}
}
text.to_string()
}
pub fn has_language(&self, language: &str) -> bool {
self.translations.contains_key(language)
}
pub fn available_languages(&self) -> Vec<String> {
self.translations.keys().cloned().collect()
}
}
impl Default for TranslationSystem {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::json;
#[test]
fn test_translation_key() {
let mut translator = TranslationSystem::new();
let mut en_translations = HashMap::new();
en_translations.insert("welcome.message".to_string(), "Welcome!".to_string());
en_translations.insert("goodbye".to_string(), "Goodbye!".to_string());
translator.add_translations("en", en_translations);
let mut fr_translations = HashMap::new();
fr_translations.insert("welcome.message".to_string(), "Bienvenue!".to_string());
fr_translations.insert("goodbye".to_string(), "Au revoir!".to_string());
translator.add_translations("fr", fr_translations);
translator.set_language("en");
assert_eq!(translator.translate_key("welcome.message"), "Welcome!");
assert_eq!(translator.translate_key("goodbye"), "Goodbye!");
translator.set_language("fr");
assert_eq!(translator.translate_key("welcome.message"), "Bienvenue!");
assert_eq!(translator.translate_key("goodbye"), "Au revoir!");
assert_eq!(translator.translate_key("missing.key"), "[missing.key]");
}
#[test]
fn test_fallback_language() {
let mut translator = TranslationSystem::new();
translator.set_fallback("en");
let mut en_translations = HashMap::new();
en_translations.insert("only_in_english".to_string(), "English only".to_string());
translator.add_translations("en", en_translations);
translator.set_language("fr");
assert_eq!(translator.translate_key("only_in_english"), "English only");
}
#[test]
fn test_load_from_json() {
let mut translator = TranslationSystem::new();
let json = json!({
"hello": "Hello",
"world": "World",
"app.name": "My App"
});
translator.load_from_json("en", &json);
translator.set_language("en");
assert_eq!(translator.translate_key("hello"), "Hello");
assert_eq!(translator.translate_key("world"), "World");
assert_eq!(translator.translate_key("app.name"), "My App");
}
}