bi18n 0.3.0

Barebone i18n crate, usable for web interfaces
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

mod key;
mod locale;
pub use key::Key;
pub use locale::Locale;
mod i18n;
pub use i18n::I18n;

use {ahash::AHashMap, parking_lot::RwLock, std::sync::Arc};

lazy_static::lazy_static! {
    static ref CURRENT: Arc<RwLock<Option<I18n>>> = Arc::new(RwLock::new(None));
    static ref DICTIONARY: Arc<RwLock<AHashMap<Locale, I18n>>> = Arc::new(RwLock::new(AHashMap::default()));
}

/// Convenience macro for i18n* functions
/// /!\ Theses functions can panic on error, if you're unsure, use the try_* functions
#[macro_export]
macro_rules! i18n {
    ($key:expr) => {
        bi18n::i18n_current($key)
    };
    ($key:expr, $locale:expr) => {
        bi18n::i18n_with_locale($key, $locale)
    };
}

/// Convenience macro for try_i18n* functions
#[macro_export]
macro_rules! try_i18n {
    ($key:expr) => {
        bi18n::try_i18n_current($key)
    };
    ($key:expr, $locale:expr) => {
        bi18n::try_i18n_with_locale($key, $locale)
    };
}

/// Fetches the translation corresponding to the given key in the currently saved i18n
/// Panics if not found, use try_i18n_current if you're not sure
pub fn i18n_current(key: impl Into<Key>) -> String {
    try_i18n_current(key).unwrap()
}

/// Tries to fetch the translation corresponding to the given key in the currently saved i18n
pub fn try_i18n_current(key: impl Into<Key>) -> Option<String> {
    CURRENT.read().as_ref()?.try_get(&key.into()).cloned()
}

/// Fetches the translation corresponding to the given key and given locale in all saved i18n (current & saved)
/// Panics if not found, use try_i18n_with_locale if you're not sure
pub fn i18n_with_locale(key: impl Into<Key>, locale: impl Into<Locale>) -> String {
    try_i18n_with_locale(key, locale).unwrap()
}

/// Tries to fetch the translation corresponding to the given key and given locale in all saved i18n (current & saved)
pub fn try_i18n_with_locale(key: impl Into<Key>, locale: impl Into<Locale>) -> Option<String> {
    let locale = locale.into();
    let key = key.into();

    if let Some(ref current) = *CURRENT.read() {
        if current.locale() == &locale {
            return current.try_get(&key).cloned();
        }
    }

    DICTIONARY
        .read()
        .iter()
        .filter(|(l, _)| *l == &locale)
        .flat_map(|(_, i)| i.try_get(&key))
        .next()
        .cloned()
}

// Sets the current i18n, saving the current one if any
pub fn set(i18n: I18n) {
    if let Some(old) = CURRENT.write().take() {
        DICTIONARY.write().insert(old.locale().clone(), old);
    }

    *CURRENT.write() = Some(i18n)
}

/// Sets the current i18n if empty, else saves it
pub fn add(i18n: I18n) {
    if CURRENT.read().is_none() {
        *CURRENT.write() = Some(i18n);
        return;
    }

    DICTIONARY.write().insert(i18n.locale().clone(), i18n);
}

/// Removes the current i18n and all saved ones
pub fn free() {
    *CURRENT.write() = None;
    DICTIONARY.write().clear();
}

/// Tries to fetch the locale of the current i18n
pub fn try_get_locale() -> Option<Locale> {
    Some(CURRENT.read().as_ref()?.locale().clone())
}

pub struct LocaleNotFound;

/// Tries to swap the current i18n with a saved one corresponding to the given Locale
pub fn set_language(locale: impl Into<Locale>) -> Result<(), LocaleNotFound> {
    let locale = locale.into();
    if let Some(ref current) = *CURRENT.read() {
        if current.locale() == &locale {
            return Ok(());
        }
    }

    if let Some(new) = DICTIONARY.write().remove(&locale) {
        set(new);
        return Ok(())
    }

    Err(LocaleNotFound)
}