Finchie/l10n_embed - Change 7U2DXFMPZO4P53AMWYCVXG3EPB7UIAPEY4PDDINX4TTABHD5NGMQC

Refactor `fluent_embed::Localize` to support overriding locales

A small consequence is that fluent_embed::time::RelativeTime no longer implements Localize, which may need to be revisited later. Also, now that the caller can override the locale, a valid locale is not guaranteed; might need to add error handling or something similar.'

Created by finchie on July 31, 2024

7U2DXFMPZO4P53AMWYCVXG3EPB7UIAPEY4PDDINX4TTABHD5NGMQC

Dependencies

In channels

main

Change contents

Insertion in fluent_embed_derive/src/lib.rs at line 82 [5.74]

[3.1384]

[4.5596]


    let locales = match &derive_input.data {
        syn::Data::Struct(_struct_data) => derive::locales_for_ident(&group, &derive_input.ident),
        syn::Data::Enum(enum_data) => derive::locales_for_enum(&group, &enum_data.variants),
        syn::Data::Union(_) => todo!(),
    };

Replacement in fluent_embed_derive/src/lib.rs at line 89 [5.74]
B:BD[4.5597] → [4.5597:5639]
```
    let body = match &derive_input.data {
```
[4.5597]
[6.7399]
```
    let message_body = match &derive_input.data {
```

Replacement in fluent_embed_derive/src/lib.rs at line 91 [5.74]

B:BD[6.7443] → [7.775:855]

            derive::for_struct(group, &derive_input.ident, &struct_data.fields)

[6.7443]

[6.7531]

            derive::message_for_struct(group, &derive_input.ident, &struct_data.fields)

Replacement in fluent_embed_derive/src/lib.rs at line 93 [5.74]

B:BD[6.7541] → [7.856:940]

        syn::Data::Enum(enum_data) => derive::for_enum(group, &enum_data.variants),

[6.7541]

[4.5830]

        syn::Data::Enum(enum_data) => derive::messages_for_enum(group, &enum_data.variants),

Insertion in fluent_embed_derive/src/lib.rs at line 103 [5.74]

[2.268]

[4.6021]


            fn message_for_locale(&self, locale: &::fluent_embed::icu_locid::LanguageIdentifier) -> String {
                #message_body
            }

Replacement in fluent_embed_derive/src/lib.rs at line 109 [5.74]

B:BD[4.6064] → [4.6064:6086]

                #body

[4.6064]

[4.6086]

                let available_locales = #locales;
                let selected_locale = ::fluent_embed::locale_select::match_locales(&available_locales, &Self::CANONICAL_LOCALE);
                self.message_for_locale(&selected_locale)

Insertion in fluent_embed_derive/src/fluent/group.rs at line 113 [9.3543]

[8.1114]

[9.6614]


    pub fn locales_for_message<'a>(&'a self, id: &'a str) -> impl Iterator<Item = &Locale> + 'a {
        self.locales
            .iter()
            .filter(|(_locale, messages)| messages.contains_expression(id))
            .map(|(locale, _source_file)| locale)
    }

Deletion in fluent_embed_derive/src/derive.rs at line 39 [10.39]

B:BD[6.510] → [3.1729:1985]

B:BD[3.1985] → [2.372:434]

∅:D[2.434] → [3.2055:2066]

B:BD[3.2055] → [3.2055:2066]

B:BD[3.2066] → [2.435:532]

∅:D[2.532] → [11.625:626]

∅:D[4.902] → [11.625:626]

∅:D[3.2171] → [11.625:626]

B:BD[11.625] → [11.625:626]

        // Create a list of available locales to choose from
        let available_locales = [
            // The canonical locale will always be available
            Self::CANONICAL_LOCALE,
            // Any additional locales that contain this message
            #(::fluent_embed::langid!(#additional_locales)),*
        ];
        let locale = ::fluent_embed::select_locale(&available_locales, &Self::CANONICAL_LOCALE);

Replacement in fluent_embed_derive/src/derive.rs at line 41 [10.39]

B:BD[3.2231] → [2.533:598]

        const plural_rule_type: ::fluent_embed::PluralRuleType =

[3.2231]

[2.598]

        const PLURAL_RULE_TYPE: ::fluent_embed::PluralRuleType =

Replacement in fluent_embed_derive/src/derive.rs at line 43 [10.39]

B:BD[2.652] → [2.652:745]

        let plural_rules = ::fluent_embed::plural_rules(&locale, plural_rule_type).unwrap();

[2.652]

[12.712]

        let plural_rules = ::fluent_embed::plural_rules(&locale, PLURAL_RULE_TYPE).unwrap();

Replacement in fluent_embed_derive/src/derive.rs at line 68 [10.39]

B:BD[13.45] → [7.9670:9689]

pub fn for_struct(

[13.45]

[7.9689]

pub fn locales_for_ident(group: &fluent::Group, ident: &syn::Ident) -> TokenStream {
    let id = ident.to_string().to_kebab_case();
    let locale_literals = group
        .locales_for_message(&id)
        .map(|locale| locale.id.to_string())
        .map(|locale_string| syn::LitStr::new(&locale_string, proc_macro2::Span::call_site()));
    // There is only one message for this struct, so just list every supported locale
    quote!(vec![#(::fluent_embed::langid!(#locale_literals)),*])
}
pub fn message_for_struct(

Replacement in fluent_embed_derive/src/derive.rs at line 101 [10.39]

B:BD[14.116] → [7.10013:10030]

pub fn for_enum(

[14.116]

[7.10030]

pub fn locales_for_enum(
    group: &fluent::Group,
    enum_variants: &Punctuated<syn::Variant, syn::token::Comma>,
) -> TokenStream {
    let mut match_arms: Vec<TokenStream> = Vec::with_capacity(enum_variants.len());
    for enum_variant in enum_variants {
        let variant_ident = &enum_variant.ident;
        // Simplify match code by always ignoring enum fields (even if they don't exist)
        // We are matching the variant name, not any data, so each arm will have something like:
        // Self::VariantName { .. }
        // Even if `Self::VariantName` doesn't contain any data
        let locales_for_variant = locales_for_ident(group, variant_ident);
        match_arms.push(quote!(Self::#variant_ident { .. } => #locales_for_variant));
    }
    quote! {
        match self {
            #(#match_arms),*
        }
    }
}
pub fn messages_for_enum(

Insertion in fluent_embed/src/time.rs at line 21 [15.53]
[15.769]
[15.769]
```
    const CANONICAL_LOCALE: LanguageIdentifier = DEFAULT_LOCALE;
```

Deletion in fluent_embed/src/time.rs at line 26 [15.53]

B:BD[15.846] → [15.846:954]

}
impl crate::Localize for RelativeTime {
    const CANONICAL_LOCALE: LanguageIdentifier = DEFAULT_LOCALE;

Replacement in fluent_embed/src/time.rs at line 27 [15.53]
B:BD[15.955] → [15.955:990]
```
    fn localize(&self) -> String {
```
[15.955]
[15.990]
```
    pub fn localize(&self) -> String {
```
Deletion in fluent_embed/src/lib.rs at line 16 [3.82]
B:BD[3.475] → [3.475:511]
```
    fn localize(&self) -> String;
}
```

Replacement in fluent_embed/src/lib.rs at line 17 [3.82]

B:BD[3.512] → [3.512:807]

/// Select which locale to use, falling back to the canonical locale if nothing matches
pub fn select_locale(
    available_locales: &[LanguageIdentifier],
    canonical_locale: &LanguageIdentifier,
) -> LanguageIdentifier {
    locale_select::match_locales(available_locales, canonical_locale)

[3.512]

[3.807]

    fn message_for_locale(&self, locale: &LanguageIdentifier) -> String;
    fn localize(&self) -> String;