globetrotter_rust/

lib.rs

//! Rust bindings code generation for globetrotter translations.

/// Rust code generation configuration types.
pub mod config;

pub use config::OutputConfig;

use convert_case::{Case, Casing};
use globetrotter_model as model;
use globetrotter_model::ext::iter::TryUnzipExt;
use quote::{format_ident, quote};

/// Common header inserted at the top of generated Rust files.
#[must_use]
pub fn preamble() -> String {
    indoc::formatdoc!(
        r"
            //
            // AUTOGENERATED. DO NOT EDIT.
            // generated by globetrotter v{version}.
            //
        ",
        version = std::env!("CARGO_PKG_VERSION"),
    )
}

fn argument_to_rust_field_name(name: &str) -> String {
    let field_name = name.replace(' ', "").replace(['-', '.'], "_");
    field_name.to_case(Case::Snake)
}

fn key_to_rust_enum_variant(key: &str) -> String {
    let variant_name = key.replace(' ', "").replace(['-', '.'], "_");
    variant_name.to_case(Case::UpperCamel)
}

trait IntoTokenStream {
    fn into_token_stream(self) -> (proc_macro2::TokenStream, bool);
}

impl IntoTokenStream for model::ArgumentType {
    fn into_token_stream(self) -> (proc_macro2::TokenStream, bool) {
        match self {
            Self::Number => {
                let tokens = quote! {i64};
                (tokens, false)
            }
            // TODO(roman): create our own globetrotter type for this
            Self::String | Self::Iso8601DateTimeString => {
                let tokens = quote! {&'a str};
                (tokens, true)
            }
            Self::Any => {
                let tokens = quote! {serde_json::Value};
                (tokens, false)
            }
        }
    }
}

/// Error raised when multiple translation keys map to the same Rust enum variant
/// identifier.
#[derive(thiserror::Error, Debug)]
pub struct DuplicateIdentifierError {
    identifier: String,
    keys: Vec<String>,
}

impl std::fmt::Display for DuplicateIdentifierError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "duplicate identifier `{}` (used by {})",
            self.identifier,
            self.keys.join(", ")
        )
    }
}

/// Error raised when multiple translation arguments would produce the same
/// Rust struct field name.
#[derive(thiserror::Error, Debug)]
pub struct DuplicateFieldError {
    field: String,
    enum_variant: String,
    arguments: Vec<String>,
    key: String,
}

impl std::fmt::Display for DuplicateFieldError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "{}: duplicate field `{}` used by arguments {} of variant `{}`",
            self.key,
            self.field,
            self.arguments
                .iter()
                .map(|arg| format!("{arg:?}"))
                .collect::<Vec<_>>()
                .join(", "),
            self.enum_variant,
        )
    }
}

/// Errors that can occur while generating Rust translation bindings.
#[derive(thiserror::Error, Debug)]
pub enum Error {
    /// Duplicate Rust enum identifier derived from translation keys.
    #[error(transparent)]
    DuplicateIdentifier(#[from] DuplicateIdentifierError),
    /// Duplicate Rust struct field derived from translation arguments.
    #[error(transparent)]
    DuplicateField(#[from] DuplicateFieldError),
    /// Error originating from the `syn` crate when pretty-printing generated code.
    #[error("{0}")]
    Syn(String),
}

/// Generate a Rust `Translation` enum for the given translations model.
///
/// The generated code includes a `key` method that maps each variant back to
/// its original translation key.
///
/// # Errors
///
/// Returns an error if translation keys or argument names would result in
/// duplicate Rust identifiers, or if the generated code cannot be parsed by
/// `syn` for pretty-printing.
pub fn generate_translation_enum(translations: &model::Translations) -> Result<String, Error> {
    use itertools::Itertools;

    // Can we use https://github.com/rust-phf/rust-phf at compile time?

    let enum_variant_names: Vec<_> = translations
        .0
        .iter()
        .map(|(key, translation)| (key_to_rust_enum_variant(key.as_ref()), key, translation))
        .collect();

    // Find duplicate identifiers
    let duplicates: Vec<_> = enum_variant_names
        .iter()
        .duplicates_by(|(safe_key, _, _)| safe_key)
        .collect();

    if let Some(first) = duplicates.first() {
        let identifier = first.0.clone();
        let keys = duplicates
            .into_iter()
            .map(|(_, key, _)| key.to_string())
            .collect();
        return Err(DuplicateIdentifierError { identifier, keys }.into());
    }

    let enum_variants = enum_variant_names
        .iter()
        .map(|(safe_key, key, translation)| {
            let fields: Vec<_> = translation
                .arguments
                .iter()
                .map(|(name, typ)| (argument_to_rust_field_name(name), name, typ))
                .collect();

            // Check for duplicate field names
            let duplicates: Vec<_> = fields
                .iter()
                .duplicates_by(|(safe_name, _, _)| safe_name)
                .collect();

            if let Some(first) = duplicates.first() {
                let field = first.0.clone();
                let arguments = duplicates
                    .into_iter()
                    .map(|(_, key, _)| (*key).clone())
                    .collect();
                return Err(Error::from(DuplicateFieldError {
                    field,
                    arguments,
                    enum_variant: safe_key.clone(),
                    key: key.to_string(),
                }));
            }

            let fields = fields.into_iter().map(|(safe_name, name, typ)| {
                let field_ident = format_ident!("{safe_name}");
                let (typ, uses_lifetime) = typ.into_token_stream();
                let tokens = quote! {
                    #[serde(rename = #name)]
                    #field_ident: #typ,
                };
                (tokens, uses_lifetime)
            });

            let (fields, uses_lifetime): (Vec<_>, Vec<_>) = fields.unzip();
            let uses_lifetime = uses_lifetime.iter().any(|v| *v);

            let variant_name_ident = format_ident!("{safe_key}");
            let tokens = quote! {
                #variant_name_ident {
                    #(#fields)*
                },
            };
            Ok((tokens, uses_lifetime))
        });

    let (enum_variants, uses_lifetime): (Vec<_>, Vec<_>) = enum_variants.try_unzip()?;
    let uses_lifetime = uses_lifetime.iter().any(|v| *v);

    let enum_variant_keys: Vec<_> = enum_variant_names
        .iter()
        .map(|(safe_key, key, _)| {
            let variant_name_ident = format_ident!("{safe_key}");
            let key = key.as_ref();
            quote! {
                Self::#variant_name_ident { .. } => #key,
            }
        })
        .collect();

    // Build generics only if needed
    let generics: syn::Generics = if uses_lifetime {
        syn::parse_quote!(<'a>)
    } else {
        syn::Generics::default()
    };
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

    let out = quote! {
        #[derive(
            Debug, Clone, PartialEq, Eq, PartialOrd, Ord, ::serde::Serialize, ::serde::Deserialize,
        )]
        #[serde(untagged)]
        pub enum Translation #generics {
            #(#enum_variants)*
        }

        impl #impl_generics Translation #ty_generics #where_clause {
            pub fn key(&self) -> &'static str {
                match self {
                    #(#enum_variant_keys)*
                }
            }
        }
    };
    let code = pretty_print(&out).map_err(|err| Error::Syn(err.to_string()))?;
    let code = format!("{}\n{}", preamble(), code);
    Ok(code)
}

fn pretty_print<T>(input: T) -> Result<String, syn::Error>
where
    T: quote::ToTokens,
{
    let file: syn::File = syn::parse2(quote! { #input })?;
    Ok(prettyplease::unparse(&file))
}

#[cfg(test)]
mod tests {
    use color_eyre::eyre;
    use globetrotter_model::{self as model, diagnostics::Spanned};
    use similar_asserts::assert_eq as sim_assert_eq;

    static INIT: std::sync::Once = std::sync::Once::new();

    /// Initialize test
    ///
    /// This ensures `color_eyre` is setup once.
    pub fn init() {
        INIT.call_once(|| {
            color_eyre::install().ok();
        });
    }

    #[test]
    fn generate_enum_with_lifetime() -> eyre::Result<()> {
        crate::tests::init();

        let translations = [
            (
                Spanned::dummy("test.one".to_string()),
                model::Translation {
                    language: [(
                        model::Language::En,
                        Spanned::dummy("test.one in en".to_string()),
                    )]
                    .into_iter()
                    .collect(),
                    arguments: [].into_iter().collect(),
                    file_id: 0,
                },
            ),
            (
                Spanned::dummy("test.two".to_string()),
                model::Translation {
                    language: [(
                        model::Language::En,
                        Spanned::dummy("test.two in en".to_string()),
                    )]
                    .into_iter()
                    .collect(),
                    arguments: [
                        ("arg-one".to_string(), model::ArgumentType::String),
                        ("ArgTwo".to_string(), model::ArgumentType::Number),
                        ("Arg_Three".to_string(), model::ArgumentType::Any),
                    ]
                    .into_iter()
                    .collect(),
                    file_id: 0,
                },
            ),
        ];
        let translations = model::Translations(translations.into_iter().collect());
        let have = super::generate_translation_enum(&translations)?;
        println!("{have}");

        let want = indoc::indoc! {r#"
            #[derive(
                Debug,
                Clone,
                PartialEq,
                Eq,
                PartialOrd,
                Ord,
                ::serde::Serialize,
                ::serde::Deserialize,
            )]
            #[serde(untagged)]
            pub enum Translation<'a> {
                TestOne {},
                TestTwo {
                    #[serde(rename = "arg-one")]
                    arg_one: &'a str,
                    #[serde(rename = "ArgTwo")]
                    arg_two: i64,
                    #[serde(rename = "Arg_Three")]
                    arg_three: serde_json::Value,
                },
            }
            impl<'a> Translation<'a> {
                pub fn key(&self) -> &'static str {
                    match self {
                        Self::TestOne { .. } => "test.one",
                        Self::TestTwo { .. } => "test.two",
                    }
                }
            }
        "# };
        let want = format!("{}\n{}", super::preamble(), want);
        sim_assert_eq!(have: have, want: want);
        Ok(())
    }

    #[test]
    fn generate_enum_without_lifetime() -> eyre::Result<()> {
        crate::tests::init();

        let translations = [
            (
                Spanned::dummy("test.one".to_string()),
                model::Translation {
                    language: [(
                        model::Language::En,
                        Spanned::dummy("test.one in en".to_string()),
                    )]
                    .into_iter()
                    .collect(),
                    arguments: [].into_iter().collect(),
                    file_id: 0,
                },
            ),
            (
                Spanned::dummy("test.two".to_string()),
                model::Translation {
                    language: [(
                        model::Language::En,
                        Spanned::dummy("test.two in en".to_string()),
                    )]
                    .into_iter()
                    .collect(),
                    arguments: [("ArgTwo".to_string(), model::ArgumentType::Number)]
                        .into_iter()
                        .collect(),
                    file_id: 0,
                },
            ),
        ];
        let translations = model::Translations(translations.into_iter().collect());
        let have = super::generate_translation_enum(&translations)?;
        println!("{have}");

        let want = indoc::indoc! {r#"
            #[derive(
                Debug,
                Clone,
                PartialEq,
                Eq,
                PartialOrd,
                Ord,
                ::serde::Serialize,
                ::serde::Deserialize,
            )]
            #[serde(untagged)]
            pub enum Translation {
                TestOne {},
                TestTwo { #[serde(rename = "ArgTwo")] arg_two: i64 },
            }
            impl Translation {
                pub fn key(&self) -> &'static str {
                    match self {
                        Self::TestOne { .. } => "test.one",
                        Self::TestTwo { .. } => "test.two",
                    }
                }
            }
        "# };
        let want = format!("{}\n{}", super::preamble(), want);
        sim_assert_eq!(have: have, want: want);
        Ok(())
    }
}