use std::sync::Arc;
use parking_lot::RwLock;
use super::{
CommonWords, DataWords, DateLocale, DisplayWords, EditingWords, FieldWords, InputWords, KeyWords, MediaWords,
NavigationWords, Plural, PluralRule, Signal,
};
#[cfg(test)]
pub(crate) const LANGUAGES: [&str; 6] = ["en", "uk", "de", "fr", "es", "pl"];
#[derive(Clone, Debug)]
pub struct Locale {
pub tag: Arc<str>,
pub dates: DateLocale,
pub media: MediaWords,
pub input: InputWords,
pub display: DisplayWords,
pub common: CommonWords,
pub fields: FieldWords,
pub navigation: NavigationWords,
pub data: DataWords,
pub editing: EditingWords,
pub keys: KeyWords,
pub plural: PluralRule,
}
impl Locale {
pub fn english() -> Self {
Self {
tag: Arc::from("en"),
dates: DateLocale::english(),
media: MediaWords::english(),
input: InputWords::english(),
display: DisplayWords::english(),
common: CommonWords::english(),
fields: FieldWords::english(),
navigation: NavigationWords::english(),
data: DataWords::english(),
editing: EditingWords::english(),
keys: KeyWords::english(),
plural: PluralRule::OneOther,
}
}
pub fn for_tag(tag: &str) -> Self {
let dates = DateLocale::for_tag(tag);
let known = tag.trim().replace('_', "-").to_ascii_lowercase();
let language = known.split('-').next().unwrap_or("");
Self {
tag: Arc::from(tag.trim()),
dates,
media: MediaWords::for_language(language),
input: InputWords::for_language(language),
display: DisplayWords::for_language(language),
common: CommonWords::for_language(language),
fields: FieldWords::for_language(language),
navigation: NavigationWords::for_language(language),
data: DataWords::for_language(language),
editing: EditingWords::for_language(language),
keys: KeyWords::for_language(language),
plural: PluralRule::for_language(language),
}
}
pub fn with_dates(mut self, dates: DateLocale) -> Self {
self.dates = dates;
self
}
pub fn with_media(mut self, media: MediaWords) -> Self {
self.media = media;
self
}
pub fn with_input(mut self, input: InputWords) -> Self {
self.input = input;
self
}
pub fn with_display(mut self, display: DisplayWords) -> Self {
self.display = display;
self
}
pub fn count(&self, word: &Plural, count: usize) -> String {
word.say(self.plural, count as u64)
}
pub fn form<'a>(&self, word: &'a Plural, count: usize) -> &'a Arc<str> {
word.form(self.plural, count as u64)
}
}
impl Default for Locale {
fn default() -> Self {
Self::english()
}
}
#[derive(Clone)]
pub(crate) struct AppLocale {
current: Arc<RwLock<Arc<Locale>>>,
version: Signal<u64>,
}
impl AppLocale {
pub fn new() -> Self {
Self {
current: Arc::new(RwLock::new(english_locale())),
version: Signal::new(0),
}
}
pub fn get(&self) -> Arc<Locale> {
let _ = self.version.get();
self.current.read().clone()
}
pub fn set(&self, locale: Locale) {
*self.current.write() = Arc::new(locale);
self.version.update(|version| *version = version.wrapping_add(1));
}
}
pub(crate) fn english_locale() -> Arc<Locale> {
static ENGLISH: std::sync::OnceLock<Arc<Locale>> = std::sync::OnceLock::new();
ENGLISH.get_or_init(|| Arc::new(Locale::english())).clone()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_tag_gives_its_languages_words_and_its_regions_dates() {
let locale = Locale::for_tag("uk_UA");
assert_eq!(&*locale.media.pause, "Пауза");
assert_eq!(&*locale.input.clear, "Очистити");
assert_eq!(&*locale.display.qr_code, "QR-код");
assert_eq!(&*locale.dates.tag, &*DateLocale::for_tag("uk_UA").tag);
let british = Locale::for_tag("en-GB");
assert_eq!(british.media, MediaWords::english());
assert_eq!(british.dates.order, DateLocale::for_tag("en-GB").order);
assert_eq!(british.input, InputWords::english());
assert_eq!(Locale::for_tag("xx").media, MediaWords::english());
assert_eq!(Locale::for_tag("xx").input, InputWords::english());
}
#[test]
fn what_reads_the_apps_locale_reads_what_was_last_set() {
let held = AppLocale::new();
assert_eq!(&*held.get().media.play, "Play");
held.set(Locale::for_tag("de"));
assert_eq!(&*held.get().media.play, "Wiedergabe");
}
#[test]
fn a_tag_gives_every_part_its_languages_words_and_its_plural_rule() {
let locale = Locale::for_tag("pl-PL");
assert_eq!(locale.common, CommonWords::for_language("pl"));
assert_eq!(locale.fields, FieldWords::for_language("pl"));
assert_eq!(locale.navigation, NavigationWords::for_language("pl"));
assert_eq!(locale.data, DataWords::for_language("pl"));
assert_eq!(locale.editing, EditingWords::for_language("pl"));
assert_eq!(locale.keys, KeyWords::for_language("pl"));
assert_eq!(locale.plural, PluralRule::Polish);
assert_eq!(locale.count(&locale.data.rows, 22), "22 wiersze");
assert_eq!(Locale::for_tag("xx").common, CommonWords::english());
}
}