Special case English fallback, improve lifetimes

Author: Manishearth

src/i18n.rs

@@ -22,46 +22,44 @@ lazy_static! {
         read_from_file("./locales/core.ftl").expect("cannot find core.ftl");
     static ref RESOURCES: HashMap<String, Vec<FluentResource>> = build_resources();
     static ref BUNDLES: HashMap<String, FluentBundle<'static>> = build_bundles();
-    static ref LOCALES: Vec<String> = build_locale_list();
+    static ref LOCALES: Vec<&'static str> = RESOURCES.iter().map(|(l, _)| &**l).collect();
+    static ref FALLBACKS: HashMap<String, Vec<String>> = build_fallbacks();
 }
 
-pub struct Fallback<'res> {
-    default: Option<&'res str>,
-    availables: &'res Vec<String>,
-}
-
-impl<'res> Fallback<'res> {
-    pub fn new(available_locales: &'res Vec<String>) -> Self {
-        Self {
-            default: Some("en-US"),
-            availables: available_locales,
-        }
-    }
-
-    pub fn order<'t, T: AsRef<str>>(&'t self, targets: &'t [T]) -> Vec<&'t str> {
-        negotiate_languages(
-            targets,
-            &self.availables,
-            self.default,
-            &fluent_locale::NegotiationStrategy::Filtering,
-        )
-    }
+pub fn build_fallbacks() -> HashMap<String, Vec<String>> {
+    LOCALES
+        .iter()
+        .map(|locale| {
+            (
+                locale.to_string(),
+                negotiate_languages(
+                    &[locale],
+                    &LOCALES,
+                    None,
+                    &fluent_locale::NegotiationStrategy::Filtering,
+                )
+                .into_iter()
+                .map(|x| x.to_string())
+                .collect(),
+            )
+        })
+        .collect()
 }
 
 pub struct I18NHelper {
     bundles: &'static HashMap<String, FluentBundle<'static>>,
-    fallback: Fallback<'static>,
+    fallbacks: &'static HashMap<String, Vec<String>>,
 }
 
 impl I18NHelper {
     pub fn new() -> Self {
         Self {
             bundles: &*BUNDLES,
-            fallback: Fallback::new(&*LOCALES),
+            fallbacks: &*FALLBACKS,
         }
     }
 
-    pub fn lookup(
+    pub fn lookup_single_language(
         &self,
         lang: &str,
         text_id: &str,
@@ -83,19 +81,42 @@ impl I18NHelper {
             panic!("Unknown language {}", lang)
         }
     }
-    pub fn lookup_with_fallback(
+
+    // Traverse the fallback chain,
+    pub fn lookup(
         &self,
         lang: &str,
         text_id: &str,
         args: Option<&HashMap<&str, FluentValue>>,
     ) -> String {
-        for l in self.fallback.order(&[lang]) {
-            if let Some(val) = self.lookup(l, text_id, args) {
+        for l in self.fallbacks.get(lang).expect("language not found") {
+            if let Some(val) = self.lookup_single_language(l, text_id, args) {
+                return val;
+            }
+        }
+        if lang != "en-US" {
+            if let Some(val) = self.lookup_single_language("en-US", text_id, args) {
                 return val;
             }
         }
         format!("Unknown localization {}", text_id)
     }
+
+    // Don't fall back to English
+    pub fn lookup_no_english(
+        &self,
+        lang: &str,
+        text_id: &str,
+        args: Option<&HashMap<&str, FluentValue>>,
+    ) -> Option<String> {
+        for l in self.fallbacks.get(lang).expect("language not found") {
+            if let Some(val) = self.lookup_single_language(l, text_id, args) {
+                return Some(val);
+            }
+        }
+
+        None
+    }
 }
 
 #[derive(Default)]
@@ -197,7 +218,7 @@ impl HelperDef for I18NHelper {
             .as_bool()
             .expect("Pontoon must be boolean");
 
-        let response = self.lookup_with_fallback(lang, &id, args.as_ref());
+        let response = self.lookup(lang, &id, args.as_ref());
         if pontoon {
             out.write(&format!("<span data-l10n-id='{}'>", id))
                 .map_err(RenderError::with)?;
@@ -288,7 +309,7 @@ impl HelperDef for TeamHelper {
         if lang == "en-US" {
             let english = team["website_data"][id].as_str().unwrap();
             out.write(&english).map_err(RenderError::with)?;
-        } else if let Some(value) = self.i18n.lookup(lang, &fluent_id, None) {
+        } else if let Some(value) = self.i18n.lookup_no_english(lang, &fluent_id, None) {
             out.write(&value).map_err(RenderError::with)?;
         } else {
             let english = team["website_data"][id].as_str().unwrap();
@@ -334,14 +355,6 @@ pub fn create_bundle(lang: &str, resources: &'static Vec<FluentResource>) -> Flu
     bundle
 }
 
-fn build_locale_list() -> Vec<String> {
-    let mut locale_list = Vec::new();
-    for key in RESOURCES.keys() {
-        locale_list.push(key.clone());
-    }
-    locale_list
-}
-
 fn build_resources() -> HashMap<String, Vec<FluentResource>> {
     let mut all_resources = HashMap::new();
     let entries = read_dir("./locales").unwrap();