fluent_typed_codegen 0.2.0

Automatic Fluent catalog discovery and typed code generation for Cargo
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
80
81
82
83
84

//! One locale selector for every generated module; no fixed language allowlist.
use crate::{discovery::CatalogSources, tree::names};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use std::collections::BTreeMap;

pub(super) fn render(sources: &CatalogSources) -> Result<TokenStream, String> {
	let mut variants = BTreeMap::new();

	for module in &sources.modules {
		let (_, variant) = names(&module.language)?;

		if let Some(previous) = variants.insert(variant.clone(), module.language.clone())
			&& previous != module.language
		{
			return Err(format!(
				"locale names `{previous}` and `{}` collide as Rust variant `{variant}`",
				module.language
			));
		}
	}

	let (_, default) = names(&sources.configuration.source_language)?;
	let identifiers: Vec<_> = variants
		.keys()
		.map(|variant| format_ident!("{variant}"))
		.collect();
	let languages: Vec<_> = variants.values().collect();
	let declarations =
		variants
			.keys()
			.zip(&identifiers)
			.zip(&languages)
			.map(|((variant, ident), language)| {
				let description = format!("`{language}`.");
				let default_attribute = (variant == &default).then(|| quote!(#[default]));

				quote! {
					#[doc = #description]
					#default_attribute
					#ident,
				}
			});

	Ok(quote! {
		/// All discovered languages. Default identifies the source language, not the startup policy.
		#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
		pub enum Locale {
			#(#declarations)*
		}

		impl ::std::convert::AsRef<str> for Locale {
			fn as_ref(&self) -> &str {
				match self {
					#(Self::#identifiers => #languages,)*
				}
			}
		}

		impl ::std::fmt::Display for Locale {
			fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
				f.write_str(self.as_ref())
			}
		}

		impl ::std::str::FromStr for Locale {
			type Err = ::std::string::String;

			fn from_str(value: &str) -> ::std::result::Result<Self, Self::Err> {
				match value {
					#(#languages => ::std::result::Result::Ok(Self::#identifiers),)*
					_ => ::std::result::Result::Err(format!("unknown compiled language: {value}")),
				}
			}
		}

		impl Locale {
			/// Iterate over compiled languages.
			pub fn iter() -> ::std::slice::Iter<'static, Self> {
				[#(Self::#identifiers,)*].iter()
			}
		}
	})
}