pacsea 0.8.2

A fast, friendly TUI for browsing and installing Arch and AUR packages with built-in news and security scanning
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

//! Translation map and lookup utilities.

use std::collections::HashMap;

/// Translation map: dot-notation key -> translated string.
pub type TranslationMap = HashMap<String, String>;

/// What: Look up a translation in the translation map.
///
/// Inputs:
/// - `key`: Dot-notation key (e.g., "app.titles.search")
/// - `translations`: Translation map to search
///
/// Output:
/// - `Option<String>` containing translation or None if not found
///
/// Details:
/// - Direct key lookup
/// - Returns None if key not found
#[must_use]
pub fn translate(key: &str, translations: &TranslationMap) -> Option<String> {
    translations.get(key).cloned()
}

/// What: Look up translation with fallback to English.
///
/// Inputs:
/// - `key`: Dot-notation key
/// - `translations`: Primary translation map
/// - `fallback_translations`: Fallback translation map (usually English)
///
/// Output:
/// - Translated string (from primary or fallback, or key itself if both missing)
///
/// Details:
/// - Tries primary translations first
/// - Falls back to English if not found
/// - Returns key itself if neither has translation (for debugging)
/// - Logs warnings for missing keys (only once per key to avoid spam)
pub fn translate_with_fallback(
    key: &str,
    translations: &TranslationMap,
    fallback_translations: &TranslationMap,
) -> String {
    // Try primary translations first
    if let Some(translation) = translations.get(key) {
        return translation.clone();
    }

    // Try fallback translations
    if let Some(translation) = fallback_translations.get(key) {
        // Log that we're using fallback (only at debug level to avoid spam)
        tracing::debug!(
            "Translation key '{}' not found in primary locale, using fallback",
            key
        );
        return translation.clone();
    }

    // Neither has the key - log warning and return key itself
    // Use debug level to avoid flooding logs, but make it discoverable
    tracing::debug!(
        "Missing translation key: '{}'. Returning key as-is. Please add this key to locale files.",
        key
    );
    key.to_string()
}

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

    #[test]
    fn test_translate() {
        let mut translations = HashMap::new();
        translations.insert("app.titles.search".to_string(), "Suche".to_string());

        assert_eq!(
            translate("app.titles.search", &translations),
            Some("Suche".to_string())
        );
        assert_eq!(translate("app.titles.help", &translations), None);
    }

    #[test]
    fn test_translate_with_fallback() {
        let mut primary = HashMap::new();
        primary.insert("app.titles.search".to_string(), "Suche".to_string());

        let mut fallback = HashMap::new();
        fallback.insert("app.titles.search".to_string(), "Search".to_string());
        fallback.insert("app.titles.help".to_string(), "Help".to_string());

        assert_eq!(
            translate_with_fallback("app.titles.search", &primary, &fallback),
            "Suche"
        );
        assert_eq!(
            translate_with_fallback("app.titles.help", &primary, &fallback),
            "Help"
        );
        assert_eq!(
            translate_with_fallback("app.titles.missing", &primary, &fallback),
            "app.titles.missing"
        );
    }
}