fluent-static-codegen 0.6.1

Automatically generate Rust functions from Fluent message files for streamlined localization in Rust applications.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use std::collections::HashMap;

use fluent_static_function::FluentFunctionDescriptor;
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{parse_str, Ident, Path, PathArguments};

pub trait FunctionCallGenerator {
    fn generate(
        &self,
        function_name: &str,
        positional_args: &Ident,
        named_args: &Ident,
    ) -> Option<TokenStream>;
}

pub struct FunctionRegistry {
    fns: HashMap<String, TokenStream>,
}

impl FunctionRegistry {
    pub fn register(
        &mut self,
        function_id: &str,
        function_descriptor: impl FluentFunctionDescriptor,
    ) -> &Self {
        self.fns
            .insert(function_id.to_string(), Self::fqn(function_descriptor));
        self
    }

    fn fqn(function_descriptor: impl FluentFunctionDescriptor) -> TokenStream {
        let path = function_descriptor.type_name();

        // HACK fluent_static reexports fluent_static_function,
        // need to patch function name
        // to avoid fluent_static_function dependency
        let path = if path.starts_with("fluent_static_function::builtins") {
            path.replace("fluent_static_function", "fluent_static::function")
        } else {
            path.to_string()
        };

        let mut path: Path = parse_str(&path).expect("vaild function type name");
        if let Some(name) = path.segments.last_mut() {
            name.arguments = PathArguments::None
        }

        quote! { #path }
    }
}

impl Default for FunctionRegistry {
    fn default() -> Self {
        let fns = HashMap::new();
        let mut result = Self { fns };

        result.register("NUMBER", fluent_static_function::builtins::number);

        result
    }
}

impl FunctionCallGenerator for FunctionRegistry {
    fn generate(
        &self,
        function_name: &str,
        positional_args: &Ident,
        named_args: &Ident,
    ) -> Option<TokenStream> {
        if let Some(fn_ident) = self.fns.get(function_name) {
            Some(quote! {
                #fn_ident(&#positional_args, &#named_args)
            })
        } else {
            None
        }
    }
}