I18n

askama/Cargo.toml

@@ -19,6 +19,7 @@ maintenance = { status = "actively-developed" }
 default = ["config", "humansize", "num-traits", "urlencode"]
 config = ["askama_derive/config"]
 humansize = ["askama_derive/humansize", "dep_humansize"]
+localization = ["askama_derive/localization", "fluent-templates", "unic-langid"]
 markdown = ["askama_derive/markdown", "comrak"]
 num-traits = ["askama_derive/num-traits", "dep_num_traits"]
 serde-json = ["askama_derive/serde-json", "askama_escape/json", "serde", "serde_json"]
@@ -42,10 +43,12 @@ askama_escape = { version = "0.10.3", path = "../askama_escape" }
 comrak = { version = "0.13", optional = true, default-features = false }
 dep_humansize = { package = "humansize", version = "1.1.0", optional = true }
 dep_num_traits = { package = "num-traits", version = "0.2.6", optional = true }
+fluent-templates = { version = "0.7.1", optional = true, default-features = false }
 percent-encoding = { version = "2.1.0", optional = true }
 serde = { version = "1.0", optional = true, features = ["derive"] }
 serde_json = { version = "1.0", optional = true }
 serde_yaml = { version = "0.8", optional = true }
+unic-langid = { version=  "0.9.0", optional = true}
 
 [package.metadata.docs.rs]
 features = ["config", "humansize", "num-traits", "serde-json", "serde-yaml"]

askama/src/lib.rs

@@ -71,6 +71,11 @@ use std::fmt;
 
 pub use askama_derive::Template;
 pub use askama_escape::{Html, MarkupDisplay, Text};
+#[cfg(feature = "localization")]
+#[doc(hidden)]
+pub use fluent_templates::fluent_bundle::FluentValue;
+#[cfg(feature = "localization")]
+use fluent_templates::{Loader, StaticLoader};
 
 #[doc(hidden)]
 pub use crate as shared;
@@ -218,3 +223,32 @@ mod tests {
     note = "file-level dependency tracking is handled automatically without build script"
 )]
 pub fn rerun_if_templates_changed() {}
+
+#[cfg(feature = "localization")]
+pub struct Locale<'a> {
+    loader: &'a StaticLoader,
+    language: unic_langid::LanguageIdentifier,
+}
+
+#[cfg(feature = "localization")]
+impl Locale<'_> {
+    pub fn new(language: unic_langid::LanguageIdentifier, loader: &'static StaticLoader) -> Self {
+        Self { loader, language }
+    }
+
+    pub fn translate<'a>(
+        &self,
+        text_id: &str,
+        args: impl IntoIterator<Item = (&'a str, FluentValue<'a>)>,
+    ) -> String {
+        use std::collections::HashMap;
+        use std::iter::FromIterator;
+
+        let args = HashMap::<&str, FluentValue<'_>>::from_iter(args);
+        let args = match args.is_empty() {
+            true => None,
+            false => Some(&args),
+        };
+        self.loader.lookup_complete(&self.language, text_id, args)
+    }
+}

askama_derive/Cargo.toml

@@ -15,11 +15,12 @@ proc-macro = true
 [features]
 config = ["serde", "toml"]
 humansize = []
+localization = []
 markdown = []
-urlencode = []
+num-traits = []
 serde-json = []
 serde-yaml = []
-num-traits = []
+urlencode = []
 with-actix-web = []
 with-axum = []
 with-gotham = []

askama_derive/src/generator.rs

@@ -1295,9 +1295,39 @@ impl<'a> Generator<'a> {
             Expr::RustMacro(name, args) => self.visit_rust_macro(buf, name, args),
             Expr::Try(ref expr) => self.visit_try(buf, expr.as_ref())?,
             Expr::Tuple(ref exprs) => self.visit_tuple(buf, exprs)?,
+            Expr::Localize(ref message, ref args) => self.visit_localize(buf, message, args)?,
         })
     }
 
+    fn visit_localize(
+        &mut self,
+        buf: &mut Buffer,
+        message: &Expr<'_>,
+        args: &[(&str, Expr<'_>)],
+    ) -> Result<DisplayWrap, CompileError> {
+        let localizer =
+            self.input.localizer.as_deref().ok_or(
+                "You have to annotate a field with #[locale] to use the localize() function.",
+            )?;
+
+        buf.write(&format!(
+            "self.{}.translate(",
+            normalize_identifier(localizer)
+        ));
+        self.visit_expr(buf, message)?;
+        buf.writeln(", [")?;
+        buf.indent();
+        for (k, v) in args {
+            buf.write(&format!("({:?}, ::askama::FluentValue::from(", k));
+            self.visit_expr(buf, v)?;
+            buf.writeln(")),")?;
+        }
+        buf.dedent()?;
+        buf.write("])");
+
+        Ok(DisplayWrap::Unwrapped)
+    }
+
     fn visit_try(
         &mut self,
         buf: &mut Buffer,

askama_derive/src/input.rs

@@ -18,6 +18,7 @@ pub(crate) struct TemplateInput<'a> {
     pub(crate) mime_type: String,
     pub(crate) parent: Option<&'a syn::Type>,
     pub(crate) path: PathBuf,
+    pub(crate) localizer: Option<String>,
 }
 
 impl TemplateInput<'_> {
@@ -50,7 +51,6 @@ impl TemplateInput<'_> {
                 return Err("must include 'ext' attribute when using 'source' attribute".into())
             }
         };
-
         // Check to see if a `_parent` field was defined on the context
         // struct, and store the type for it for use in the code generator.
         let parent = match ast.data {
@@ -65,6 +65,37 @@ impl TemplateInput<'_> {
             _ => None,
         };
 
+        let localizer = match ast.data {
+            syn::Data::Struct(syn::DataStruct {
+                fields: syn::Fields::Named(ref fields),
+                ..
+            }) => {
+                let mut localizers =
+                    fields
+                        .named
+                        .iter()
+                        .filter(|&f| f.ident.is_some())
+                        .flat_map(
+                            |f| match f.attrs.iter().any(|a| a.path.is_ident("locale")) {
+                                true => Some(f.ident.as_ref()?.to_string()),
+                                false => None,
+                            },
+                        );
+                match localizers.next() {
+                    Some(localizer) => {
+                        if !cfg!(feature = "localization") {
+                            return Err("You have to active the \"localization\" feature to use #[locale] on fields.".into());
+                        } else if localizers.next().is_some() {
+                            return Err("You cannot mark more than one field as #[locale].".into());
+                        }
+                        Some(localizer)
+                    }
+                    None => None,
+                }
+            }
+            _ => None,
+        };
+
         if parent.is_some() {
             eprint!(
                 "   --> in struct {}\n   = use of deprecated field '_parent'\n",
@@ -119,6 +150,8 @@ impl TemplateInput<'_> {
             mime_type,
             parent,
             path,
+            #[cfg(feature = "localization")]
+            localizer,
         })
     }
 

askama_derive/src/lib.rs

@@ -14,7 +14,7 @@ mod heritage;
 mod input;
 mod parser;
 
-#[proc_macro_derive(Template, attributes(template))]
+#[proc_macro_derive(Template, attributes(template, locale))]
 pub fn derive_template(input: TokenStream) -> TokenStream {
     generator::derive_template(input)
 }

askama_derive/src/parser.rs

@@ -66,6 +66,7 @@ pub(crate) enum Expr<'a> {
     Call(Box<Expr<'a>>, Vec<Expr<'a>>),
     RustMacro(&'a str, &'a str),
     Try(Box<Expr<'a>>),
+    Localize(Box<Expr<'a>>, Vec<(&'a str, Expr<'a>)>),
 }
 
 impl Expr<'_> {
@@ -669,6 +670,37 @@ macro_rules! expr_prec_layer {
     }
 }
 
+fn expr_localize_args(mut i: &str) -> IResult<&str, Vec<(&str, Expr<'_>)>> {
+    let mut args = Vec::<(&str, Expr<'_>)>::new();
+
+    let mut p = opt(tuple((ws(tag(",")), identifier, ws(tag(":")), expr_any)));
+    while let (j, Some((_, k, _, v))) = p(i)? {
+        if args.iter().any(|&(a, _)| a == k) {
+            eprintln!("Duplicated key: {:?}", k);
+            return Err(nom::Err::Failure(error_position!(i, ErrorKind::Tag)));
+        }
+
+        args.push((k, v));
+        i = j;
+    }
+
+    let (i, _) = opt(tag(","))(i)?;
+    Ok((i, args))
+}
+
+fn expr_localize(i: &str) -> IResult<&str, Expr<'_>> {
+    let (i, _) = pair(tag("localize"), ws(tag("(")))(i)?;
+    if cfg!(feature = "localization") {
+        cut(map(
+            tuple((expr_any, expr_localize_args, ws(tag(")")))),
+            |(text_id, args, _)| Expr::Localize(text_id.into(), args),
+        ))(i)
+    } else {
+        eprintln!(r#"Please activate the "localization" to use localize()."#);
+        Err(nom::Err::Failure(error_position!(i, ErrorKind::Tag)))
+    }
+}
+
 expr_prec_layer!(expr_muldivmod, expr_filtered, "*", "/", "%");
 expr_prec_layer!(expr_addsub, expr_muldivmod, "+", "-");
 expr_prec_layer!(expr_shifts, expr_addsub, ">>", "<<");
@@ -686,6 +718,7 @@ fn expr_handle_ws(i: &str) -> IResult<&str, Whitespace> {
 fn expr_any(i: &str) -> IResult<&str, Expr<'_>> {
     let range_right = |i| pair(ws(alt((tag("..="), tag("..")))), opt(expr_or))(i);
     alt((
+        expr_localize,
         map(range_right, |(op, right)| {
             Expr::Range(op, None, right.map(Box::new))
         }),
@@ -1255,6 +1288,77 @@ mod tests {
         super::parse("{% extend \"blah\" %}", &Syntax::default()).unwrap();
     }
 
+    #[cfg(feature = "localization")]
+    #[test]
+    fn test_parse_localize() {
+        macro_rules! map {
+            ($($k:expr => $v:expr),* $(,)?) => {{
+                use std::iter::{Iterator, IntoIterator};
+                Iterator::collect(IntoIterator::into_iter([$(($k, $v),)*]))
+            }};
+        }
+
+        assert_eq!(
+            super::parse(r#"{{ localize("a", v: 32 + 7) }}"#, &Syntax::default()).unwrap(),
+            vec![Node::Expr(
+                Ws(None, None),
+                Expr::Localize(
+                    Expr::StrLit("a").into(),
+                    map!(
+                        "v" => {
+                            Expr::BinOp("+", Expr::NumLit("32").into(), Expr::NumLit("7").into())
+                        }
+                    ),
+                )
+            )],
+        );
+
+        assert_eq!(
+            super::parse(
+                r#"{{ localize("a", b: "b", c: "c", d: "d") }}"#,
+                &Syntax::default(),
+            )
+            .unwrap(),
+            vec![Node::Expr(
+                Ws(None, None),
+                Expr::Localize(
+                    Expr::StrLit("a").into(),
+                    map!(
+                        "b" => Expr::StrLit("b"),
+                        "c" => Expr::StrLit("c"),
+                        "d" => Expr::StrLit("d"),
+                    ),
+                )
+            )],
+        );
+
+        assert_eq!(
+            super::parse(
+                r#"{{ localize("a", v: localize("a", v: 32 + 7) ) }}"#,
+                &Syntax::default(),
+            )
+            .unwrap(),
+            vec![Node::Expr(
+                Ws(None, None),
+                Expr::Localize(
+                    Expr::StrLit("a").into(),
+                    map!(
+                        "v" => Expr::Localize(
+                            Expr::StrLit("a").into(),
+                            map!(
+                                "v" => Expr::BinOp(
+                                    "+",
+                                    Expr::NumLit("32").into(),
+                                    Expr::NumLit("7").into(),
+                                ),
+                            ),
+                        ),
+                    ),
+                ),
+            )],
+        );
+    }
+
     #[test]
     fn test_parse_filter() {
         use Expr::*;

testing/Cargo.toml

@@ -7,14 +7,17 @@ edition = "2018"
 publish = false
 
 [features]
-default = ["serde-json", "markdown"]
+default = ["serde-json", "markdown", "localization"]
 serde-json = ["serde_json", "askama/serde-json"]
 markdown = ["comrak", "askama/markdown"]
+localization = ["fluent-templates", "unic-langid", "askama/localization"]
 
 [dependencies]
 askama = { path = "../askama", version = "0.11.0-beta.1" }
 comrak = { version = "0.13", default-features = false, optional = true }
+fluent-templates = { version = "0.7.1", optional = true}
 serde_json = { version = "1.0", optional = true }
+unic-langid = { version =  "0.9.0", optional = true }
 
 [dev-dependencies]
 criterion = "0.3"

testing/i18n-basic/en-US/basic.ftl

@@ -0,0 +1,3 @@
+greeting = Hello, { $name }! 
+age = You are { $hours } hours old.
+test = This is a test

testing/i18n-basic/es-MX/basic.ftl

@@ -0,0 +1,2 @@
+greeting = ¡Hola, { $name }!
+age = Tienes { $hours } horas.

testing/templates/i18n.html

@@ -0,0 +1,2 @@
+<h1>{{ localize("greeting", name: name) }}</h1>
+<h3>{{ localize("age", hours: hours ) }}</h3>

testing/templates/i18n_broken.html

@@ -0,0 +1 @@
+<h1>{{ localize("car", color: car_color) }}</h1>

testing/templates/i18n_invalid.html

@@ -0,0 +1,2 @@
+<h1>{{ localize("greetingsss", name: name) }}</h1>
+<h3>{{ localize("ages") }}</h3>

testing/templates/i18n_no_args.html

@@ -0,0 +1 @@
+<h3>{{ localize("test", test: "") }}</h3>