use ::std::sync::OnceLock;
pub use ::fluent_bundle::FluentValue;
use ::fluent_bundle::concurrent::FluentBundle;
use ::fluent_bundle::{FluentArgs, FluentResource};
use ::fluent_langneg::{NegotiationStrategy, negotiate_languages};
use ::unic_langid::LanguageIdentifier;
pub const FALLBACK: &str = "en";
pub const LOCALES: [(&str, &str); 8] = [
("en", include_str!("../i18n/en.ftl")),
("de", include_str!("../i18n/de.ftl")),
("es", include_str!("../i18n/es.ftl")),
("fr", include_str!("../i18n/fr.ftl")),
("ru", include_str!("../i18n/ru.ftl")),
("lt", include_str!("../i18n/lt.ftl")),
("ja", include_str!("../i18n/ja.ftl")),
("zh-Hans", include_str!("../i18n/zh-Hans.ftl")),
];
struct Texts {
bundles: Vec<FluentBundle<FluentResource>>,
}
static TEXTS: OnceLock<Texts> = OnceLock::new();
pub fn bundle(language: &str, ftl: &str) -> Result<FluentBundle<FluentResource>, String> {
let id: LanguageIdentifier = language
.parse()
.map_err(|err| format!("{language}: {err}"))?;
let resource = FluentResource::try_new(ftl.to_owned())
.map_err(|(_, errors)| format!("{language}: {errors:?}"))?;
let mut bundle = FluentBundle::new_concurrent(vec![id]);
bundle.set_use_isolating(false);
bundle
.add_resource(resource)
.map_err(|errors| format!("{language}: {errors:?}"))?;
Ok(bundle)
}
pub fn requested(var: impl Fn(&str) -> Option<String>) -> Vec<String> {
let locale = ["LC_ALL", "LC_MESSAGES", "LANG"]
.into_iter()
.find_map(|name| var(name).filter(|value| !value.is_empty()));
let mut languages = Vec::new();
if locale.as_deref().is_none_or(|locale| !is_c(locale))
&& let Some(list) = var("LANGUAGE")
{
languages.extend(list.split(':').map(str::to_owned));
}
languages.extend(locale);
languages
.into_iter()
.filter(|language| !language.is_empty() && !is_c(language))
.map(|language| {
let language = language.split(['.', '@']).next().unwrap_or_default();
language.replace('_', "-")
})
.collect()
}
fn is_c(locale: &str) -> bool {
matches!(locale.split('.').next(), Some("C" | "POSIX"))
}
pub fn negotiate(requested: &[String]) -> &'static str {
let requested: Vec<LanguageIdentifier> = requested
.iter()
.filter_map(|language| language.parse().ok())
.filter(|language| !is_traditional_chinese(language))
.collect();
let available: Vec<LanguageIdentifier> = LOCALES
.iter()
.map(|(language, _)| language.parse().expect("a valid language"))
.collect();
let fallback: LanguageIdentifier = FALLBACK.parse().expect("a valid language");
let chosen = negotiate_languages(
&requested,
&available,
Some(&fallback),
NegotiationStrategy::Lookup,
);
let chosen = chosen
.first()
.map_or(FALLBACK.to_owned(), ToString::to_string);
LOCALES
.iter()
.find(|(language, _)| *language == chosen)
.map_or(FALLBACK, |(language, _)| language)
}
fn is_traditional_chinese(language: &LanguageIdentifier) -> bool {
language.language.as_str() == "zh"
&& (language
.script
.is_some_and(|script| script.as_str() == "Hant")
|| language
.region
.is_some_and(|region| ["TW", "HK", "MO"].contains(®ion.as_str())))
}
fn texts() -> &'static Texts {
TEXTS.get_or_init(|| {
let language = negotiate(&requested(|name| ::std::env::var(name).ok()));
let bundles = [language, FALLBACK]
.into_iter()
.enumerate()
.filter(|&(i, chosen)| i == 0 || chosen != language)
.filter_map(|(_, chosen)| {
let (_, ftl) = LOCALES.iter().find(|(lang, _)| *lang == chosen)?;
bundle(chosen, ftl)
.inspect_err(|err| eprintln!("Skipped the translation {err}"))
.ok()
})
.collect();
Texts { bundles }
})
}
pub fn lookup(id: &str, args: &[(&str, FluentValue<'_>)]) -> Option<String> {
let args = (!args.is_empty()).then(|| {
let mut fluent = FluentArgs::new();
for (name, value) in args {
fluent.set(*name, value.clone());
}
fluent
});
texts().bundles.iter().find_map(|bundle| {
let pattern = bundle.get_message(id)?.value()?;
let mut errors = Vec::new();
let text = bundle.format_pattern(pattern, args.as_ref(), &mut errors);
Some(paragraphs(&text))
})
}
pub fn tr(id: &str) -> String {
lookup(id, &[]).unwrap_or_else(|| id.to_owned())
}
pub fn tr_args(id: &str, args: &[(&str, FluentValue<'_>)]) -> String {
lookup(id, args).unwrap_or_else(|| id.to_owned())
}
pub fn paragraphs(text: &str) -> String {
text.split("\n\n")
.map(|paragraph| {
paragraph
.split('\n')
.map(str::trim)
.collect::<Vec<_>>()
.join(" ")
})
.collect::<Vec<_>>()
.join("\n\n")
}