I18n

askama/Cargo.toml

@@ -31,6 +31,7 @@ with-mendes = ["askama_derive/with-mendes"]
 with-rocket = ["askama_derive/with-rocket"]
 with-tide = ["askama_derive/with-tide"]
 with-warp = ["askama_derive/with-warp"]
+localization = ["dep:fluent-templates","dep:unic-langid"]
 
 # deprecated
 mime = []
@@ -46,6 +47,8 @@ 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 }
+fluent-templates = { version= "0.7.1", 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

@@ -218,3 +218,30 @@ mod tests {
     note = "file-level dependency tracking is handled automatically without build script"
 )]
 pub fn rerun_if_templates_changed() {}
+
+#[cfg(feature = "localization")]
+use fluent_templates::Loader;
+#[cfg(feature = "localization")]
+pub struct Locale<'a> {
+    loader: &'a fluent_templates::StaticLoader,
+    language: unic_langid::LanguageIdentifier,
+}
+#[cfg(feature = "localization")]
+impl<'a> Locale<'a> {
+    pub fn new(
+        language: unic_langid::LanguageIdentifier,
+        templates: &'static fluent_templates::StaticLoader,
+    ) -> Locale<'a> {
+        Self {
+            loader: templates,
+            language,
+        }
+    }
+    pub fn translate(
+        &self,
+        text_id: &str,
+        args: &std::collections::HashMap<String, fluent_templates::fluent_bundle::FluentValue<'_>>,
+    ) -> String {
+        self.loader.lookup_with_args(&self.language, text_id, args)
+    }
+}

askama_derive/Cargo.toml

@@ -27,6 +27,7 @@ with-mendes = []
 with-rocket = []
 with-tide = []
 with-warp = []
+localization = []
 
 [dependencies]
 mime = "0.3"

askama_derive/src/generator.rs

@@ -7,6 +7,8 @@ use crate::CompileError;
 use proc_macro::TokenStream;
 use quote::{quote, ToTokens};
 
+#[cfg(feature = "localization")]
+use std::collections::BTreeSet;
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::{cmp, hash, mem, str};
@@ -255,6 +257,9 @@ struct Generator<'a> {
     // If set to `suppress`, the whitespace characters will be removed by default unless `+` is
     // used.
     whitespace: WhitespaceHandling,
+    #[cfg(feature = "localization")]
+    // Messages used with localize()
+    localized_messages: BTreeSet<String>,
 }
 
 impl<'a> Generator<'a> {
@@ -276,6 +281,8 @@ impl<'a> Generator<'a> {
             buf_writable: vec![],
             named: 0,
             whitespace,
+            #[cfg(feature = "localization")]
+            localized_messages: BTreeSet::new(),
         }
     }
 
@@ -1295,9 +1302,59 @@ 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)?,
+            #[cfg(feature = "localization")]
+            Expr::Localize(message, attribute, ref args) => {
+                self.visit_localize(buf, message, attribute, args)?
+            }
         })
     }
 
+    #[cfg(feature = "localization")]
+    fn visit_localize(
+        &mut self,
+        buf: &mut Buffer,
+        message: &str,
+        attribute: Option<&str>,
+        args: &[(&str, Expr<'_>)],
+    ) -> Result<DisplayWrap, CompileError> {
+        let localizer = self.input.localizer.as_ref().expect(
+            "A template struct must have a member with the `#[locale]` \
+             attribute that implements `askama::Localize` to enable calling the localize() filter",
+        );
+
+        let mut message = message.to_string();
+        if let Some(attribute) = attribute {
+            message.push_str(".");
+            message.push_str(attribute);
+        }
+
+        assert!(
+            message.chars().find(|c| *c == '"').is_none(),
+            "message ids with quotes in them break the generator, please remove"
+        );
+
+        self.localized_messages.insert(message.clone());
+
+        buf.write(&format!(
+            "self.{}.translate(\"{}\", &std::iter::FromIterator::from_iter(vec![",
+            localizer.0, message
+        ));
+
+        for (i, (name, value)) in args.iter().enumerate() {
+            if i > 0 {
+                buf.write(", ");
+            }
+            buf.write(&format!(
+                "(\"{}\".to_string(), ({}).into())",
+                name,
+                self.visit_expr_root(value)?
+            ));
+        }
+        buf.write("]))");
+
+        Ok(DisplayWrap::Unwrapped)
+    }
+
     fn visit_try(
         &mut self,
         buf: &mut Buffer,

askama_derive/src/input.rs

@@ -18,6 +18,8 @@ pub(crate) struct TemplateInput<'a> {
     pub(crate) mime_type: String,
     pub(crate) parent: Option<&'a syn::Type>,
     pub(crate) path: PathBuf,
+    #[cfg(feature = "localization")]
+    pub(crate) localizer: Option<(syn::Ident, &'a syn::Type)>,
 }
 
 impl TemplateInput<'_> {
@@ -50,7 +52,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 {
@@ -64,7 +65,32 @@ impl TemplateInput<'_> {
                 .map(|f| &f.ty),
             _ => None,
         };
-
+        #[cfg(feature = "localization")]
+        // if enabled, it tries to get the localizer
+        let localizer = match ast.data {
+            syn::Data::Struct(syn::DataStruct {
+                fields: syn::Fields::Named(ref fields),
+                ..
+            }) => {
+                let named = &fields.named;
+                let localizers: Vec<_> = named
+                    .iter()
+                    .filter(|f| f.ident.is_some())
+                    .flat_map(|f| {
+                        f.attrs
+                            .iter()
+                            .filter(|a| a.path.is_ident("locale"))
+                            .map(move |_| (f.ident.to_owned().unwrap(), &f.ty))
+                    })
+                    .collect();
+                if localizers.len() > 1 {
+                    panic!("Can't have multiple localizers for a single template!");
+                } else {
+                    localizers.get(0).map(|l| l.to_owned())
+                }
+            }
+            _ => None,
+        };
         if parent.is_some() {
             eprint!(
                 "   --> in struct {}\n   = use of deprecated field '_parent'\n",
@@ -119,6 +145,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,8 @@ pub(crate) enum Expr<'a> {
     Call(Box<Expr<'a>>, Vec<Expr<'a>>),
     RustMacro(&'a str, &'a str),
     Try(Box<Expr<'a>>),
+    #[cfg(feature = "localization")]
+    Localize(&'a str, Option<&'a str>, Vec<(&'a str, Expr<'a>)>),
 }
 
 impl Expr<'_> {
@@ -668,7 +670,29 @@ macro_rules! expr_prec_layer {
         }
     }
 }
-
+#[cfg(feature = "localization")]
+fn localize(i: &str) -> IResult<&str, Expr<'_>> {
+    let (tail, (_, _, message, attribute, args, _)) = tuple((
+        tag("localize"),
+        ws(tag("(")),
+        identifier,
+        opt(tuple((ws(tag(".")), identifier))),
+        opt(tuple((
+            ws(tag(",")),
+            separated_list0(ws(tag(",")), tuple((identifier, ws(tag(":")), expr_any))),
+        ))),
+        ws(tag(")")),
+    ))(i)?;
+    Ok((
+        tail,
+        Expr::Localize(
+            message,
+            attribute.map(|(_, a)| a),
+            args.map(|(_, args)| args.into_iter().map(|(k, _, v)| (k, v)).collect())
+                .unwrap_or_default(),
+        ),
+    ))
+}
 expr_prec_layer!(expr_muldivmod, expr_filtered, "*", "/", "%");
 expr_prec_layer!(expr_addsub, expr_muldivmod, "+", "-");
 expr_prec_layer!(expr_shifts, expr_addsub, ">>", "<<");
@@ -682,10 +706,14 @@ expr_prec_layer!(expr_or, expr_and, "||");
 fn expr_handle_ws(i: &str) -> IResult<&str, Whitespace> {
     alt((char('-'), char('+'), char('~')))(i).map(|(s, r)| (s, Whitespace::from(r)))
 }
-
 fn expr_any(i: &str) -> IResult<&str, Expr<'_>> {
     let range_right = |i| pair(ws(alt((tag("..="), tag("..")))), opt(expr_or))(i);
     alt((
+        #[cfg(feature = "localization")]
+        map(localize, |expr| match expr {
+            Expr::Localize(_, _, _) => expr,
+            _ => panic!("localize failed: {:?}", expr),
+        }),
         map(range_right, |(op, right)| {
             Expr::Range(op, None, right.map(Box::new))
         }),
@@ -1254,7 +1282,57 @@ mod tests {
     fn test_invalid_block() {
         super::parse("{% extend \"blah\" %}", &Syntax::default()).unwrap();
     }
-
+    #[cfg(feature = "localization")]
+    #[test]
+    fn test_parse_localize() {
+        assert_eq!(
+            super::parse("{{ localize(a, v: 32 + 7) }}", &Syntax::default()).unwrap(),
+            vec![Node::Expr(
+                Ws(None, None),
+                Expr::Localize(
+                    "a",
+                    None,
+                    vec![(
+                        "v",
+                        Expr::BinOp("+", Expr::NumLit("32").into(), Expr::NumLit("7").into())
+                    )]
+                )
+            )]
+        );
+    }
+    #[cfg(feature = "localization")]
+    #[test]
+    fn test_parse_nested_localize() {
+        assert_eq!(
+            super::parse(
+                "{{ localize(a, v: localize(a, v: 32 + 7) ) }}",
+                &Syntax::default()
+            )
+            .unwrap(),
+            vec![Node::Expr(
+                Ws(None, None),
+                Expr::Localize(
+                    "a",
+                    None,
+                    vec![(
+                        "v",
+                        Expr::Localize(
+                            "a",
+                            None,
+                            vec![(
+                                "v",
+                                Expr::BinOp(
+                                    "+",
+                                    Expr::NumLit("32").into(),
+                                    Expr::NumLit("7").into()
+                                )
+                            )]
+                        )
+                    )]
+                )
+            )]
+        );
+    }
     #[test]
     fn test_parse_filter() {
         use Expr::*;

testing/Cargo.toml

@@ -10,11 +10,14 @@ publish = false
 default = ["serde-json", "markdown"]
 serde-json = ["serde_json", "askama/serde-json"]
 markdown = ["comrak", "askama/markdown"]
+localization = ["dep:fluent-templates","dep:unic-langid"]
 
 [dependencies]
 askama = { path = "../askama", version = "0.11.0-beta.1" }
 comrak = { version = "0.13", default-features = false, optional = true }
 serde_json = { version = "1.0", optional = true }
+fluent-templates = { version= "0.7.1", 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>