use core::{fmt, str::FromStr};
use crate::{
CompositeFilterMarker, CompositeMarker, DefaultMarker, Nullable, ScalarFilter, ToGraphqlInput,
};
use smol_bytes::Utf8Bytes;
use super::{
Language, LanguageWire, ParseLanguageError, ParseRegionError, ParseScriptSubtagError, Region,
RegionWire, ScriptSubtag, ScriptSubtagWire, registry,
};
use crate::graphql::filter::opt_accessor;
#[cfg(feature = "sqlx")]
mod comparison;
mod storage;
#[cfg(test)]
mod tests;
#[cfg(feature = "sqlx")]
pub use comparison::{LanguageIdCrossingError, SqlLanguageIdComparison};
pub use storage::LanguageIdColumnError;
#[cfg(feature = "mongo")]
pub(crate) use storage::document_seats;
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct LanguageId {
language: Language,
script: Option<ScriptSubtag>,
region: Option<Region>,
rest: Option<Utf8Bytes>,
}
impl LanguageId {
pub fn new(text: &str) -> Result<Self, ParseLanguageIdError> {
if text.is_empty() {
return Err(ParseLanguageIdError::Empty);
}
let normalized;
let tag = if text.contains('_') {
normalized = text.replace('_', "-");
normalized.as_str()
} else {
text
};
if let Some(preferred) = grandfathered(tag) {
return Self::composed(preferred);
}
Self::composed(tag)
}
fn composed(tag: &str) -> Result<Self, ParseLanguageIdError> {
let parts: Vec<&str> = tag.split('-').collect();
if parts.iter().any(|part| part.is_empty()) {
return Err(ParseLanguageIdError::EmptySubtag);
}
let language = Language::new(parts[0]).map_err(ParseLanguageIdError::Language)?;
let mut at = 1;
let script = match parts.get(at) {
Some(part) if script_shaped(part) => {
at += 1;
Some(ScriptSubtag::new(part).map_err(ParseLanguageIdError::ScriptSubtag)?)
}
_ => None,
};
let region = match parts.get(at) {
Some(part) if region_shaped(part) => {
at += 1;
Some(Region::new(part).map_err(ParseLanguageIdError::Region)?)
}
_ => None,
};
let consumed: usize = parts[..at].iter().map(|part| part.len() + 1).sum();
let rest = match consumed < tag.len() {
true => Some(tail(&tag[consumed..])?),
false => None,
};
Ok(Self {
script: match (&script, language.suppressed_script()) {
(Some(declared), Some(implied)) if declared.as_str() == implied => None,
_ => script,
},
language,
region,
rest,
})
}
#[must_use]
pub fn compose(
language: Language,
script: Option<ScriptSubtag>,
region: Option<Region>,
rest: Option<Utf8Bytes>,
) -> Self {
Self {
script: match (&script, language.suppressed_script()) {
(Some(declared), Some(implied)) if declared.as_str() == implied => None,
_ => script,
},
language,
region,
rest,
}
}
#[inline]
#[must_use]
pub const fn language(&self) -> &Language {
&self.language
}
#[inline]
#[must_use]
pub const fn script(&self) -> Option<&ScriptSubtag> {
self.script.as_ref()
}
#[inline]
#[must_use]
pub const fn region(&self) -> Option<&Region> {
self.region.as_ref()
}
#[inline]
#[must_use]
pub const fn rest(&self) -> Option<&Utf8Bytes> {
self.rest.as_ref()
}
}
const TAIL_SUBTAG_MAX: usize = 8;
pub(super) fn tail(text: &str) -> Result<Utf8Bytes, ParseLanguageIdError> {
for part in text.split('-') {
if part.is_empty() {
return Err(ParseLanguageIdError::EmptySubtag);
}
if part.len() > TAIL_SUBTAG_MAX {
return Err(ParseLanguageIdError::TailWidth);
}
if let Some(outside) = part
.chars()
.find(|character| !character.is_ascii_alphanumeric())
{
return Err(ParseLanguageIdError::Tail(outside));
}
}
Ok(Utf8Bytes::from(text))
}
const GRANDFATHERED_MAX: usize = 16;
fn grandfathered(tag: &str) -> Option<&'static str> {
if tag.len() > GRANDFATHERED_MAX {
return None;
}
let mut lowered = [0u8; GRANDFATHERED_MAX];
for (at, byte) in tag.as_bytes().iter().enumerate() {
lowered[at] = byte.to_ascii_lowercase();
}
let lowered = unsafe { core::str::from_utf8_unchecked(&lowered[..tag.len()]) };
registry::grandfathered_preferred(lowered)
}
fn script_shaped(part: &str) -> bool {
part.len() == 4
&& part
.chars()
.all(|character| character.is_ascii_alphabetic())
}
fn region_shaped(part: &str) -> bool {
let letters = part.len() == 2
&& part
.chars()
.all(|character| character.is_ascii_alphabetic());
let digits = part.len() == 3 && part.chars().all(|character| character.is_ascii_digit());
letters || digits
}
impl fmt::Display for LanguageId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(self.language.as_str())?;
if let Some(script) = &self.script {
write!(f, "-{script}")?;
}
if let Some(region) = &self.region {
write!(f, "-{region}")?;
}
if let Some(rest) = &self.rest {
write!(f, "-{}", rest.as_str())?;
}
Ok(())
}
}
impl fmt::Debug for LanguageId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "LanguageId({:?})", self.to_string())
}
}
impl FromStr for LanguageId {
type Err = ParseLanguageIdError;
#[inline]
fn from_str(text: &str) -> Result<Self, Self::Err> {
Self::new(text)
}
}
impl From<Language> for LanguageId {
#[inline]
fn from(language: Language) -> Self {
Self {
language,
script: None,
region: None,
rest: None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ParseLanguageIdError {
Empty,
EmptySubtag,
Language(ParseLanguageError),
ScriptSubtag(ParseScriptSubtagError),
Region(ParseRegionError),
Tail(char),
TailWidth,
}
impl fmt::Display for ParseLanguageIdError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Empty => {
f.write_str("a language tag opens with a language subtag, and nothing was sent")
}
Self::EmptySubtag => f.write_str("a language tag has no empty subtag between its separators"),
Self::Language(refused) => write!(f, "the tag's language subtag is not one: {refused}"),
Self::ScriptSubtag(refused) => write!(f, "the tag's script subtag is not one: {refused}"),
Self::Region(refused) => write!(f, "the tag's region subtag is not one: {refused}"),
Self::Tail(outside) => write!(
f,
"a variant, extension or private-use subtag is letters and digits, so `{outside}` is not \
one of its characters"
),
Self::TailWidth => {
f.write_str("a variant, extension or private-use subtag is at most eight characters")
}
}
}
}
impl core::error::Error for ParseLanguageIdError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Language(refused) => Some(refused),
Self::ScriptSubtag(refused) => Some(refused),
Self::Region(refused) => Some(refused),
Self::Empty | Self::EmptySubtag | Self::Tail(_) | Self::TailWidth => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct LanguageIdOperand(LanguageId);
impl LanguageIdOperand {
#[inline]
#[must_use]
pub const fn new(id: LanguageId) -> Self {
Self(id)
}
#[inline]
#[must_use]
pub fn get(&self) -> &LanguageId {
&self.0
}
}
impl From<LanguageId> for LanguageIdOperand {
#[inline]
fn from(id: LanguageId) -> Self {
Self(id)
}
}
impl From<LanguageIdOperand> for LanguageId {
#[inline]
fn from(operand: LanguageIdOperand) -> Self {
operand.0
}
}
impl ToGraphqlInput for LanguageId {
type Input = LanguageIdOperand;
type Error = core::convert::Infallible;
#[inline]
fn cross(input: Self::Input) -> Result<Self, Self::Error> {
Ok(input.into())
}
#[inline]
fn carry(operand: &Self) -> Self::Input {
LanguageIdOperand::new(operand.clone())
}
}
impl crate::ToGraphqlOutput for LanguageId {
type Output<'a> = &'a Self;
#[inline]
fn to_graphql_output(marked: &Self) -> &Self {
marked
}
}
impl CompositeFilterMarker for LanguageId {
type Filter = LanguageIdFilter;
type ColumnFilter = LanguageIdFilter;
}
impl DefaultMarker for LanguageId {
type Marker = CompositeMarker<LanguageId>;
}
#[derive(Debug, Clone, PartialEq, ingraph::Filter)]
#[ingraph(composed)]
pub struct LanguageIdFilter {
eq: Option<LanguageId>,
ne: Option<LanguageId>,
in_: Option<Box<[LanguageId]>>,
not_in: Option<Box<[LanguageId]>>,
language: Option<ScalarFilter<Language, LanguageWire>>,
script: Option<Nullable<ScalarFilter<ScriptSubtag, ScriptSubtagWire>>>,
region: Option<Nullable<ScalarFilter<Region, RegionWire>>>,
}
impl LanguageIdFilter {
#[inline]
pub const fn new() -> Self {
Self {
eq: None,
ne: None,
in_: None,
not_in: None,
language: None,
script: None,
region: None,
}
}
pub fn is_empty(&self) -> bool {
self.eq.is_none()
&& self.ne.is_none()
&& self.in_.is_none()
&& self.not_in.is_none()
&& self.language.as_ref().is_none_or(ScalarFilter::is_empty)
&& self.script.as_ref().is_none_or(Nullable::is_empty)
&& self.region.as_ref().is_none_or(Nullable::is_empty)
}
#[inline]
pub const fn language(&self) -> Option<&ScalarFilter<Language, LanguageWire>> {
self.language.as_ref()
}
#[inline]
pub const fn script(&self) -> Option<&Nullable<ScalarFilter<ScriptSubtag, ScriptSubtagWire>>> {
self.script.as_ref()
}
#[inline]
pub const fn region(&self) -> Option<&Nullable<ScalarFilter<Region, RegionWire>>> {
self.region.as_ref()
}
opt_accessor!(eq: LanguageId => with_eq, set_eq, maybe_eq, update_eq);
opt_accessor!(ne: LanguageId => with_ne, set_ne, maybe_ne, update_ne);
opt_accessor!(in_: [LanguageId] => with_in_, set_in_, maybe_in_, update_in_);
opt_accessor!(not_in: [LanguageId] => with_not_in, set_not_in, maybe_not_in, update_not_in);
#[must_use]
#[inline]
pub fn with_language(mut self, language: ScalarFilter<Language, LanguageWire>) -> Self {
self.set_language(language);
self
}
#[inline]
pub fn set_language(&mut self, language: ScalarFilter<Language, LanguageWire>) -> &mut Self {
self.language = Some(language);
self
}
#[must_use]
#[inline]
pub fn with_script(
mut self,
script: Nullable<ScalarFilter<ScriptSubtag, ScriptSubtagWire>>,
) -> Self {
self.set_script(script);
self
}
#[inline]
pub fn set_script(
&mut self,
script: Nullable<ScalarFilter<ScriptSubtag, ScriptSubtagWire>>,
) -> &mut Self {
self.script = Some(script);
self
}
#[must_use]
#[inline]
pub fn with_region(mut self, region: Nullable<ScalarFilter<Region, RegionWire>>) -> Self {
self.set_region(region);
self
}
#[inline]
pub fn set_region(&mut self, region: Nullable<ScalarFilter<Region, RegionWire>>) -> &mut Self {
self.region = Some(region);
self
}
}
impl Default for LanguageIdFilter {
#[inline]
fn default() -> Self {
Self::new()
}
}