Skip to content

A tiny friend in your Mac's notch and on your iPhone that keeps an eye on your AI coding agents: Claude Code, Codex, Cursor, Gemini CLI, Antigravity and more. Approve from the notch or your Lock Screen.

12.5 KB
Raw Blame
// Interface language for what Rust shows: the tray menu, the settings window
// title and the errors the webviews display. Same tables and same lookup as
// src/i18n/i18n.ts: strings keyed by their English text, from the Mac's catalog
// (strings.json, generated by scripts/gen-strings.mjs) and the Windows/Linux
// only ones (extra.json). A string missing in a language shows in English.
//
// The language is Settings.language when it is one of ours; "" follows the
// system: the languages the island's webview reports at launch, else (Linux)
// the LANGUAGE / LC_ALL / LC_MESSAGES / LANG variables, else English.

use serde_json::{Map, Value};
use std::collections::HashMap;
use std::sync::{OnceLock, RwLock};

pub const LANGUAGES: [&str; 14] = ["en", "zh-Hans", "hi", "es", "ar", "fr", "bn", "pt-BR", "ru", "id", "de", "tr", "ko", "ja"];

static MAC: &str = include_str!("../../src/i18n/strings.json");
static EXTRA: &str = include_str!("../../src/i18n/extra.json");

type Table = HashMap<String, Map<String, Value>>;

fn table() -> &'static Table {
    static TABLE: OnceLock<Table> = OnceLock::new();
    TABLE.get_or_init(|| {
        let mut out = Table::new();
        // extra.json goes last: it wins where both have a string.
        for source in [MAC, EXTRA] {
            let Ok(Value::Object(root)) = serde_json::from_str::<Value>(source) else { continue };
            let Some(Value::Object(strings)) = root.get("strings") else { continue };
            for (key, entry) in strings {
                if let Value::Object(langs) = entry {
                    out.insert(key.clone(), langs.clone());
                }
            }
        }
        out
    })
}

struct Current {
    picked: String,
    system: Vec<String>,
    resolved: &'static str,
}

fn state() -> &'static RwLock<Current> {
    static STATE: OnceLock<RwLock<Current>> = OnceLock::new();
    STATE.get_or_init(|| {
        let system = env_languages();
        let resolved = resolve("", &system);
        RwLock::new(Current { picked: String::new(), system, resolved })
    })
}

/// LANGUAGE (a list), then LC_ALL, LC_MESSAGES and LANG, as gettext reads them.
fn env_languages() -> Vec<String> {
    let mut out = Vec::new();
    if let Ok(list) = std::env::var("LANGUAGE") {
        out.extend(list.split(':').filter(|s| !s.is_empty()).map(str::to_string));
    }
    for name in ["LC_ALL", "LC_MESSAGES", "LANG"] {
        if let Ok(v) = std::env::var(name) {
            if !v.is_empty() && v != "C" && v != "POSIX" {
                out.push(v);
            }
        }
    }
    out
}

/// The language to show: `picked` when it is one of ours, else the first of
/// the system's languages we have, else English. Same rules as resolveLanguage
/// in src/i18n/i18n.ts.
pub fn resolve(picked: &str, system: &[String]) -> &'static str {
    if let Some(code) = LANGUAGES.iter().find(|c| **c == picked) {
        return code;
    }
    for raw in system {
        // "fr_FR.UTF-8" → "fr-fr"
        let tag = raw.split('.').next().unwrap_or("").replace('_', "-").to_lowercase();
        let base = tag.split('-').next().unwrap_or("");
        if base.is_empty() {
            continue;
        }
        if base == "zh" {
            let traditional = ["zh-hant", "zh-tw", "zh-hk", "zh-mo"].iter().any(|p| tag.starts_with(p));
            if traditional {
                continue;
            }
            return "zh-Hans";
        }
        if base == "pt" {
            return "pt-BR";
        }
        if let Some(code) = LANGUAGES.iter().find(|c| c.to_lowercase() == base) {
            return code;
        }
    }
    "en"
}

/// Records Settings.language. Returns true when the shown language changed.
pub fn set_picked(picked: &str) -> bool {
    let mut s = state().write().unwrap_or_else(|e| e.into_inner());
    s.picked = picked.to_string();
    let next = resolve(&s.picked, &s.system);
    std::mem::replace(&mut s.resolved, next) != next
}

/// Records the system's languages as the webview sees them. Returns true when
/// the shown language changed.
pub fn set_system(languages: Vec<String>) -> bool {
    let mut s = state().write().unwrap_or_else(|e| e.into_inner());
    if !languages.is_empty() {
        s.system = languages;
    }
    let next = resolve(&s.picked, &s.system);
    std::mem::replace(&mut s.resolved, next) != next
}

/// The language shown now.
pub fn current() -> &'static str {
    #[cfg(test)]
    return TEST_LANG.with(|c| c.get());
    #[cfg(not(test))]
    state().read().unwrap_or_else(|e| e.into_inner()).resolved
}

// Tests run in parallel and many check English text: each test thread has its
// own language, English unless the test picks another.
#[cfg(test)]
thread_local! {
    static TEST_LANG: std::cell::Cell<&'static str> = const { std::cell::Cell::new("en") };
}

fn interpolate(text: &str, vars: &[(&str, &str)]) -> String {
    let mut out = text.to_string();
    for (name, value) in vars {
        out = out.replace(&format!("{{{name}}}"), value);
    }
    out
}

fn lookup_in(lang: &str, key: &str) -> Option<&'static Value> {
    if lang == "en" {
        return None;
    }
    table().get(key)?.get(lang)
}

/// CLDR plural category of `n` (whole numbers) in `lang`.
fn plural_category(lang: &str, n: u64) -> &'static str {
    match lang {
        "zh-Hans" | "id" | "ko" | "ja" => "other",
        "fr" | "pt-BR" | "hi" | "bn" => {
            if n <= 1 { "one" } else { "other" }
        }
        "ru" => {
            let (m10, m100) = (n % 10, n % 100);
            if m10 == 1 && m100 != 11 {
                "one"
            } else if (2..=4).contains(&m10) && !(12..=14).contains(&m100) {
                "few"
            } else {
                "many"
            }
        }
        "ar" => match (n, n % 100) {
            (0, _) => "zero",
            (1, _) => "one",
            (2, _) => "two",
            (_, 3..=10) => "few",
            (_, 11..=99) => "many",
            _ => "other",
        },
        _ => {
            if n == 1 { "one" } else { "other" }
        }
    }
}

fn pick_plural(forms: &Map<String, Value>, category: &str) -> Option<String> {
    forms
        .get(category)
        .or_else(|| forms.get("other"))
        .or_else(|| forms.values().next())
        .and_then(Value::as_str)
        .map(str::to_string)
}

/// Marks an English key for a table built before it is shown (the tray's
/// labels): the code translates it with `t` when it shows it. The i18n test
/// (tests/i18n.test.mjs) finds the keys through it.
pub const fn n_(key: &'static str) -> &'static str {
    key
}

/// `key` (English text) in the shown language, else the English text.
pub fn t(key: &str) -> String {
    tf(key, &[])
}

/// `t` with `{name}` placeholders filled in.
pub fn tf(key: &str, vars: &[(&str, &str)]) -> String {
    let lang = current();
    let text = match lookup_in(lang, key) {
        Some(Value::String(s)) => s.clone(),
        Some(Value::Object(forms)) => pick_plural(forms, "other").unwrap_or_else(|| key.to_string()),
        _ => key.to_string(),
    };
    interpolate(&text, vars)
}

/// A count with its words: `tn("{count} file", "{count} files", n, &[])`.
#[allow(dead_code)]
pub fn tn(one: &str, other: &str, count: u64, vars: &[(&str, &str)]) -> String {
    let lang = current();
    let n = count.to_string();
    let mut all: Vec<(&str, &str)> = vars.to_vec();
    all.push(("count", &n));
    let text = match lookup_in(lang, other) {
        Some(Value::Object(forms)) => pick_plural(forms, plural_category(lang, count)),
        Some(Value::String(s)) => Some(s.clone()),
        _ => None,
    };
    let text = text.unwrap_or_else(|| if count == 1 { one.to_string() } else { other.to_string() });
    interpolate(&text, &all)
}

#[cfg(test)]
pub(crate) fn set_for_test(lang: &str) {
    TEST_LANG.with(|c| c.set(resolve(lang, &[])));
}

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

    #[test]
    fn resolves_like_the_webview() {
        let sys = |v: &[&str]| v.iter().map(|s| s.to_string()).collect::<Vec<_>>();
        assert_eq!(resolve("fr", &sys(&["ru"])), "fr");
        assert_eq!(resolve("", &sys(&["fr_FR.UTF-8"])), "fr");
        assert_eq!(resolve("", &sys(&["pt-PT"])), "pt-BR");
        assert_eq!(resolve("", &sys(&["zh-CN"])), "zh-Hans");
        assert_eq!(resolve("", &sys(&["zh-TW", "it", "es-MX"])), "es");
        assert_eq!(resolve("", &sys(&["it-IT"])), "en");
        assert_eq!(resolve("xx", &[]), "en");
    }

    #[test]
    fn looks_up_both_tables_and_falls_back_to_english() {
        set_for_test("fr");
        // From the Mac's catalog.
        assert_eq!(t("Allow"), "Autoriser");
        // From extra.json.
        assert_eq!(t("Open Coucou"), "Ouvrir Coucou");
        assert_eq!(t("A string nobody translated"), "A string nobody translated");
        assert_eq!(tf("Open {name}", &[("name", "Vercel")]), "Ouvrir Vercel");
        set_for_test("en");
        assert_eq!(t("Allow"), "Allow");
        assert_eq!(tf("Open {name}", &[("name", "Vercel")]), "Open Vercel");
    }

    #[test]
    fn plurals_follow_the_language() {
        set_for_test("en");
        assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 1, &[]), "✓ Connected · 1 model");
        assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 3, &[]), "✓ Connected · 3 models");
        set_for_test("es");
        assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 1, &[]), "✓ Conectado · 1 modelo");
        assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", 4, &[]), "✓ Conectado · 4 modelos");
        assert_eq!(plural_category("ru", 21), "one");
        assert_eq!(plural_category("ru", 23), "few");
        assert_eq!(plural_category("ru", 25), "many");
        assert_eq!(plural_category("ar", 2), "two");
        set_for_test("en");
    }

    #[test]
    fn every_extra_string_has_every_language() {
        let Value::Object(root) = serde_json::from_str::<Value>(EXTRA).unwrap() else { panic!() };
        let Some(Value::Object(strings)) = root.get("strings") else { panic!("no strings") };
        for (key, entry) in strings {
            for lang in LANGUAGES.iter().filter(|l| **l != "en") {
                assert!(entry.get(*lang).is_some(), "{key:?} has no {lang}");
            }
        }
    }

    #[test]
    fn german_resolves_translates_and_selects_singular_only_for_one() {
        for tag in ["de", "de-DE", "de-AT", "de-CH", "de_DE.UTF-8"] {
            assert_eq!(resolve("", &[tag.to_string()]), "de");
        }
        assert_eq!(resolve("de", &["fr-FR".to_string()]), "de");
        assert_eq!(resolve("fr", &["de-DE".to_string()]), "fr");
        set_for_test("de");
        assert_eq!(t("Allow"), "Zulassen");
        assert_eq!(t("Deny"), "Ablehnen");
        assert_eq!(t("Open the chat"), "Chat öffnen");
        assert_eq!(tf("Uploading {name}", &[("name", "Grüße.pdf")]), "Grüße.pdf wird hochgeladen");
        assert_eq!(t("A string nobody translated"), "A string nobody translated");
        for count in [0, 1, 2, 21] {
            assert_eq!(plural_category("de", count), if count == 1 { "one" } else { "other" });
            let repo = if count == 1 { "Repository" } else { "Repositorys" };
            let model = if count == 1 { "Modell" } else { "Modelle" };
            assert_eq!(tn("{count} repo", "{count} repos", count, &[]), format!("{count} {repo}"));
            assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", count, &[]),
                format!("✓ Verbunden · {count} {model}"));
        }
        set_for_test("en");
    }

    #[test]
    fn turkish_resolves_translates_and_preserves_counted_nouns() {
        let system = |tag: &str| vec![tag.to_string()];
        assert_eq!(resolve("tr", &system("en-US")), "tr");
        for tag in ["tr", "tr-TR", "tr_TR.UTF-8"] {
            assert_eq!(resolve("", &system(tag)), "tr");
        }
        set_for_test("tr");
        assert_eq!(t("Allow"), "İzin ver");
        assert_eq!(t("Deny"), "Reddet");
        assert_eq!(t("Open the chat"), "Sohbeti aç");
        assert_eq!(tf("Uploading {name}", &[("name", "öğrenci.pdf")]), "öğrenci.pdf yükleniyor");
        assert_eq!(t("A string nobody translated"), "A string nobody translated");
        for n in [0, 1, 2, 21] {
            assert_eq!(plural_category("tr", n), if n == 1 { "one" } else { "other" });
            assert_eq!(tn("{count} repo", "{count} repos", n, &[]), format!("{n} depo"));
            assert_eq!(tn("✓ Connected · {count} model", "✓ Connected · {count} models", n, &[]),
                format!("✓ Bağlı · {n} model"));
        }
        set_for_test("en");
    }
}