Add i18n fallback

Author: renyuneyun

Cargo.lock

@@ -9,6 +9,7 @@ lazy_static = "1.2.0"
 fluent = "0.5"
 fluent-bundle = "0.6.0"
 fluent-syntax = "0.9.0"
+fluent-locale = "0.4.1"
 rand = "0.6"
 regex = "1"
 rocket = "0.4.1"

Cargo.toml

@@ -15,19 +15,51 @@ use std::io::prelude::*;
 use std::path::Path;
 
 use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
+use fluent_locale::negotiate_languages;
 
 lazy_static! {
     static ref RESOURCES: HashMap<String, Vec<FluentResource>> = build_resources();
     static ref BUNDLES: HashMap<String, FluentBundle<'static>> = build_bundles();
 }
 
+pub struct Fallback<A: AsRef<str>> {
+    default: Option<&'static str>,
+    availables: Vec<A>,
+}
+
+impl<A: AsRef<str>> Fallback<A> {
+    pub fn new(available_locales: Vec<A>) -> 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 struct I18NHelper {
     bundles: &'static HashMap<String, FluentBundle<'static>>,
+    fallback: Fallback<String>,
 }
 
 impl I18NHelper {
     pub fn new() -> Self {
-        Self { bundles: &*BUNDLES }
+        let mut availables: Vec<String> = Vec::new();
+        for key in RESOURCES.keys() {
+            availables.push(key.clone());
+        }
+        Self {
+            bundles: &*BUNDLES,
+            fallback: Fallback::new(availables),
+        }
     }
 
     pub fn lookup(
@@ -58,17 +90,12 @@ impl I18NHelper {
         text_id: &str,
         args: Option<&HashMap<&str, FluentValue>>,
     ) -> String {
-        if let Some(val) = self.lookup(lang, text_id, args) {
-            val
-        } else if lang != "en-US" {
-            if let Some(val) = self.lookup("en-US", text_id, args) {
-                val
-            } else {
-                format!("Unknown localization {}", text_id)
+        for l in self.fallback.order(&[lang]) {
+            if let Some(val) = self.lookup(l, text_id, args) {
+                return val;
             }
-        } else {
-            format!("Unknown localization {}", text_id)
         }
+        format!("Unknown localization {}", text_id)
     }
 }