Merge pull request #792 from Manishearth/fluent

Basic Fluent implementation

Author: skade

Cargo.lock

@@ -6,7 +6,11 @@ edition = "2018"
 
 [dependencies]
 lazy_static = "1.2.0"
+fluent = "0.5"
+fluent-bundle = "0.6.0"
+fluent-syntax = "0.9.0"
 rand = "0.6"
+regex = "1"
 rocket = "0.4.1"
 serde = "1.0"
 serde_derive = "1.0"
@@ -16,6 +20,7 @@ reqwest = "0.9.5"
 toml = "0.4"
 serde_json = "1.0"
 rust_team_data = { git = "https://github.com/rust-lang/team" }
+handlebars = "1.1.0"
 
 [dependencies.rocket_contrib]
 version = "*"

Cargo.toml

@@ -0,0 +1,221 @@
+use handlebars::{
+    Context, Handlebars, Helper, HelperDef, HelperResult, Output, RenderContext, RenderError,
+    Renderable,
+};
+
+use handlebars::template::{Parameter, TemplateElement};
+use rocket::http::RawStr;
+use rocket::request::FromParam;
+use serde_json::Value as Json;
+use std::collections::HashMap;
+use std::fs::read_dir;
+use std::fs::File;
+use std::io;
+use std::io::prelude::*;
+use std::path::Path;
+
+use fluent_bundle::{FluentBundle, FluentResource, FluentValue};
+
+lazy_static! {
+    static ref RESOURCES: HashMap<String, Vec<FluentResource>> = build_resources();
+    static ref BUNDLES: HashMap<String, FluentBundle<'static>> = build_bundles();
+}
+
+pub struct I18NHelper {
+    bundles: &'static HashMap<String, FluentBundle<'static>>,
+}
+
+impl I18NHelper {
+    pub fn new() -> Self {
+        Self { bundles: &*BUNDLES }
+    }
+    pub fn i18n_token(
+        &self,
+        lang: &str,
+        text_id: &str,
+        args: Option<&HashMap<&str, FluentValue>>,
+    ) -> String {
+        if let Some(bundle) = self.bundles.get(lang) {
+            if bundle.has_message(text_id) {
+                let (value, _errors) = bundle
+                    .format(text_id, args)
+                    .expect("Failed to format a message.");
+                return value;
+            } else if lang != "en-US" {
+                let bundle = self
+                    .bundles
+                    .get("en-US")
+                    .expect("Must have English localization");
+                let (value, _errors) = bundle
+                    .format(text_id, args)
+                    .expect("Failed to format a message.");
+                return value;
+            }
+        }
+        format!("Unknown localization {}", text_id)
+    }
+}
+
+#[derive(Default)]
+struct StringOutput {
+    pub s: String,
+}
+
+impl Output for StringOutput {
+    fn write(&mut self, seg: &str) -> Result<(), io::Error> {
+        self.s.push_str(seg);
+        Ok(())
+    }
+}
+
+impl HelperDef for I18NHelper {
+    fn call<'reg: 'rc, 'rc>(
+        &self,
+        h: &Helper<'reg, 'rc>,
+        reg: &'reg Handlebars,
+        context: &'rc Context,
+        rcx: &mut RenderContext<'reg>,
+        out: &mut dyn Output,
+    ) -> HelperResult {
+        let id = if let Some(id) = h.param(0) {
+            id
+        } else {
+            return Err(RenderError::new(
+                "{{text}} must have at least one parameter",
+            ));
+        };
+
+        let id = if let Some(id) = id.path() {
+            id
+        } else {
+            return Err(RenderError::new("{{text}} takes an identifier parameter"));
+        };
+
+        let mut args = if h.hash().is_empty() {
+            None
+        } else {
+            let map = h
+                .hash()
+                .iter()
+                .filter_map(|(k, v)| {
+                    let json = v.value();
+                    let val = match *json {
+                        Json::Number(ref n) => FluentValue::Number(n.to_string()),
+                        Json::String(ref s) => FluentValue::String(s.to_string()),
+                        _ => return None,
+                    };
+                    Some((&**k, val))
+                })
+                .collect();
+            Some(map)
+        };
+
+        if let Some(tpl) = h.template() {
+            if args.is_none() {
+                args = Some(HashMap::new());
+            }
+            let args = args.as_mut().unwrap();
+            for element in &tpl.elements {
+                if let TemplateElement::HelperBlock(ref block) = element {
+                    if block.name != "textparam" {
+                        return Err(RenderError::new(format!(
+                            "{{{{text}}}} can only contain {{{{textparam}}}} elements, not {}",
+                            block.name
+                        )));
+                    }
+                    let id = if let Some(el) = block.params.get(0) {
+                        if let Parameter::Name(ref s) = *el {
+                            s
+                        } else {
+                            return Err(RenderError::new(
+                                "{{textparam}} takes an identifier parameter",
+                            ));
+                        }
+                    } else {
+                        return Err(RenderError::new("{{textparam}} must have one parameter"));
+                    };
+                    if let Some(ref tpl) = block.template {
+                        let mut s = StringOutput::default();
+                        tpl.render(reg, context, rcx, &mut s)?;
+                        args.insert(&*id, FluentValue::String(s.s));
+                    }
+                }
+            }
+        }
+        let lang = context
+            .data()
+            .get("lang")
+            .expect("Language not set in context")
+            .as_str()
+            .expect("Language must be string");
+        let response = self.i18n_token(lang, &id, args.as_ref());
+        out.write(&response).map_err(RenderError::with)
+    }
+}
+
+pub fn read_from_file<P: AsRef<Path>>(filename: P) -> io::Result<FluentResource> {
+    let mut file = File::open(filename)?;
+    let mut string = String::new();
+
+    file.read_to_string(&mut string)?;
+
+    Ok(FluentResource::try_new(string).expect("File did not parse!"))
+}
+
+pub fn read_from_dir<P: AsRef<Path>>(dirname: P) -> io::Result<Vec<FluentResource>> {
+    let mut result = Vec::new();
+    for dir_entry in read_dir(dirname)? {
+        let entry = dir_entry?;
+        let resource = read_from_file(entry.path())?;
+        result.push(resource);
+    }
+    Ok(result)
+}
+
+pub fn create_bundle(lang: &str, resources: &'static Vec<FluentResource>) -> FluentBundle<'static> {
+    let mut bundle = FluentBundle::new(&[lang]);
+
+    for res in resources {
+        bundle
+            .add_resource(res)
+            .expect("Failed to add FTL resources to the bundle.");
+    }
+
+    bundle
+}
+
+fn build_resources() -> HashMap<String, Vec<FluentResource>> {
+    let mut all_resources = HashMap::new();
+    let entries = read_dir("./templates/fluent-resource").unwrap();
+    for entry in entries {
+        let entry = entry.unwrap();
+        if let Ok(lang) = entry.file_name().into_string() {
+            let resources = read_from_dir(entry.path()).unwrap();
+            all_resources.insert(lang, resources);
+        }
+    }
+    all_resources
+}
+
+fn build_bundles() -> HashMap<String, FluentBundle<'static>> {
+    let mut bundles = HashMap::new();
+    for (ref k, ref v) in &*RESOURCES {
+        bundles.insert(k.to_string(), create_bundle(&k, &v));
+    }
+    bundles
+}
+
+pub struct SupportedLocale(pub String);
+
+impl<'r> FromParam<'r> for SupportedLocale {
+    type Error = ();
+
+    fn from_param(param: &'r RawStr) -> Result<Self, Self::Error> {
+        let param = param.percent_decode().map_err(|_| ())?;
+        if BUNDLES.get(param.as_ref()).is_some() {
+            Ok(SupportedLocale(param.into()))
+        } else {
+            Err(())
+        }
+    }
+}