orzklv 0.2.3

Library consisting various implementation for std and libs by Orzklv
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

use super::language::Language;
use std::collections::HashMap;
// use std::io::BufRead;
use crate::telegram::i18n::I18nError;

#[derive(Debug, Clone, Default)]
pub struct I18n {
    users: HashMap<i64, String>,
    pub languages: HashMap<String, Language>,
}

impl I18n {
    pub fn new() -> Self {
        I18n::default()
    }

    pub fn load_translations(&mut self) -> Result<(), I18nError> {
        let locales = std::fs::read_dir("locales")?;

        for locale in locales {
            let safe = locale?;

            let path = safe.path();
            let file = match path.to_str() {
                Some(c) => c,
                None => continue,
            };

            let mut language = Language::new();
            language.parse_translation(file);

            let name = file.split("/").last().unwrap().split(".").next().unwrap();

            self.languages.insert(name.to_owned(), language);
        }

        Ok(())
    }

    pub fn add_user(&mut self, user_id: i64, language: &str) {
        self.users.insert(user_id, language.to_string());
    }

    pub fn get_translation(&self, language: &str, key: &str) -> Option<&String> {
        self.languages.get(language)?.get_translation(key)
    }

    pub fn get_user_translation(&self, user_id: i64, key: &str) -> Option<&String> {
        let language = self.users.get(&user_id)?;
        self.get_translation(language, key)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_i18n_init() {
        // Create instance and load locales
        let mut i18n = I18n::new();
        i18n.load_translations().unwrap();

        // Get a translation
        let translation = i18n.get_translation("en", "lorem");

        // Test
        assert_eq!(translation, Some(&"ipsum shit".to_string()));
    }

    #[test]
    fn test_user() {
        // Create instance and load locales
        let mut i18n = I18n::new();
        i18n.load_translations().unwrap();

        //
        i18n.add_user(123123123123, "en");

        // Let's try sending request
        let translation = i18n.get_user_translation(123123123123, "lorem");

        // Test
        assert_eq!(translation, Some(&"ipsum shit".to_string()));
    }
}