finchie/l10n_embed - Change OWXLFLRMQDTXWN5QQQLJNAATWFWXIN2S4UQA2LC2A6AWX4UWM6LQC

Merge `cli_macros` shim into `fluent_embed`

Part of an extended cleanup effort, fluent_embed will likely get renamed to fluent_embed_derive and fluent_embed_runtime will take its place, re-exporting the macro similar to serde.

Created by finchie on July 29, 2024

OWXLFLRMQDTXWN5QQQLJNAATWFWXIN2S4UQA2LC2A6AWX4UWM6LQC

Dependencies

In channels

main

Change contents

File deletion: cli_macros
BF:BFD[5.1] → [6.0:21]
BF:BFD[6.21] → [6.22:22]

File deletion: Cargo.toml

BF:BFD[6.22] → [6.676:710]

BF:BFD[6.710] → [6.711:711]

B:BD[6.711] → [6.712:888]

B:BD[6.888] → [7.13275:13328]

∅:D[8.2340] → [9.7484:7524]

B:BD[6.888] → [9.7484:7524]

∅:D[7.13328] → [8.2313:2340]

B:BD[6.888] → [8.2313:2340]

∅:D[9.7524] → [6.888:954]

B:BD[6.888] → [6.888:954]

B:BD[6.954] → [2.117:169]

∅:D[2.169] → [6.971:991]

∅:D[8.2355] → [6.971:991]

B:BD[6.971] → [6.971:991]

B:BD[6.991] → [10.2631:2691]

[package]
name = "cli_macros"
version = "0.1.0"
edition = "2021"
[lib]
proc-macro = true
[lints]
workspace = true
[dependencies]
fluent_embed = { path = "../fluent_embed" }
miette = { version = "7.2.0", features = ["fancy"] }
proc-macro2 = "1.0.78"
quote = "1.0.35"
proc-macro-error = "1.0.4"
syn = { version = "2.0.48", features = ["full", "extra-traits"] }
wax = { git = "https://github.com/Finchiedev/wax" }
[dev-dependencies]
fluent_embed_runtime = { path = "../fluent_embed_runtime" }

File deletion: src
BF:BFD[6.22] → [6.24:38]
BF:BFD[6.38] → [6.39:39]

File deletion: lib.rs

BF:BFD[6.39] → [6.41:71]

BF:BFD[6.71] → [6.72:72]

B:BD[6.72] → [6.73:130]

B:BD[6.130] → [7.9145:12219]

∅:D[7.12219] → [6.130:131]

B:BD[6.130] → [6.130:131]

B:BD[6.131] → [7.12220:12754]

B:BD[7.12754] → [3.6374:6424]

∅:D[3.6424] → [7.12920:13038]

B:BD[7.12920] → [7.12920:13038]

∅:D[8.512] → [6.206:231]

∅:D[9.7214] → [6.206:231]

∅:D[7.13038] → [6.206:231]

B:BD[6.206] → [6.206:231]

B:BD[6.231] → [8.513:533]

∅:D[8.533] → [6.231:307]

B:BD[6.231] → [6.231:307]

B:BD[6.307] → [9.7215:7285]

B:BD[9.7285] → [8.534:654]

∅:D[8.654] → [6.441:442]

∅:D[9.7350] → [6.441:442]

B:BD[6.441] → [6.441:442]

B:BD[6.442] → [8.655:791]

B:BD[8.791] → [7.13039:13069]

∅:D[11.838] → [8.820:868]

∅:D[7.13069] → [8.820:868]

B:BD[8.820] → [8.820:868]

B:BD[8.868] → [7.13070:13273]

∅:D[7.13273] → [12.714:715]

B:BD[12.714] → [12.714:715]

B:BD[8.1927] → [8.1927:2312]

∅:D[8.2312] → [6.600:614]

∅:D[9.7434] → [6.600:614]

B:BD[6.600] → [6.600:614]

B:BD[6.614] → [9.7435:7458]

∅:D[9.7458] → [6.635:636]

B:BD[6.635] → [6.635:636]

B:BD[6.636] → [9.7459:7483]

∅:D[9.7483] → [6.655:673]

B:BD[6.655] → [6.655:673]

B:BD[6.673] → [6.673:675]

B:BD[6.675] → [7.13274:13274]

//! A proc_macro shim for other crates in this workspace
use fluent_embed::{AttributeError, FluentError, MacroError};
use proc_macro::TokenStream;
use proc_macro_error::{abort, emit_call_site_error, emit_error, proc_macro_error};
use quote::{quote, ToTokens};
use syn::parse_macro_input;
fn attribute_error(error: AttributeError, derive_attribute: &syn::LitStr) {
    match error {
        AttributeError::Build(build_error) => {
            for location in build_error.locations() {
                // Create a token stream from the attribute's string literal
                let [proc_macro2::TokenTree::Literal(ref string_literal)] = derive_attribute
                    .to_token_stream()
                    .into_iter()
                    .collect::<Vec<_>>()[..]
                else {
                    abort!(derive_attribute, "unexpected macro attribute");
                };
                let (span_start, span_length) = location.span();
                let error_source = string_literal
                    // Offset by 1 to skip the starting `"` double-quote character
                    .subspan(span_start + 1..=span_start + span_length)
                    // Fall back to the whole attribute if `subspan()` returns `None`
                    // This will always happend on stable as subspan is nightly-only:
                    // https://docs.rs/proc-macro2/latest/proc_macro2/struct.Literal.html#method.subspan
                    .unwrap_or(derive_attribute.span());
                emit_error! { error_source, "invalid glob";
                    note = location.to_string();
                };
            }
        }
        AttributeError::Walk(walk_error) => {
            // Generate help text
            let help = if let Some(path) = walk_error.path() {
                let path_name = path.to_str().unwrap();
                // Might hit an error if file exists but insufficient permissions
                match path.try_exists() {
                    Ok(true) => {
                        format!("the path `{path_name}` exists, but unable to access it")
                    }
                    _ => format!("the path `{path_name}` doesn't seem to exist"),
                }
            } else {
                String::from("no associated path")
            };
            emit_error! { derive_attribute, "error at depth {} while walking path", walk_error.depth();
                help = help;
            };
        }
        AttributeError::NoMatches {
            path,
            complete_match,
        } => {
            // Validate the assumption that the user has provided an exact path
            assert!(path.exists());
            assert_eq!(path.to_string_lossy(), complete_match);
            emit_error! { derive_attribute, "cannot match against an exact path";
                help = "The attribute should use glob syntax to match against multiple files";
                note = "For example, you can:\n{}\n{}",
                "- Match against directories: locale/**/errors.ftl",
                "- Match against files: locale/*.ftl";
            };
        }
    }
}
fn fluent_error(error: FluentError) {
    // It doesn't seem like you can reference non-Rust source files
    // in `proc_macro::Span`, so use Miette to pretty-print our own reports.
    // This includes setting up a global report handler with some extra options
    miette::set_hook(Box::new(|_| {
        Box::new(
            miette::MietteHandlerOpts::new()
                // Force color output, even when printing using the debug formatter
                .color(true)
                .build(),
        )
    }))
    .unwrap();
    eprintln!("{:?}", miette::Error::new(error));
    // Make sure compilation fails
    emit_call_site_error!("invalid Fluent source code, see above for details");
}
#[proc_macro_attribute]
#[proc_macro_error]
pub fn localize(attribute: TokenStream, item: TokenStream) -> TokenStream {
    let original_item = proc_macro2::TokenStream::from(item.clone());
    let derive_attribute: syn::LitStr = parse_macro_input!(attribute);
    let derive_input = parse_macro_input!(item);
    let implementation = match fluent_embed::localize(&derive_attribute, &derive_input) {
        Ok(implementation) => implementation,
        Err(macro_error) => {
            // Emit the relevant error messages
            match macro_error {
                MacroError::Attribute(error) => attribute_error(error, &derive_attribute),
                MacroError::Fluent(error) => fluent_error(error),
            }
            // Generate a minimal `localize()` implementation so the error is self-contained
            let ident = &derive_input.ident;
            quote! {
                impl #ident {
                    fn localize(&self) -> String {
                        unimplemented!("Encountered error in proc-macro")
                    }
                }
            }
        }
    };
    quote! {
        #original_item
        #implementation
    }
    .into()
}

File move: tests → tests
BF:BFD[6.22] → [13.84:100]
BF:BF[13.100] → [13.101:101]
[14.24]
[13.101]
Replacement in fluent_embed/tests/selectors.rs at line 3 [13.140]
B:BD[13.243] → [13.243:269]
```
use cli_macros::localize;
```
[13.243]
[10.2594]
```
use fluent_embed::localize;
```
Replacement in fluent_embed/src/lib.rs at line 6 [14.74]
∅:D[7.6636] → [9.4318:4348]
B:BD[9.4318] → [9.4318:4348]
```
use proc_macro2::TokenStream;
```
[7.6636]
[9.4348]
```
use proc_macro::TokenStream;
use proc_macro_error::proc_macro_error;
```
Insertion in fluent_embed/src/lib.rs at line 9 [14.74]
[9.4366]
[7.6637]
```
use syn::parse_macro_input;
```
Insertion in fluent_embed/src/lib.rs at line 14 [14.74]
[15.12]
[15.12]
```
mod error;
```
Deletion in fluent_embed/src/lib.rs at line 16 [14.74]
∅:D[15.24] → [11.25:26]
B:BD[16.1625] → [11.25:26]
B:BD[11.26] → [15.25:63]
```
pub use fluent::Error as FluentError;
```
Replacement in fluent_embed/src/lib.rs at line 19 [14.74]
∅:D[7.6777] → [11.61:87]
B:BD[11.61] → [11.61:87]
```
pub enum AttributeError {
```
[7.6777]
[11.107]
```
enum AttributeError {
```
Replacement in fluent_embed/src/lib.rs at line 32 [14.74]
B:BD[7.6941] → [7.6941:6963]
```
pub enum MacroError {
```
[7.6941]
[7.6963]
```
enum MacroError {
```
Replacement in fluent_embed/src/lib.rs at line 35 [14.74]
∅:D[3.43] → [7.7046:7079]
B:BD[7.7046] → [7.7046:7079]
```
    Fluent(#[from] FluentError),
```
[3.43]
[11.294]
```
    Fluent(#[from] fluent::Error),
```
Replacement in fluent_embed/src/lib.rs at line 38 [14.74]
B:BD[17.1387] → [15.64:95]
```
pub fn locales_from_attribute(
```
[17.1387]
[15.95]
```
fn locales_from_attribute(
```
Replacement in fluent_embed/src/lib.rs at line 74 [14.74]
B:BD[9.5475] → [15.457:474]
```
pub fn localize(
```
[9.5475]
[15.474]
```
fn localize_impl(
```

Replacement in fluent_embed/src/lib.rs at line 77 [14.74]

B:BD[15.540] → [15.540:634]

) -> Result<TokenStream, MacroError> {
    let locales = locales_from_attribute(&attribute)?;

[15.540]

[15.664]

) -> Result<proc_macro2::TokenStream, MacroError> {
    let locales = locales_from_attribute(attribute)?;

Insertion in fluent_embed/src/lib.rs at line 103 [14.74]

[9.6118]


#[proc_macro_attribute]
#[proc_macro_error]
pub fn localize(attribute: TokenStream, item: TokenStream) -> TokenStream {
    let original_item = proc_macro2::TokenStream::from(item.clone());
    let derive_attribute: syn::LitStr = parse_macro_input!(attribute);
    let derive_input = parse_macro_input!(item);
    let implementation = localize_impl(&derive_attribute, &derive_input)
        .unwrap_or_else(|error| error::handle(error, &derive_attribute, &derive_input.ident));
    quote! {
        #original_item
        #implementation
    }
    .into()
}

File addition: error.rs (----------)

[14.41]

use super::{AttributeError, MacroError};
use proc_macro_error::{abort, emit_call_site_error, emit_error};
use quote::{quote, ToTokens};
fn attribute(error: AttributeError, derive_attribute: &syn::LitStr) {
    match error {
        AttributeError::Build(build_error) => {
            for location in build_error.locations() {
                // Create a token stream from the attribute's string literal
                let [proc_macro2::TokenTree::Literal(ref string_literal)] = derive_attribute
                    .to_token_stream()
                    .into_iter()
                    .collect::<Vec<_>>()[..]
                else {
                    abort!(derive_attribute, "unexpected macro attribute");
                };
                let (span_start, span_length) = location.span();
                let error_source = string_literal
                    // Offset by 1 to skip the starting `"` double-quote character
                    .subspan(span_start + 1..=span_start + span_length)
                    // Fall back to the whole attribute if `subspan()` returns `None`
                    // This will always happend on stable as subspan is nightly-only:
                    // https://docs.rs/proc-macro2/latest/proc_macro2/struct.Literal.html#method.subspan
                    .unwrap_or(derive_attribute.span());
                emit_error! { error_source, "invalid glob";
                    note = location.to_string();
                };
            }
        }
        AttributeError::Walk(walk_error) => {
            // Generate help text
            let help = if let Some(path) = walk_error.path() {
                let path_name = path.to_str().unwrap();
                // Might hit an error if file exists but insufficient permissions
                match path.try_exists() {
                    Ok(true) => {
                        format!("the path `{path_name}` exists, but unable to access it")
                    }
                    _ => format!("the path `{path_name}` doesn't seem to exist"),
                }
            } else {
                String::from("no associated path")
            };
            emit_error! { derive_attribute, "error at depth {} while walking path", walk_error.depth();
                help = help;
            };
        }
        AttributeError::NoMatches {
            path,
            complete_match,
        } => {
            // Validate the assumption that the user has provided an exact path
            assert!(path.exists());
            assert_eq!(path.to_string_lossy(), complete_match);
            emit_error! { derive_attribute, "cannot match against an exact path";
                help = "The attribute should use glob syntax to match against multiple files";
                note = "For example, you can:\n{}\n{}",
                "- Match against directories: locale/**/errors.ftl",
                "- Match against files: locale/*.ftl";
            };
        }
    }
}
fn fluent(error: super::fluent::Error) {
    // It doesn't seem like you can reference non-Rust source files
    // in `proc_macro::Span`, so use Miette to pretty-print our own reports.
    // This includes setting up a global report handler with some extra options
    miette::set_hook(Box::new(|_| {
        Box::new(
            miette::MietteHandlerOpts::new()
                // Force color output, even when printing using the debug formatter
                .color(true)
                .build(),
        )
    }))
    .unwrap();
    eprintln!("{:?}", miette::Error::new(error));
    // Make sure compilation fails
    emit_call_site_error!("invalid Fluent source code, see above for details");
}
pub fn handle(
    error: MacroError,
    derive_attribute: &syn::LitStr,
    ident: &syn::Ident,
) -> proc_macro2::TokenStream {
    match error {
        MacroError::Attribute(error) => attribute(error, derive_attribute),
        MacroError::Fluent(error) => fluent(error),
    };
    // Generate a minimal `localize()` implementation so the error is self-contained
    quote! {
        impl #ident {
            fn localize(&self) -> String {
                unimplemented!("Encountered error in derive macro")
            }
        }
    }
}

Insertion in fluent_embed/Cargo.toml at line 5 [14.1300]
[14.1368]
[14.1368]
```
[lib]
proc-macro = true
```
Replacement in fluent_embed/Cargo.toml at line 16 [14.1300]
∅:D[18.4623] → [7.9127:9144]
B:BD[19.574] → [7.9127:9144]
```
miette = "7.2.0"
```
[18.4623]
[14.1488]
```
miette = { version = "7.2.0", features = ["fancy"] }
```
Insertion in fluent_embed/Cargo.toml at line 18 [14.1300]
[14.1511]
[14.1511]
```
proc-macro-error = "1.0.4"
```
Replacement in fluent_embed/Cargo.toml at line 25 [14.1300]
B:BD[20.258] → [20.258:282]
```
prettyplease = "0.2.16"
```
[20.258]
```
fluent_embed_runtime = { path = "../fluent_embed_runtime" }
```

Replacement in Cargo.toml at line 2 [21.197]

B:BD[21.210] → [4.0:101]

members = [
    "fluent_embed",
    "cli_macros",
    "locale_select",
    "fluent_embed_runtime",
]

[21.210]

[21.238]

members = ["fluent_embed", "locale_select", "fluent_embed_runtime"]

Deletion in Cargo.lock at line 82 [24.4277]
∅:D[22.377] → [23.1230:1243]
∅:D[7.14656] → [23.1230:1243]
B:BD[23.1230] → [23.1230:1243]
∅:D[23.1243] → [6.1106:1178]
B:BD[6.1106] → [6.1106:1178]
B:BD[6.1178] → [10.2792:2817]
∅:D[10.2817] → [7.14657:14668]
B:BD[25.18] → [7.14657:14668]
∅:D[7.14668] → [8.2356:2377]
B:BD[25.18] → [8.2356:2377]
∅:D[8.2377] → [9.7525:7541]
B:BD[25.18] → [9.7525:7541]
∅:D[25.18] → [6.1208:1218]
∅:D[9.7541] → [6.1208:1218]
B:BD[6.1208] → [6.1208:1218]
B:BD[6.1218] → [18.5012:5027]
∅:D[18.5027] → [8.2393:2401]
B:BD[8.2393] → [8.2393:2401]
∅:D[8.2401] → [23.1244:1246]
B:BD[6.1226] → [23.1244:1246]
```
[[package]]
name = "cli_macros"
version = "0.1.0"
dependencies = [
 "fluent_embed",
 "fluent_embed_runtime",
 "miette",
 "proc-macro-error",
 "proc-macro2",
 "quote",
 "syn 2.0.71",
 "wax",
]
```
Insertion in Cargo.lock at line 166 [24.4277]
[14.1943]
[14.1943]
```
 "fluent_embed_runtime",
```
Replacement in Cargo.lock at line 170 [24.4277]
∅:D[19.589] → [20.283:300]
∅:D[7.15020] → [20.283:300]
B:BD[14.1952] → [20.283:300]
```
 "prettyplease",
```
[7.15020]
[14.1952]
```
 "proc-macro-error",
```
Deletion in Cargo.lock at line 665 [24.4277]
∅:D[23.3028] → [20.301:323]
B:BD[24.4501] → [20.301:323]
B:BD[20.323] → [18.10667:10686]
∅:D[18.10686] → [20.342:407]
B:BD[20.342] → [20.342:407]
B:BD[20.407] → [18.10687:10765]
∅:D[18.10765] → [20.485:518]
B:BD[20.485] → [20.485:518]
B:BD[20.518] → [18.10766:10781]
∅:D[18.10781] → [8.2481:2496]
B:BD[8.2481] → [8.2481:2496]
```
name = "prettyplease"
version = "0.2.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f12335488a2f3b0a83b14edad48dca9879ce89b2edd10e80237e4e852dd645e"
dependencies = [
 "proc-macro2",
 "syn 2.0.71",
]
[[package]]
```

Merge `cli_macros` shim into `fluent_embed`

Dependencies

In channels

Change contents

File deletion: cli_macros

File deletion: Cargo.toml

File deletion: src

File deletion: lib.rs

File move: tests → tests

Replacement in fluent_embed/tests/selectors.rs at line 3 [13.140]

Replacement in fluent_embed/src/lib.rs at line 6 [14.74]

Insertion in fluent_embed/src/lib.rs at line 9 [14.74]

Insertion in fluent_embed/src/lib.rs at line 14 [14.74]

Deletion in fluent_embed/src/lib.rs at line 16 [14.74]

Replacement in fluent_embed/src/lib.rs at line 19 [14.74]

Replacement in fluent_embed/src/lib.rs at line 32 [14.74]

Replacement in fluent_embed/src/lib.rs at line 35 [14.74]

Replacement in fluent_embed/src/lib.rs at line 38 [14.74]

Replacement in fluent_embed/src/lib.rs at line 74 [14.74]

Replacement in fluent_embed/src/lib.rs at line 77 [14.74]

Insertion in fluent_embed/src/lib.rs at line 103 [14.74]

File addition: error.rs (----------)

Insertion in fluent_embed/Cargo.toml at line 5 [14.1300]

Replacement in fluent_embed/Cargo.toml at line 16 [14.1300]

Insertion in fluent_embed/Cargo.toml at line 18 [14.1300]

Replacement in fluent_embed/Cargo.toml at line 25 [14.1300]

Replacement in Cargo.toml at line 2 [21.197]

Deletion in Cargo.lock at line 82 [24.4277]

Insertion in Cargo.lock at line 166 [24.4277]

Replacement in Cargo.lock at line 170 [24.4277]

Deletion in Cargo.lock at line 665 [24.4277]