use crate::error::{Failure, Result};
use unic_langid::LanguageIdentifier;
pub const SUPPORTED: [&str; 2] = ["en", "pt-BR"];
pub const BUILTIN: &str = "en";
#[must_use]
pub fn parse(raw: &str) -> Option<LanguageIdentifier> {
let head = raw
.split(['.', '@'])
.next()
.unwrap_or(raw)
.replace('_', "-");
if head.is_empty() {
return None;
}
head.parse().ok()
}
#[must_use]
pub fn system() -> Option<LanguageIdentifier> {
sys_locale::get_locale().as_deref().and_then(parse)
}
#[must_use]
pub fn supported() -> Vec<LanguageIdentifier> {
SUPPORTED.iter().filter_map(|tag| parse(tag)).collect()
}
#[must_use]
pub fn best_match(wanted: &LanguageIdentifier) -> Option<LanguageIdentifier> {
let carried = supported();
carried
.iter()
.find(|candidate| *candidate == wanted)
.or_else(|| {
carried
.iter()
.find(|candidate| candidate.language == wanted.language)
})
.cloned()
}
fn unsupported(code: &'static str, raw: &str) -> Failure {
Failure::usage(code, format!("`{raw}`"))
.with_detail("detail", raw)
.with_detail("languages", SUPPORTED.join(", "))
.with_hint(format!("carried languages: {}", SUPPORTED.join(", ")))
}
pub fn negotiate(requested: Option<&str>, stored: Option<&str>) -> Result<LanguageIdentifier> {
if let Some(raw) = requested {
return parse(raw)
.as_ref()
.and_then(best_match)
.ok_or_else(|| unsupported("i18n.unsupported_language", raw));
}
if let Some(raw) = stored {
return parse(raw).as_ref().and_then(best_match).ok_or_else(|| {
Failure::config("i18n.unsupported_stored_language", format!("`{raw}`"))
.with_detail("detail", raw)
.with_detail("languages", SUPPORTED.join(", "))
.with_hint(format!("carried languages: {}", SUPPORTED.join(", ")))
});
}
Ok(system()
.as_ref()
.and_then(best_match)
.or_else(|| parse(BUILTIN))
.unwrap_or_default())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_carried_list_is_read_as_whole_languages() {
assert_eq!(supported().len(), SUPPORTED.len());
}
#[test]
fn a_host_writes_the_same_language_in_several_shapes() {
let dotted = parse("pt_BR.UTF-8").expect("a language");
let dashed = parse("pt-BR").expect("a language");
assert_eq!(dotted, dashed);
}
#[test]
fn something_that_is_not_a_language_yields_nothing_without_failing() {
assert!(parse("").is_none());
assert!(parse("!!!").is_none());
}
#[test]
fn a_region_this_build_does_not_carry_falls_back_to_the_base_language() {
let wanted = parse("pt-PT").expect("a language");
let served = best_match(&wanted).expect("the base language serves");
assert_eq!(served.to_string(), "pt-BR");
}
#[test]
fn a_language_with_no_region_reaches_the_carried_region() {
let wanted = parse("pt").expect("a language");
assert_eq!(best_match(&wanted).expect("carried").to_string(), "pt-BR");
}
#[test]
fn a_language_this_build_does_not_carry_matches_nothing() {
let wanted = parse("de-DE").expect("a language");
assert!(best_match(&wanted).is_none());
}
#[test]
fn the_mark_on_the_command_line_outranks_the_stored_value() {
let chosen = negotiate(Some("en"), Some("pt-BR")).expect("carried");
assert_eq!(chosen.to_string(), "en");
}
#[test]
fn the_stored_value_decides_when_no_mark_was_given() {
let chosen = negotiate(None, Some("pt-BR")).expect("carried");
assert_eq!(chosen.to_string(), "pt-BR");
}
#[test]
fn a_language_this_build_lacks_is_refused_as_the_callers_mistake() {
let failure = negotiate(Some("klingon"), None).expect_err("must refuse");
assert_eq!(failure.category(), crate::error::Category::Usage);
assert_eq!(failure.exit_number().code(), 2);
assert!(failure.hint().is_some_and(|hint| hint.contains("pt-BR")));
}
#[test]
fn a_broken_stored_value_is_told_apart_from_a_broken_mark() {
let failure = negotiate(None, Some("klingon")).expect_err("must refuse");
assert_eq!(failure.category(), crate::error::Category::Config);
}
#[test]
fn nothing_asked_for_always_yields_a_language() {
let chosen = negotiate(None, None).expect("never fails");
assert!(SUPPORTED.contains(&chosen.to_string().as_str()));
}
}