roblox-slang 2.0.4

Type-safe internationalization for Roblox experiences
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

use std::collections::HashMap;

/// A single translation entry
#[derive(Debug, Clone, PartialEq)]
pub struct Translation {
    /// Dot-separated key path (e.g., "ui.buttons.buy")
    pub key: String,

    /// Translated text
    pub value: String,

    /// Locale identifier (e.g., "en", "id", "es")
    pub locale: String,

    /// Optional context for disambiguation
    pub context: Option<String>,
}

/// Map of translation keys to values
#[allow(dead_code)]
pub type TranslationMap = HashMap<String, String>;

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

    #[test]
    fn test_translation_creation() {
        let translation = Translation {
            key: "ui.button".to_string(),
            value: "Buy".to_string(),
            locale: "en".to_string(),
            context: None,
        };

        assert_eq!(translation.key, "ui.button");
        assert_eq!(translation.value, "Buy");
        assert_eq!(translation.locale, "en");
        assert!(translation.context.is_none());
    }

    #[test]
    fn test_translation_with_context() {
        let translation = Translation {
            key: "common.close".to_string(),
            value: "Close".to_string(),
            locale: "en".to_string(),
            context: Some("button".to_string()),
        };

        assert_eq!(translation.context, Some("button".to_string()));
    }

    #[test]
    fn test_translation_clone() {
        let translation = Translation {
            key: "test.key".to_string(),
            value: "Test Value".to_string(),
            locale: "en".to_string(),
            context: None,
        };

        let cloned = translation.clone();
        assert_eq!(translation, cloned);
    }

    #[test]
    fn test_translation_equality() {
        let t1 = Translation {
            key: "key".to_string(),
            value: "value".to_string(),
            locale: "en".to_string(),
            context: None,
        };

        let t2 = Translation {
            key: "key".to_string(),
            value: "value".to_string(),
            locale: "en".to_string(),
            context: None,
        };

        assert_eq!(t1, t2);
    }

    #[test]
    fn test_translation_map() {
        let mut map: TranslationMap = HashMap::new();
        map.insert("key1".to_string(), "value1".to_string());
        map.insert("key2".to_string(), "value2".to_string());

        assert_eq!(map.len(), 2);
        assert_eq!(map.get("key1"), Some(&"value1".to_string()));
        assert_eq!(map.get("key2"), Some(&"value2".to_string()));
    }
}