use std::{cmp::Reverse, sync::Arc};
use axum::http::{HeaderMap, HeaderValue, header};
use thiserror::Error;
use crate::result::{ClassifyError, ErrorCode, ErrorKind};
mod language_tag;
use language_tag::normalize_tag;
pub const MAX_ACCEPT_LANGUAGE_BYTES: usize = 8192;
pub const MAX_LANGUAGE_RANGES: usize = 64;
pub const MAX_LOCALE_LENGTH: usize = 256;
#[derive(Clone, Debug)]
pub struct LocalePolicy {
supported: Arc<[(String, HeaderValue)]>,
default: usize,
}
impl LocalePolicy {
pub fn new(
supported: impl IntoIterator<Item = impl AsRef<str>>,
default: impl AsRef<str>,
) -> Result<Self, LocaleConfigError> {
let mut locales: Vec<(String, HeaderValue)> = Vec::new();
for value in supported {
let tag = normalize_tag(value.as_ref())?;
if locales.iter().any(|(existing, _)| existing == &tag) {
return Err(LocaleConfigError::DuplicateLocale);
}
let header =
HeaderValue::from_str(&tag).map_err(|_| LocaleConfigError::InvalidLocale)?;
locales.push((tag, header));
}
if locales.is_empty() {
return Err(LocaleConfigError::EmptySupportedLocales);
}
let default = normalize_tag(default.as_ref())?;
let default = locales
.iter()
.position(|(tag, _)| tag == &default)
.ok_or(LocaleConfigError::UnsupportedDefault)?;
Ok(Self {
supported: locales.into(),
default,
})
}
pub fn supported_locales(&self) -> impl ExactSizeIterator<Item = &str> {
self.supported.iter().map(|(tag, _)| tag.as_str())
}
#[must_use]
pub fn default_locale(&self) -> ResolvedLocale {
self.resolved(self.default, LocaleSource::Default)
}
pub fn select(&self, locale: &str) -> Result<ResolvedLocale, LocaleNegotiationError> {
let index = self
.supported
.iter()
.position(|(tag, _)| tag.eq_ignore_ascii_case(locale))
.ok_or(LocaleNegotiationError::UnsupportedLocale)?;
Ok(self.resolved(index, LocaleSource::Explicit))
}
pub fn negotiate(&self, headers: &HeaderMap) -> Result<ResolvedLocale, LocaleNegotiationError> {
if !headers.contains_key(header::ACCEPT_LANGUAGE) {
return Ok(self.default_locale());
}
let preferences = parse_preferences(headers)?;
let index = self
.supported
.iter()
.enumerate()
.filter_map(|(index, (tag, _))| {
controlling_preference(tag, &preferences)
.filter(|(_, preference)| preference.quality > 0)
.map(|(position, preference)| {
(
index,
(preference.quality, Reverse(position), Reverse(index)),
)
})
})
.max_by_key(|(_, rank)| *rank)
.map(|(index, _)| index)
.ok_or(LocaleNegotiationError::NoMatch)?;
Ok(self.resolved(index, LocaleSource::AcceptLanguage))
}
fn resolved(&self, index: usize, source: LocaleSource) -> ResolvedLocale {
let (tag, header) = &self.supported[index];
ResolvedLocale {
tag: tag.clone(),
header: header.clone(),
source,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum LocaleSource {
Explicit,
AcceptLanguage,
Default,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ResolvedLocale {
tag: String,
header: HeaderValue,
source: LocaleSource,
}
impl ResolvedLocale {
#[must_use]
pub fn as_str(&self) -> &str {
&self.tag
}
#[must_use]
pub const fn source(&self) -> LocaleSource {
self.source
}
pub fn apply_response_headers(&self, headers: &mut HeaderMap) {
headers.insert(header::CONTENT_LANGUAGE, self.header.clone());
if self.source == LocaleSource::Explicit {
return;
}
let already_varies = headers.get_all(header::VARY).iter().any(|value| {
value.as_bytes().split(|&byte| byte == b',').any(|member| {
let member = member.trim_ascii();
member == b"*" || member.eq_ignore_ascii_case(b"accept-language")
})
});
if !already_varies {
headers.append(header::VARY, HeaderValue::from_static("Accept-Language"));
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Error)]
#[non_exhaustive]
pub enum LocaleConfigError {
#[error("at least one supported locale is required")]
EmptySupportedLocales,
#[error("locale must be a well-formed language tag within the length limit")]
InvalidLocale,
#[error("supported locales must not contain duplicates")]
DuplicateLocale,
#[error("default locale must be a supported locale")]
UnsupportedDefault,
}
impl ClassifyError for LocaleConfigError {
fn error_kind(&self) -> ErrorKind {
ErrorKind::Validation
}
fn error_code(&self) -> ErrorCode {
ErrorCode::internal(match self {
Self::EmptySupportedLocales => "locale_empty_supported",
Self::InvalidLocale => "locale_invalid_tag",
Self::DuplicateLocale => "locale_duplicate_tag",
Self::UnsupportedDefault => "locale_unsupported_default",
})
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Error)]
#[non_exhaustive]
pub enum LocaleNegotiationError {
#[error("Accept-Language contains a malformed range or weight")]
MalformedHeader,
#[error("Accept-Language exceeds the byte limit")]
HeaderTooLarge,
#[error("Accept-Language exceeds the range limit")]
TooManyRanges,
#[error("no supported locale matches the language preferences")]
NoMatch,
#[error("explicit locale must be a supported locale")]
UnsupportedLocale,
}
impl ClassifyError for LocaleNegotiationError {
fn error_kind(&self) -> ErrorKind {
ErrorKind::Validation
}
fn error_code(&self) -> ErrorCode {
ErrorCode::internal(match self {
Self::MalformedHeader => "locale_malformed_header",
Self::HeaderTooLarge => "locale_header_too_large",
Self::TooManyRanges => "locale_too_many_ranges",
Self::NoMatch => "locale_no_match",
Self::UnsupportedLocale => "locale_unsupported_preference",
})
}
}
struct Preference<'a> {
range: &'a str,
quality: u16,
}
fn parse_preferences(headers: &HeaderMap) -> Result<Vec<Preference<'_>>, LocaleNegotiationError> {
let mut preferences = Vec::new();
let mut remaining_bytes = MAX_ACCEPT_LANGUAGE_BYTES;
let mut remaining_members = MAX_LANGUAGE_RANGES;
for value in headers.get_all(header::ACCEPT_LANGUAGE) {
remaining_bytes = remaining_bytes
.checked_sub(value.as_bytes().len())
.ok_or(LocaleNegotiationError::HeaderTooLarge)?;
let value = value
.to_str()
.map_err(|_| LocaleNegotiationError::MalformedHeader)?;
for member in value.split(',') {
remaining_members = remaining_members
.checked_sub(1)
.ok_or(LocaleNegotiationError::TooManyRanges)?;
let member = trim_ows(member);
if member.is_empty() {
continue;
}
let (range, quality) = match member.split_once(';') {
Some((range, weight)) => {
let weight = trim_ows(weight);
let quality = weight
.strip_prefix("q=")
.or_else(|| weight.strip_prefix("Q="))
.and_then(super::parse_quality)
.ok_or(LocaleNegotiationError::MalformedHeader)?;
(trim_ows(range), quality)
}
None => (member, 1000),
};
if range != "*" && !is_basic_range(range) {
return Err(LocaleNegotiationError::MalformedHeader);
}
preferences.push(Preference { range, quality });
}
}
Ok(preferences)
}
fn trim_ows(value: &str) -> &str {
value.trim_matches([' ', '\t'])
}
fn is_basic_range(range: &str) -> bool {
range.len() <= MAX_LOCALE_LENGTH
&& range.split('-').enumerate().all(|(index, subtag)| {
(1..=8).contains(&subtag.len())
&& subtag.bytes().all(|byte| {
if index == 0 {
byte.is_ascii_alphabetic()
} else {
byte.is_ascii_alphanumeric()
}
})
})
}
fn controlling_preference<'a>(
tag: &str,
preferences: &'a [Preference<'_>],
) -> Option<(usize, &'a Preference<'a>)> {
preferences
.iter()
.enumerate()
.filter(|(_, preference)| {
let range = preference.range;
range == "*"
|| (tag
.get(..range.len())
.is_some_and(|prefix| prefix.eq_ignore_ascii_case(range))
&& (tag.len() == range.len() || tag.as_bytes().get(range.len()) == Some(&b'-')))
})
.max_by_key(|(index, preference)| {
let specificity = if preference.range == "*" {
0
} else {
preference.range.len()
};
(specificity, Reverse(*index))
})
}