use std::str::FromStr;
use super::bundle::Locale;
pub const BUILTIN_DEFAULT_LOCALE: &str = "en-US";
const PROJ_LANG_ENV: &str = "CRAWLRS_LANG";
pub fn parse_accept_language(header: &str) -> Vec<Locale> {
let mut locales: Vec<(Locale, f32)> = header
.split(',')
.filter_map(|part| {
let part = part.trim();
if part.is_empty() {
return None;
}
let mut segments = part.split(';');
let tag = segments.next()?.trim();
let locale: Locale = tag.parse().ok()?;
let quality = segments
.next()
.and_then(|q| q.trim().strip_prefix("q="))
.and_then(|v| v.trim().parse::<f32>().ok())
.unwrap_or(1.0);
Some((locale, quality))
})
.collect();
locales.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
locales.into_iter().map(|(l, _)| l).collect()
}
pub fn negotiate_locale(preferred: &[Locale], supported: &[Locale], default: &Locale) -> Locale {
for pref in preferred {
if supported.contains(pref) {
return pref.clone();
}
for sup in supported {
if sup.language == pref.language {
return sup.clone();
}
}
}
default.clone()
}
fn normalize_locale_label(raw: &str) -> Option<Locale> {
let s = raw
.trim()
.split('@')
.next()?
.split('.')
.next()?
.trim()
.replace('_', "-");
if s.is_empty() || s.eq_ignore_ascii_case("C") || s.eq_ignore_ascii_case("POSIX") {
return None;
}
if s.to_ascii_lowercase().starts_with("zh") {
return "zh-CN".parse().ok();
}
"en-US".parse().ok()
}
pub fn detect_locale_from(
getenv: impl Fn(&str) -> Option<String>,
sys_locale: Option<&str>,
) -> Locale {
if let Some(lang) = getenv(PROJ_LANG_ENV) {
if let Some(locale) = normalize_locale_label(&lang) {
return locale;
}
}
for key in ["LC_ALL", "LC_MESSAGES", "LANG"] {
if let Some(lang) = getenv(key) {
if let Some(locale) = normalize_locale_label(&lang) {
return locale;
}
}
}
if let Some(s) = sys_locale {
if let Some(locale) = normalize_locale_label(s) {
return locale;
}
}
Locale::from_str(BUILTIN_DEFAULT_LOCALE).expect("builtin default locale is valid")
}
pub fn detect_system_locale() -> Locale {
detect_locale_from(
|key| std::env::var(key).ok().filter(|v| !v.trim().is_empty()),
sys_locale::get_locale().as_deref(),
)
}
pub fn resolve_startup_default_locale(configured_default: &str, supported: &[&str]) -> Locale {
let builtin: Locale = Locale::from_str(BUILTIN_DEFAULT_LOCALE).expect("valid builtin locale");
let Ok(configured) = configured_default.parse::<Locale>() else {
return builtin;
};
if configured != builtin {
return configured;
}
let detected = detect_system_locale();
let supported_locales: Vec<Locale> = supported.iter().filter_map(|s| s.parse().ok()).collect();
if supported_locales.contains(&detected) {
detected
} else {
configured
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_parse_accept_language_basic() {
let locales = parse_accept_language("en-US,en;q=0.9,zh-CN;q=0.8");
assert_eq!(locales.len(), 3);
assert_eq!(locales[0].to_string(), "en-US");
assert_eq!(locales[1].to_string(), "en");
assert_eq!(locales[2].to_string(), "zh-CN");
}
#[test]
fn test_parse_accept_language_single() {
let locales = parse_accept_language("zh-CN");
assert_eq!(locales.len(), 1);
assert_eq!(locales[0].to_string(), "zh-CN");
}
#[test]
fn test_parse_accept_language_with_spaces() {
let locales = parse_accept_language("en-US, zh-CN;q=0.5");
assert_eq!(locales.len(), 2);
assert_eq!(locales[0].to_string(), "en-US");
assert_eq!(locales[1].to_string(), "zh-CN");
}
#[test]
fn test_parse_accept_language_empty() {
let locales = parse_accept_language("");
assert!(locales.is_empty());
}
#[test]
fn test_parse_accept_language_invalid_tags() {
let locales = parse_accept_language("invalid!!!,en-US;q=0.9");
assert_eq!(locales.len(), 1);
assert_eq!(locales[0].to_string(), "en-US");
}
#[test]
fn test_negotiate_exact_match() {
let preferred: Vec<Locale> = vec!["zh-CN".parse().unwrap()];
let supported: Vec<Locale> = vec!["en-US".parse().unwrap(), "zh-CN".parse().unwrap()];
let default: Locale = "en-US".parse().unwrap();
let result = negotiate_locale(&preferred, &supported, &default);
assert_eq!(result.to_string(), "zh-CN");
}
#[test]
fn test_negotiate_language_prefix_match() {
let preferred: Vec<Locale> = vec!["en".parse().unwrap()];
let supported: Vec<Locale> = vec!["en-US".parse().unwrap(), "zh-CN".parse().unwrap()];
let default: Locale = "en-US".parse().unwrap();
let result = negotiate_locale(&preferred, &supported, &default);
assert_eq!(result.to_string(), "en-US");
}
#[test]
fn test_negotiate_fallback_to_default() {
let preferred: Vec<Locale> = vec!["fr-FR".parse().unwrap()];
let supported: Vec<Locale> = vec!["en-US".parse().unwrap(), "zh-CN".parse().unwrap()];
let default: Locale = "en-US".parse().unwrap();
let result = negotiate_locale(&preferred, &supported, &default);
assert_eq!(result.to_string(), "en-US");
}
#[test]
fn test_negotiate_empty_preferred() {
let preferred: Vec<Locale> = vec![];
let supported: Vec<Locale> = vec!["en-US".parse().unwrap(), "zh-CN".parse().unwrap()];
let default: Locale = "en-US".parse().unwrap();
let result = negotiate_locale(&preferred, &supported, &default);
assert_eq!(result.to_string(), "en-US");
}
#[test]
fn test_negotiate_priority_order() {
let preferred: Vec<Locale> = vec!["fr-FR".parse().unwrap(), "zh-CN".parse().unwrap()];
let supported: Vec<Locale> = vec!["en-US".parse().unwrap(), "zh-CN".parse().unwrap()];
let default: Locale = "en-US".parse().unwrap();
let result = negotiate_locale(&preferred, &supported, &default);
assert_eq!(result.to_string(), "zh-CN");
}
fn no_env() -> impl Fn(&str) -> Option<String> {
|_| None
}
#[test]
fn test_detect_chain_zh_cn_utf8() {
let getenv = |key: &str| match key {
"LANG" => Some("zh_CN.UTF-8".to_string()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "zh-CN");
}
#[test]
fn test_detect_chain_zh_tw_collapses_to_zh_cn() {
let getenv = |key: &str| match key {
"LC_ALL" => Some("zh_TW".to_string()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "zh-CN");
}
#[test]
fn test_detect_chain_unsupported_language_falls_back_to_en() {
let getenv = |key: &str| match key {
"LANG" => Some("fr_FR.UTF-8".to_string()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "en-US");
}
#[test]
fn test_detect_chain_c_posix_skips_and_terminates_en() {
let getenv = |key: &str| match key {
"LC_ALL" => Some("C".to_string()),
"LANG" => Some("zh_CN".to_string()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "zh-CN");
let getenv = |key: &str| match key {
"LC_ALL" => Some("C".to_string()),
"LC_MESSAGES" => Some("C".to_string()),
"LANG" => Some("POSIX".to_string()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "en-US");
}
#[test]
fn test_detect_chain_empty_or_malformed_falls_back_to_en() {
let getenv = |key: &str| match key {
"LC_ALL" => Some(" ".to_string()),
"LC_MESSAGES" => Some("@@@!!!".to_string()),
"LANG" => Some(String::new()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "en-US");
let locale = detect_locale_from(no_env(), None);
assert_eq!(locale.to_string(), "en-US");
}
#[test]
fn test_detect_chain_proj_lang_overrides_lc_all() {
let getenv = |key: &str| match key {
"CRAWLRS_LANG" => Some("zh-CN".to_string()),
"LC_ALL" => Some("en_US.UTF-8".to_string()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "zh-CN");
let getenv = |key: &str| match key {
"CRAWLRS_LANG" => Some("en".to_string()),
"LC_ALL" => Some("zh_CN.UTF-8".to_string()),
_ => None,
};
let locale = detect_locale_from(getenv, None);
assert_eq!(locale.to_string(), "en-US");
}
#[test]
fn test_detect_chain_sys_locale_used_after_env() {
assert_eq!(
detect_locale_from(no_env(), Some("zh-CN")).to_string(),
"zh-CN"
);
assert_eq!(
detect_locale_from(no_env(), Some("en_US")).to_string(),
"en-US"
);
assert_eq!(
detect_locale_from(no_env(), Some("fr-FR")).to_string(),
"en-US"
);
}
#[test]
fn test_detect_system_locale_result_domain() {
let locale = detect_system_locale();
let resolved = locale.to_string();
assert!(
resolved == "en-US" || resolved == "zh-CN",
"detect_system_locale must resolve to en-US or zh-CN, got {}",
locale
);
}
#[test]
fn test_resolve_startup_explicit_config_wins() {
let locale = resolve_startup_default_locale("zh-CN", &["en-US", "zh-CN"]);
assert_eq!(locale.to_string(), "zh-CN");
let locale = resolve_startup_default_locale("zh-TW", &["en-US"]);
assert_eq!(locale.to_string(), "zh-TW");
}
#[test]
fn test_resolve_startup_detection_applies_when_unspecified() {
let _guard = crate::common::test_support::ENV_MUTEX
.lock()
.unwrap_or_else(|e| e.into_inner());
let saved = std::env::var("CRAWLRS_LANG").ok();
std::env::set_var("CRAWLRS_LANG", "zh-CN");
let locale = resolve_startup_default_locale("en-US", &["en-US", "zh-CN"]);
match saved {
Some(v) => std::env::set_var("CRAWLRS_LANG", v),
None => std::env::remove_var("CRAWLRS_LANG"),
}
assert_eq!(locale.to_string(), "zh-CN");
}
#[test]
fn test_resolve_startup_unsupported_detection_falls_back_to_config() {
let _guard = crate::common::test_support::ENV_MUTEX
.lock()
.unwrap_or_else(|e| e.into_inner());
let saved = std::env::var("CRAWLRS_LANG").ok();
std::env::set_var("CRAWLRS_LANG", "zh-CN");
let locale = resolve_startup_default_locale("en-US", &["en-US"]);
match saved {
Some(v) => std::env::set_var("CRAWLRS_LANG", v),
None => std::env::remove_var("CRAWLRS_LANG"),
}
assert_eq!(locale.to_string(), "en-US");
}
#[test]
fn test_resolve_startup_invalid_config_falls_back_to_builtin() {
let _guard = crate::common::test_support::ENV_MUTEX
.lock()
.unwrap_or_else(|e| e.into_inner());
let saved = std::env::var("CRAWLRS_LANG").ok();
std::env::remove_var("CRAWLRS_LANG");
let locale = resolve_startup_default_locale("not-a-locale!!!", &["en-US", "zh-CN"]);
match saved {
Some(v) => std::env::set_var("CRAWLRS_LANG", v),
None => std::env::remove_var("CRAWLRS_LANG"),
}
assert_eq!(locale.to_string(), "en-US");
}
}