fluent_template_helper/
helper.rs

1use handlebars::{
2    Context, Handlebars, Helper, HelperDef, HelperResult, Output, RenderContext, RenderError,
3    Renderable,
4};
5
6use fluent_bundle::FluentValue;
7use handlebars::template::{Parameter, TemplateElement};
8use serde_json::Value as Json;
9use std::collections::HashMap;
10use std::io;
11
12use crate::Loader;
13
14pub struct FluentHelper<L> {
15    loader: L,
16}
17
18impl<L> FluentHelper<L> {
19    pub fn new(loader: L) -> Self {
20        Self { loader }
21    }
22}
23
24#[derive(Default)]
25struct StringOutput {
26    pub s: String,
27}
28
29impl Output for StringOutput {
30    fn write(&mut self, seg: &str) -> Result<(), io::Error> {
31        self.s.push_str(seg);
32        Ok(())
33    }
34}
35
36impl<L: Loader + Send + Sync> HelperDef for FluentHelper<L> {
37    fn call<'reg: 'rc, 'rc>(
38        &self,
39        h: &Helper<'reg, 'rc>,
40        reg: &'reg Handlebars,
41        context: &'rc Context,
42        rcx: &mut RenderContext<'reg, 'rc>,
43        out: &mut dyn Output,
44    ) -> HelperResult {
45        let id = if let Some(id) = h.param(0) {
46            id
47        } else {
48            return Err(RenderError::new(
49                "{{fluent}} must have at least one parameter",
50            ));
51        };
52
53        if id.relative_path().is_some() {
54            return Err(RenderError::new(
55                "{{fluent}} takes a string parameter with no path",
56            ));
57        }
58
59        let id = if let Json::String(ref s) = *id.value() {
60            s
61        } else {
62            return Err(RenderError::new("{{fluent}} takes a string parameter"));
63        };
64
65        let mut args = if h.hash().is_empty() {
66            None
67        } else {
68            let map = h
69                .hash()
70                .iter()
71                .filter_map(|(k, v)| {
72                    let json = v.value();
73                    let val = match json {
74                        // `Number::as_f64` can't fail here because we haven't
75                        // enabled `arbitrary_precision` feature
76                        // in `serde_json`.
77                        Json::Number(n) => n.as_f64().unwrap().into(),
78                        Json::String(s) => s.to_owned().into(),
79                        _ => return None,
80                    };
81                    Some((&**k, val))
82                })
83                .collect();
84            Some(map)
85        };
86
87        if let Some(tpl) = h.template() {
88            if args.is_none() {
89                args = Some(HashMap::new());
90            }
91            let args = args.as_mut().unwrap();
92            for element in &tpl.elements {
93                if let TemplateElement::HelperBlock(ref block) = element {
94                    if block.name != Parameter::Name("fluentparam".into()) {
95                        return Err(RenderError::new(format!(
96                            "{{{{fluent}}}} can only contain {{{{fluentparam}}}} elements, not {}",
97                            block.name.expand_as_name(reg, context, rcx).unwrap()
98                        )));
99                    }
100                    let id = if let Some(el) = block.params.get(0) {
101                        if let Parameter::Literal(ref s) = *el {
102                            if let Json::String(ref s) = *s {
103                                s
104                            } else {
105                                return Err(RenderError::new(
106                                    "{{fluentparam}} takes a string parameter",
107                                ));
108                            }
109                        } else {
110                            return Err(RenderError::new(
111                                "{{fluentparam}} takes a string parameter",
112                            ));
113                        }
114                    } else {
115                        return Err(RenderError::new("{{fluentparam}} must have one parameter"));
116                    };
117                    if let Some(ref tpl) = block.template {
118                        let mut s = StringOutput::default();
119                        tpl.render(reg, context, rcx, &mut s)?;
120                        args.insert(&*id, FluentValue::String(s.s.into()));
121                    }
122                }
123            }
124        }
125        let lang = context
126            .data()
127            .get("lang")
128            .expect("Language not set in context")
129            .as_str()
130            .expect("Language must be string")
131            .parse()
132            .expect("Language not valid identifier");
133
134        let response = self.loader.lookup(&lang, &id, args.as_ref());
135        out.write(&response).map_err(RenderError::with)
136    }
137}
fluent_template_helper/helper.rs

fluent_template_helper/
helper.rs
