Skip to main content

vibe/
locale.rs

1//! Keyword locale tables — multi-lingual keyword views (T37).
2//!
3//! VibeScript keywords are canonically English. This module provides
4//! locale tables that map keywords from other languages to the
5//! canonical English forms. The parser accepts any locale's keyword
6//! and normalises it to the canonical English form.
7//!
8//! ## Design
9//!
10//! - [`Locale`] identifies a language locale (e.g. `en`, `zh`).
11//! - [`LocaleTable`] maps locale-specific keywords to canonical forms.
12//! - [`LocaleRegistry`] holds tables for all supported locales.
13//! - The parser can use [`LocaleRegistry::resolve`] to check if a
14//!   token is a keyword in any locale and get the canonical form.
15//!
16//! ## Ship `en` plus one second locale as proof of pipeline
17//!
18//! English (`en`) is the canonical locale. Chinese (`zh`) is shipped
19//! as the second locale to prove the pipeline works. Adding more
20//! locales is a matter of adding more tables.
21//!
22//! Reference: `docs/vibescript-full-impl-PLAN.md` §8.8 T37.
23
24use std::collections::HashMap;
25
26/// A language locale identifier (e.g. "en", "zh").
27#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
28pub struct Locale(&'static str);
29
30impl Locale {
31    /// English locale (canonical).
32    pub const EN: Locale = Locale("en");
33    /// Chinese locale.
34    pub const ZH: Locale = Locale("zh");
35    /// Spanish locale.
36    pub const ES: Locale = Locale("es");
37    /// Japanese locale.
38    pub const JA: Locale = Locale("ja");
39    /// Arabic locale.
40    pub const AR: Locale = Locale("ar");
41    /// Hindi locale.
42    pub const HI: Locale = Locale("hi");
43    /// French locale.
44    pub const FR: Locale = Locale("fr");
45    /// German locale.
46    pub const DE: Locale = Locale("de");
47
48    /// Get the locale code as a string.
49    pub fn code(&self) -> &'static str {
50        self.0
51    }
52}
53
54impl std::fmt::Display for Locale {
55    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
56        write!(f, "{}", self.0)
57    }
58}
59
60/// A keyword locale table — maps locale-specific keywords to canonical
61/// English forms.
62#[derive(Debug, Clone)]
63pub struct LocaleTable {
64    /// The locale this table is for.
65    pub locale: Locale,
66    /// Map from locale-specific keyword → canonical English keyword.
67    pub keywords: HashMap<&'static str, &'static str>,
68}
69
70impl LocaleTable {
71    /// Create a new empty table for the given locale.
72    pub fn new(locale: Locale) -> Self {
73        Self {
74            locale,
75            keywords: HashMap::new(),
76        }
77    }
78
79    /// Look up the canonical form of a locale-specific keyword.
80    pub fn resolve(&self, keyword: &str) -> Option<&'static str> {
81        self.keywords.get(keyword).copied()
82    }
83
84    /// Number of keywords in this table.
85    pub fn len(&self) -> usize {
86        self.keywords.len()
87    }
88
89    /// Is this table empty?
90    pub fn is_empty(&self) -> bool {
91        self.keywords.is_empty()
92    }
93}
94
95/// The English locale table (canonical — keywords map to themselves).
96pub fn english_table() -> LocaleTable {
97    let mut t = LocaleTable::new(Locale::EN);
98    for kw in ENGLISH_KEYWORDS {
99        t.keywords.insert(kw, kw);
100    }
101    t
102}
103
104/// The Chinese locale table.
105pub fn chinese_table() -> LocaleTable {
106    let mut t = LocaleTable::new(Locale::ZH);
107    t.keywords.insert("如果", "if");
108    t.keywords.insert("否则", "else");
109    t.keywords.insert("对于", "for");
110    t.keywords.insert("在", "in");
111    t.keywords.insert("当", "while");
112    t.keywords.insert("匹配", "match");
113    t.keywords.insert("返回", "return");
114    t.keywords.insert("让", "let");
115    t.keywords.insert("可变", "mut");
116    t.keywords.insert("常量", "const");
117    t.keywords.insert("真", "true");
118    t.keywords.insert("假", "false");
119    t.keywords.insert("空", "null");
120    t.keywords.insert("函数", "fn");
121    t.keywords.insert("单元", "cell");
122    t.keywords.insert("模块", "module");
123    t.keywords.insert("导入", "import");
124    t.keywords.insert("作为", "as");
125    t.keywords.insert("要求", "requires");
126    t.keywords.insert("能力", "capability");
127    t.keywords.insert("异步", "async");
128    t.keywords.insert("作用", "effect");
129    t.keywords.insert("纯", "pure");
130    t.keywords.insert("事务", "transaction");
131    t.keywords.insert("等待", "await");
132    t.keywords.insert("产出", "yield");
133    t.keywords.insert("前缀", "prefix");
134    t.keywords.insert("于", "on");
135    t.keywords.insert("枚举", "enum");
136    t.keywords.insert("场", "field");
137    t.keywords.insert("材料", "material");
138    t.keywords.insert("定律", "law");
139    t.keywords.insert("当条件", "when");
140    t.keywords.insert("热", "hot");
141    t.keywords.insert("冷", "cold");
142    t.keywords.insert("使用", "using");
143    t.keywords.insert("语言", "locale");
144    t.keywords.insert("呈现", "present");
145    t.keywords.insert("义务", "obligate");
146    t.keywords.insert("允许", "permit");
147    t.keywords.insert("禁止", "forbid");
148    t.keywords.insert("知道", "knows");
149    t.keywords.insert("相信", "believes");
150    t.keywords.insert("总是", "always");
151    t.keywords.insert("终将", "eventually");
152    t.keywords.insert("直到", "until");
153    t.keywords.insert("绑定", "bind");
154    t
155}
156
157/// The Spanish locale table.
158pub fn spanish_table() -> LocaleTable {
159    let mut t = LocaleTable::new(Locale::ES);
160    t.keywords.insert("si", "if");
161    t.keywords.insert("sino", "else");
162    t.keywords.insert("para", "for");
163    t.keywords.insert("en", "in");
164    t.keywords.insert("mientras", "while");
165    t.keywords.insert("coincidir", "match");
166    t.keywords.insert("retornar", "return");
167    t.keywords.insert("sea", "let");
168    t.keywords.insert("mutable", "mut");
169    t.keywords.insert("constante", "const");
170    t.keywords.insert("verdadero", "true");
171    t.keywords.insert("falso", "false");
172    t.keywords.insert("nulo", "null");
173    t.keywords.insert("fun", "fn");
174    t.keywords.insert("célula", "cell");
175    t.keywords.insert("módulo", "module");
176    t.keywords.insert("importar", "import");
177    t.keywords.insert("como", "as");
178    t.keywords.insert("requiere", "requires");
179    t.keywords.insert("capacidad", "capability");
180    t.keywords.insert("asinc", "async");
181    t.keywords.insert("efecto", "effect");
182    t.keywords.insert("puro", "pure");
183    t.keywords.insert("transacción", "transaction");
184    t.keywords.insert("esperar", "await");
185    t.keywords.insert("ceder", "yield");
186    t.keywords.insert("prefijo", "prefix");
187    t.keywords.insert("al", "on");
188    t.keywords.insert("enumeración", "enum");
189    t.keywords.insert("campo", "field");
190    t.keywords.insert("material", "material");
191    t.keywords.insert("ley", "law");
192    t.keywords.insert("cuando", "when");
193    t.keywords.insert("caliente", "hot");
194    t.keywords.insert("frío", "cold");
195    t.keywords.insert("usando", "using");
196    t.keywords.insert("idioma", "locale");
197    t.keywords.insert("presentar", "present");
198    t.keywords.insert("obligar", "obligate");
199    t.keywords.insert("permitir", "permit");
200    t.keywords.insert("prohibir", "forbid");
201    t.keywords.insert("conoce", "knows");
202    t.keywords.insert("cree", "believes");
203    t.keywords.insert("siempre", "always");
204    t.keywords.insert("eventualmente", "eventually");
205    t.keywords.insert("hastaque", "until");
206    t.keywords.insert("vincular", "bind");
207    t
208}
209
210/// The Japanese locale table.
211pub fn japanese_table() -> LocaleTable {
212    let mut t = LocaleTable::new(Locale::JA);
213    t.keywords.insert("もし", "if");
214    t.keywords.insert("他", "else");
215    t.keywords.insert("反復", "for");
216    t.keywords.insert("要素", "in");
217    t.keywords.insert("間", "while");
218    t.keywords.insert("一致", "match");
219    t.keywords.insert("戻す", "return");
220    t.keywords.insert("設", "let");
221    t.keywords.insert("可変", "mut");
222    t.keywords.insert("定数", "const");
223    t.keywords.insert("真", "true");
224    t.keywords.insert("偽", "false");
225    t.keywords.insert("無", "null");
226    t.keywords.insert("関数", "fn");
227    t.keywords.insert("セル", "cell");
228    t.keywords.insert("モジュール", "module");
229    t.keywords.insert("インポート", "import");
230    t.keywords.insert("別名", "as");
231    t.keywords.insert("要求", "requires");
232    t.keywords.insert("機能", "capability");
233    t.keywords.insert("非同期", "async");
234    t.keywords.insert("作用", "effect");
235    t.keywords.insert("純粋", "pure");
236    t.keywords.insert("トランザクション", "transaction");
237    t.keywords.insert("待機", "await");
238    t.keywords.insert("譲渡", "yield");
239    t.keywords.insert("接頭辞", "prefix");
240    t.keywords.insert("時", "on");
241    t.keywords.insert("列挙", "enum");
242    t.keywords.insert("場", "field");
243    t.keywords.insert("物質", "material");
244    t.keywords.insert("法則", "law");
245    t.keywords.insert("場合", "when");
246    t.keywords.insert("高速", "hot");
247    t.keywords.insert("低速", "cold");
248    t.keywords.insert("使用中", "using");
249    t.keywords.insert("言語", "locale");
250    t.keywords.insert("提示", "present");
251    t.keywords.insert("義務", "obligate");
252    t.keywords.insert("許可", "permit");
253    t.keywords.insert("禁止", "forbid");
254    t.keywords.insert("知る", "knows");
255    t.keywords.insert("信じる", "believes");
256    t.keywords.insert("常に", "always");
257    t.keywords.insert("やがて", "eventually");
258    t.keywords.insert("迄", "until");
259    t.keywords.insert("結合", "bind");
260    t
261}
262
263/// The Arabic locale table.
264pub fn arabic_table() -> LocaleTable {
265    let mut t = LocaleTable::new(Locale::AR);
266    t.keywords.insert("إذا", "if");
267    t.keywords.insert("وإلا", "else");
268    t.keywords.insert("لكل", "for");
269    t.keywords.insert("في", "in");
270    t.keywords.insert("طالما", "while");
271    t.keywords.insert("طابق", "match");
272    t.keywords.insert("أرجع", "return");
273    t.keywords.insert("دع", "let");
274    t.keywords.insert("متغير", "mut");
275    t.keywords.insert("ثابت", "const");
276    t.keywords.insert("صحيح", "true");
277    t.keywords.insert("خطأ", "false");
278    t.keywords.insert("فارغ", "null");
279    t.keywords.insert("دالة", "fn");
280    t.keywords.insert("خلية", "cell");
281    t.keywords.insert("وحدة", "module");
282    t.keywords.insert("استيراد", "import");
283    t.keywords.insert("باسم", "as");
284    t.keywords.insert("يتطلب", "requires");
285    t.keywords.insert("صلاحية", "capability");
286    t.keywords.insert("لاتزامني", "async");
287    t.keywords.insert("تأثير", "effect");
288    t.keywords.insert("نقي", "pure");
289    t.keywords.insert("معاملة", "transaction");
290    t.keywords.insert("انتظر", "await");
291    t.keywords.insert("أنتج", "yield");
292    t.keywords.insert("بادئة", "prefix");
293    t.keywords.insert("عند", "on");
294    t.keywords.insert("تعداد", "enum");
295    t.keywords.insert("حقل", "field");
296    t.keywords.insert("مادة", "material");
297    t.keywords.insert("قانون", "law");
298    t.keywords.insert("حين", "when");
299    t.keywords.insert("ساخن", "hot");
300    t.keywords.insert("بارد", "cold");
301    t.keywords.insert("باستخدام", "using");
302    t.keywords.insert("لغة", "locale");
303    t.keywords.insert("اعرض", "present");
304    t.keywords.insert("يلزم", "obligate");
305    t.keywords.insert("يسمح", "permit");
306    t.keywords.insert("يحظر", "forbid");
307    t.keywords.insert("يعلم", "knows");
308    t.keywords.insert("يعتقد", "believes");
309    t.keywords.insert("دائما", "always");
310    t.keywords.insert("أخيرا", "eventually");
311    t.keywords.insert("حتى", "until");
312    t.keywords.insert("ربط", "bind");
313    t
314}
315
316/// The Hindi locale table.
317pub fn hindi_table() -> LocaleTable {
318    let mut t = LocaleTable::new(Locale::HI);
319    t.keywords.insert("यदि", "if");
320    t.keywords.insert("अन्यथा", "else");
321    t.keywords.insert("के_लिए", "for");
322    t.keywords.insert("में", "in");
323    t.keywords.insert("जब_तक", "while");
324    t.keywords.insert("मिलान", "match");
325    t.keywords.insert("वापस", "return");
326    t.keywords.insert("मान", "let");
327    t.keywords.insert("परिवर्तनीय", "mut");
328    t.keywords.insert("स्थिरांक", "const");
329    t.keywords.insert("सत्य", "true");
330    t.keywords.insert("असत्य", "false");
331    t.keywords.insert("रिक्त", "null");
332    t.keywords.insert("कार्य", "fn");
333    t.keywords.insert("सेल", "cell");
334    t.keywords.insert("मॉड्यूल", "module");
335    t.keywords.insert("आयात", "import");
336    t.keywords.insert("के_रूप_में", "as");
337    t.keywords.insert("आवश्यकता", "requires");
338    t.keywords.insert("क्षमता", "capability");
339    t.keywords.insert("अतुल्यकालिक", "async");
340    t.keywords.insert("प्रभाव", "effect");
341    t.keywords.insert("शुद्ध", "pure");
342    t.keywords.insert("लेनदेन", "transaction");
343    t.keywords.insert("प्रतीक्षा", "await");
344    t.keywords.insert("उत्पादन", "yield");
345    t.keywords.insert("उपसर्ग", "prefix");
346    t.keywords.insert("पर", "on");
347    t.keywords.insert("गणना", "enum");
348    t.keywords.insert("क्षेत्र", "field");
349    t.keywords.insert("सामग्री", "material");
350    t.keywords.insert("नियम", "law");
351    t.keywords.insert("जब", "when");
352    t.keywords.insert("तप्त", "hot");
353    t.keywords.insert("शीत", "cold");
354    t.keywords.insert("उपयोग", "using");
355    t.keywords.insert("भाषा", "locale");
356    t.keywords.insert("प्रस्तुत", "present");
357    t.keywords.insert("बाध्य", "obligate");
358    t.keywords.insert("अनुमति", "permit");
359    t.keywords.insert("निषेध", "forbid");
360    t.keywords.insert("जानता", "knows");
361    t.keywords.insert("मानता", "believes");
362    t.keywords.insert("हमेशा", "always");
363    t.keywords.insert("अंततः", "eventually");
364    t.keywords.insert("जबतक", "until");
365    t.keywords.insert("बांध", "bind");
366    t
367}
368
369/// The French locale table.
370pub fn french_table() -> LocaleTable {
371    let mut t = LocaleTable::new(Locale::FR);
372    t.keywords.insert("si", "if");
373    t.keywords.insert("sinon", "else");
374    t.keywords.insert("pour", "for");
375    t.keywords.insert("dans", "in");
376    t.keywords.insert("tantque", "while");
377    t.keywords.insert("correspondre", "match");
378    t.keywords.insert("retourner", "return");
379    t.keywords.insert("soit", "let");
380    t.keywords.insert("mutable", "mut");
381    t.keywords.insert("constante", "const");
382    t.keywords.insert("vrai", "true");
383    t.keywords.insert("faux", "false");
384    t.keywords.insert("nul", "null");
385    t.keywords.insert("fonction", "fn");
386    t.keywords.insert("cellule", "cell");
387    t.keywords.insert("module", "module");
388    t.keywords.insert("importer", "import");
389    t.keywords.insert("comme", "as");
390    t.keywords.insert("exige", "requires");
391    t.keywords.insert("capacité", "capability");
392    t.keywords.insert("asynchrone", "async");
393    t.keywords.insert("effet", "effect");
394    t.keywords.insert("pur", "pure");
395    t.keywords.insert("transaction", "transaction");
396    t.keywords.insert("attendre", "await");
397    t.keywords.insert("produire", "yield");
398    t.keywords.insert("préfixe", "prefix");
399    t.keywords.insert("sur", "on");
400    t.keywords.insert("énum", "enum");
401    t.keywords.insert("champ", "field");
402    t.keywords.insert("matériau", "material");
403    t.keywords.insert("loi", "law");
404    t.keywords.insert("lorsque", "when");
405    t.keywords.insert("chaud", "hot");
406    t.keywords.insert("froid", "cold");
407    t.keywords.insert("utilisant", "using");
408    t.keywords.insert("langue", "locale");
409    t.keywords.insert("présenter", "present");
410    t.keywords.insert("obliger", "obligate");
411    t.keywords.insert("permettre", "permit");
412    t.keywords.insert("interdire", "forbid");
413    t.keywords.insert("connait", "knows");
414    t.keywords.insert("croit", "believes");
415    t.keywords.insert("toujours", "always");
416    t.keywords.insert("finalement", "eventually");
417    t.keywords.insert("jusqua", "until");
418    t.keywords.insert("lier", "bind");
419    t
420}
421
422/// The German locale table.
423pub fn german_table() -> LocaleTable {
424    let mut t = LocaleTable::new(Locale::DE);
425    t.keywords.insert("wenn", "if");
426    t.keywords.insert("sonst", "else");
427    t.keywords.insert("für", "for");
428    t.keywords.insert("in", "in");
429    t.keywords.insert("solange", "while");
430    t.keywords.insert("abgleichen", "match");
431    t.keywords.insert("zurück", "return");
432    t.keywords.insert("sei", "let");
433    t.keywords.insert("veränderlich", "mut");
434    t.keywords.insert("konstante", "const");
435    t.keywords.insert("wahr", "true");
436    t.keywords.insert("falsch", "false");
437    t.keywords.insert("null", "null");
438    t.keywords.insert("funktion", "fn");
439    t.keywords.insert("zelle", "cell");
440    t.keywords.insert("modul", "module");
441    t.keywords.insert("importieren", "import");
442    t.keywords.insert("als", "as");
443    t.keywords.insert("erfordert", "requires");
444    t.keywords.insert("fähigkeit", "capability");
445    t.keywords.insert("asynchron", "async");
446    t.keywords.insert("wirkung", "effect");
447    t.keywords.insert("rein", "pure");
448    t.keywords.insert("transaktion", "transaction");
449    t.keywords.insert("abwarten", "await");
450    t.keywords.insert("ergeben", "yield");
451    t.keywords.insert("präfix", "prefix");
452    t.keywords.insert("bei", "on");
453    t.keywords.insert("aufzählung", "enum");
454    t.keywords.insert("feld", "field");
455    t.keywords.insert("material", "material");
456    t.keywords.insert("gesetz", "law");
457    t.keywords.insert("wann", "when");
458    t.keywords.insert("heiß", "hot");
459    t.keywords.insert("kalt", "cold");
460    t.keywords.insert("nutzend", "using");
461    t.keywords.insert("sprache", "locale");
462    t.keywords.insert("präsentieren", "present");
463    t.keywords.insert("verpflichten", "obligate");
464    t.keywords.insert("erlauben", "permit");
465    t.keywords.insert("verbieten", "forbid");
466    t.keywords.insert("weiss", "knows");
467    t.keywords.insert("glaubt", "believes");
468    t.keywords.insert("immer", "always");
469    t.keywords.insert("schliesslich", "eventually");
470    t.keywords.insert("solangebis", "until");
471    t.keywords.insert("binden", "bind");
472    t
473}
474
475/// The canonical English keyword list.
476pub const ENGLISH_KEYWORDS: &[&str] = &[
477    "module",
478    "import",
479    "as",
480    "prefix",
481    "requires",
482    "capability",
483    "fn",
484    "cell",
485    "async",
486    "on",
487    "let",
488    "mut",
489    "const",
490    "enum",
491    "field",
492    "material",
493    "law",
494    "when",
495    "if",
496    "else",
497    "for",
498    "in",
499    "while",
500    "match",
501    "return",
502    "yield",
503    "transaction",
504    "await",
505    "true",
506    "false",
507    "null",
508    "effect",
509    "pure",
510    "hot",
511    "cold",
512    "using",
513    "locale",
514    "present",
515    "obligate",
516    "permit",
517    "forbid",
518    "knows",
519    "believes",
520    "always",
521    "eventually",
522    "until",
523    "bind",
524];
525
526/// A registry of locale tables.
527#[derive(Debug, Clone)]
528pub struct LocaleRegistry {
529    tables: Vec<LocaleTable>,
530    /// Reverse index: locale-specific keyword → (locale, canonical).
531    keyword_index: HashMap<&'static str, (Locale, &'static str)>,
532}
533
534impl Default for LocaleRegistry {
535    fn default() -> Self {
536        Self::with_all_locales()
537    }
538}
539
540impl LocaleRegistry {
541    /// Create a registry with all supported locales: en, zh, es, ja, ar, hi, fr, de.
542    pub fn with_all_locales() -> Self {
543        Self::new(vec![
544            english_table(),
545            chinese_table(),
546            spanish_table(),
547            japanese_table(),
548            arabic_table(),
549            hindi_table(),
550            french_table(),
551            german_table(),
552        ])
553    }
554
555    /// Create a registry with English and Chinese tables.
556    pub fn with_en_and_zh() -> Self {
557        Self::new(vec![english_table(), chinese_table()])
558    }
559
560    /// Create a registry with the given tables.
561    pub fn new(tables: Vec<LocaleTable>) -> Self {
562        let mut keyword_index = HashMap::new();
563        for table in &tables {
564            for (&kw, &canonical) in &table.keywords {
565                keyword_index.insert(kw, (table.locale, canonical));
566            }
567        }
568        Self {
569            tables,
570            keyword_index,
571        }
572    }
573
574    /// Resolve a keyword from any locale to its canonical English form.
575    /// Returns (locale, canonical_keyword) if found.
576    pub fn resolve(&self, keyword: &str) -> Option<(Locale, &'static str)> {
577        self.keyword_index.get(keyword).copied()
578    }
579
580    /// Check if a string is a keyword in any locale.
581    pub fn is_keyword(&self, text: &str) -> bool {
582        self.keyword_index.contains_key(text)
583    }
584
585    /// Get the table for a specific locale.
586    pub fn table_for(&self, locale: Locale) -> Option<&LocaleTable> {
587        self.tables.iter().find(|t| t.locale == locale)
588    }
589
590    /// Number of registered locales.
591    pub fn locale_count(&self) -> usize {
592        self.tables.len()
593    }
594
595    /// Total number of keywords across all locales.
596    pub fn total_keywords(&self) -> usize {
597        self.keyword_index.len()
598    }
599}
600
601#[cfg(test)]
602mod tests {
603    use super::*;
604
605    #[test]
606    fn english_table_is_canonical() {
607        let t = english_table();
608        assert_eq!(t.locale, Locale::EN);
609        // English keywords map to themselves.
610        assert_eq!(t.resolve("if"), Some("if"));
611        assert_eq!(t.resolve("let"), Some("let"));
612        assert_eq!(t.resolve("return"), Some("return"));
613        assert_eq!(t.resolve("fn"), Some("fn"));
614    }
615
616    #[test]
617    fn english_table_has_all_keywords() {
618        let t = english_table();
619        for kw in ENGLISH_KEYWORDS {
620            assert!(t.resolve(kw).is_some(), "missing English keyword: {kw}");
621        }
622    }
623
624    #[test]
625    fn chinese_table_maps_to_english() {
626        let t = chinese_table();
627        assert_eq!(t.locale, Locale::ZH);
628        assert_eq!(t.resolve("如果"), Some("if"));
629        assert_eq!(t.resolve("返回"), Some("return"));
630        assert_eq!(t.resolve("让"), Some("let"));
631        assert_eq!(t.resolve("函数"), Some("fn"));
632        assert_eq!(t.resolve("真"), Some("true"));
633    }
634
635    #[test]
636    fn chinese_table_not_empty() {
637        let t = chinese_table();
638        assert!(!t.is_empty());
639        assert!(t.len() > 0);
640    }
641
642    #[test]
643    fn registry_resolves_english() {
644        let reg = LocaleRegistry::with_en_and_zh();
645        let (locale, canonical) = reg.resolve("if").unwrap();
646        assert_eq!(locale, Locale::EN);
647        assert_eq!(canonical, "if");
648    }
649
650    #[test]
651    fn registry_resolves_chinese() {
652        let reg = LocaleRegistry::with_en_and_zh();
653        let (locale, canonical) = reg.resolve("如果").unwrap();
654        assert_eq!(locale, Locale::ZH);
655        assert_eq!(canonical, "if");
656    }
657
658    #[test]
659    fn registry_is_keyword() {
660        let reg = LocaleRegistry::with_en_and_zh();
661        assert!(reg.is_keyword("if"));
662        assert!(reg.is_keyword("如果"));
663        assert!(reg.is_keyword("let"));
664        assert!(reg.is_keyword("让"));
665        assert!(!reg.is_keyword("not_a_keyword"));
666        assert!(!reg.is_keyword("xyz"));
667    }
668
669    #[test]
670    fn registry_table_for_locale() {
671        let reg = LocaleRegistry::with_en_and_zh();
672        let en = reg.table_for(Locale::EN);
673        assert!(en.is_some());
674        assert_eq!(en.unwrap().locale, Locale::EN);
675        let zh = reg.table_for(Locale::ZH);
676        assert!(zh.is_some());
677        assert_eq!(zh.unwrap().locale, Locale::ZH);
678    }
679
680    #[test]
681    fn registry_resolves_all_locales() {
682        let reg = LocaleRegistry::with_all_locales();
683        assert_eq!(reg.resolve("sea").unwrap(), (Locale::ES, "let"));
684        assert_eq!(reg.resolve("soit").unwrap(), (Locale::FR, "let"));
685        assert_eq!(reg.resolve("もし").unwrap(), (Locale::JA, "if"));
686        assert_eq!(reg.resolve("إذا").unwrap(), (Locale::AR, "if"));
687        assert_eq!(reg.resolve("यदि").unwrap(), (Locale::HI, "if"));
688        assert_eq!(reg.resolve("wenn").unwrap(), (Locale::DE, "if"));
689        assert_eq!(reg.resolve("如果").unwrap(), (Locale::ZH, "if"));
690        assert_eq!(reg.resolve("if").unwrap(), (Locale::EN, "if"));
691    }
692
693    #[test]
694    fn registry_locale_count_all() {
695        let reg = LocaleRegistry::with_all_locales();
696        assert_eq!(reg.locale_count(), 8);
697    }
698
699    #[test]
700    fn registry_default_is_all_locales() {
701        let reg = LocaleRegistry::default();
702        assert_eq!(reg.locale_count(), 8);
703        assert!(reg.table_for(Locale::EN).is_some());
704        assert!(reg.table_for(Locale::ZH).is_some());
705        assert!(reg.table_for(Locale::ES).is_some());
706        assert!(reg.table_for(Locale::JA).is_some());
707        assert!(reg.table_for(Locale::AR).is_some());
708        assert!(reg.table_for(Locale::HI).is_some());
709        assert!(reg.table_for(Locale::FR).is_some());
710        assert!(reg.table_for(Locale::DE).is_some());
711    }
712
713    #[test]
714    fn chinese_modal_verbs_map_to_english() {
715        let t = chinese_table();
716        assert_eq!(t.resolve("义务"), Some("obligate"));
717        assert_eq!(t.resolve("允许"), Some("permit"));
718        assert_eq!(t.resolve("禁止"), Some("forbid"));
719        assert_eq!(t.resolve("知道"), Some("knows"));
720        assert_eq!(t.resolve("相信"), Some("believes"));
721        assert_eq!(t.resolve("总是"), Some("always"));
722        assert_eq!(t.resolve("终将"), Some("eventually"));
723        assert_eq!(t.resolve("直到"), Some("until"));
724    }
725}