feat: better translations (locale O(1) lookup)

Author: filipton

Cargo.lock

@@ -7,6 +7,7 @@ edition = "2021"
 proc-macro = true
 
 [dependencies]
+convert_case = "0.7.1"
 proc-macro2 = "1.0.93"
 quote = "1.0.38"
 serde = { version = "1.0.217", features = ["derive"] }

macros/Cargo.lock

@@ -1,9 +1,10 @@
+use convert_case::Casing;
 use proc_macro::TokenStream;
 use quote::{format_ident, quote};
 use serde::Deserialize;
 use syn::{
     parse::{Parse, ParseStream},
-    Ident, LitStr, Token,
+    LitStr,
 };
 
 #[derive(Debug, Deserialize, Clone)]
@@ -16,47 +17,40 @@ pub struct TranslationRecord {
 #[allow(dead_code)]
 struct TranslationsHandler {
     path: String,
-    name: Ident,
 }
 
 impl Parse for TranslationsHandler {
     fn parse(input: ParseStream) -> Result<Self, syn::Error> {
         let path = input.parse::<LitStr>()?;
-        input.parse::<Token![,]>()?;
-        let name = input.parse::<Ident>()?;
 
-        Ok(TranslationsHandler {
-            path: path.value(),
-            name,
-        })
+        Ok(TranslationsHandler { path: path.value() })
     }
 }
 
 pub fn load_translations_macro(args: TokenStream) -> TokenStream {
-    let TranslationsHandler { path, name } = syn::parse_macro_input!(args as TranslationsHandler);
+    let TranslationsHandler { path } = syn::parse_macro_input!(args as TranslationsHandler);
 
     let read = std::fs::read(&path).unwrap();
     let translations: Vec<TranslationRecord> = serde_json::from_slice(&read).unwrap();
 
     let translations_count = translations.len();
     let declaration = quote! {
-        pub const #name: [&'static str; #translations_count]
+        pub const TRANSLATIONS_COUNT: usize = #translations_count;
+        pub const FALLBACK_TRANSLATIONS: [&'static str; TRANSLATIONS_COUNT]
     };
 
-    let mut enum_keys = Vec::new();
+    let mut translation_keys = Vec::new();
     let mut enum_parser_keys = Vec::new();
     let mut translations_strings = Vec::new();
 
     for (i, TranslationRecord { key, translation }) in translations.iter().enumerate() {
-        let i = i as isize;
-
-        let enum_key = format_ident!("{}", uppercase_first_letter(&key));
-        enum_keys.push(quote! {
-            #enum_key = #i,
+        let translation_key = format_ident!("{}", key.to_case(convert_case::Case::Constant));
+        translation_keys.push(quote! {
+            pub const #translation_key: usize = #i;
         });
 
         enum_parser_keys.push(quote! {
-            #key => Some(Self::#enum_key),
+            #key => Some(Self::#translation_key),
         });
 
         translations_strings.push(quote! {
@@ -65,17 +59,12 @@ pub fn load_translations_macro(args: TokenStream) -> TokenStream {
     }
 
     quote! {
-        #[derive(Clone, Copy)]
-        pub enum TranslationKey {
-            #(#enum_keys)*
-        }
+        pub struct TranslationKey {}
 
         impl TranslationKey {
-            pub fn to_usize(&self) -> usize {
-                *self as usize
-            }
+            #(#translation_keys)*
 
-            pub fn from_key_str(input: &str) -> Option<Self> {
+            pub fn from_key_str(input: &str) -> Option<usize> {
                 match input {
                     #(#enum_parser_keys)*
                     _ => None
@@ -89,20 +78,3 @@ pub fn load_translations_macro(args: TokenStream) -> TokenStream {
     }
     .into()
 }
-
-// not performent, i know, i dont care
-fn uppercase_first_letter(input: &str) -> String {
-    let mut tmp = String::new();
-
-    let mut first = true;
-    for c in input.chars() {
-        if first {
-            tmp.push(c.to_uppercase().nth(0).unwrap());
-            first = false;
-        } else {
-            tmp.push(c);
-        }
-    }
-
-    tmp
-}