use icu4x for number formatting

Author: JasperDeSutter

fluent-bundle/Cargo.toml

@@ -26,8 +26,12 @@ include = [
 ]
 
 [dependencies]
+fixed_decimal = { version = "0.5.1", features = ["ryu"] }
 fluent-langneg.workspace = true
 fluent-syntax.workspace = true
+icu_decimal = "1"
+icu_locid = "1"
+icu_provider = { version = "1", features = ["sync"] }
 intl_pluralrules.workspace = true
 rustc-hash.workspace = true
 unic-langid.workspace = true

fluent-bundle/src/bundle.rs

@@ -4,6 +4,7 @@
 //! internationalization formatters, functions, scopeironmental variables and are expected to be used
 //! together.
 
+use icu_provider::AnyProvider;
 use rustc_hash::FxHashMap;
 use std::borrow::Borrow;
 use std::borrow::Cow;
@@ -25,6 +26,8 @@ use crate::resolver::{ResolveValue, Scope, WriteValue};
 use crate::resource::FluentResource;
 use crate::types::FluentValue;
 
+pub type IcuDataProvider = Box<dyn AnyProvider>;
+
 /// A collection of localization messages for a single locale, which are meant
 /// to be used together in a single view, widget or any other UI abstraction.
 ///
@@ -141,6 +144,7 @@ pub struct FluentBundle<R, M> {
     pub(crate) use_isolating: bool,
     pub(crate) transform: Option<fn(&str) -> Cow<str>>,
     pub(crate) formatter: Option<fn(&FluentValue, &M) -> Option<String>>,
+    pub(crate) icu_data_provider: Option<IcuDataProvider>,
 }
 
 impl<R, M> FluentBundle<R, M> {
@@ -586,6 +590,7 @@ impl<R> FluentBundle<R, IntlLangMemoizer> {
             use_isolating: true,
             transform: None,
             formatter: None,
+            icu_data_provider: None,
         }
     }
 }

fluent-bundle/src/concurrent.rs

@@ -31,6 +31,7 @@ impl<R> FluentBundle<R, IntlLangMemoizer> {
             use_isolating: true,
             transform: None,
             formatter: None,
+            icu_data_provider: None,
         }
     }
 }

fluent-bundle/src/types/mod.rs

@@ -228,7 +228,7 @@ impl<'source> FluentValue<'source> {
         }
         match self {
             FluentValue::String(s) => w.write_str(s),
-            FluentValue::Number(n) => w.write_str(&n.as_string()),
+            FluentValue::Number(n) => w.write_str(&n.as_string(scope.bundle)),
             FluentValue::Custom(s) => w.write_str(&scope.bundle.intls.stringify_value(&**s)),
             FluentValue::Error => Ok(()),
             FluentValue::None => Ok(()),
@@ -247,7 +247,7 @@ impl<'source> FluentValue<'source> {
         }
         match self {
             FluentValue::String(s) => s.clone(),
-            FluentValue::Number(n) => n.as_string(),
+            FluentValue::Number(n) => n.as_string(scope.bundle),
             FluentValue::Custom(s) => scope.bundle.intls.stringify_value(&**s),
             FluentValue::Error => "".into(),
             FluentValue::None => "".into(),

fluent-bundle/src/types/number.rs

@@ -3,9 +3,19 @@ use std::convert::TryInto;
 use std::default::Default;
 use std::str::FromStr;
 
+use fixed_decimal::{DoublePrecision, FixedDecimal};
+use icu_decimal::options::{FixedDecimalFormatterOptions, GroupingStrategy};
+use icu_decimal::provider::DecimalSymbolsV1Marker;
+use icu_decimal::{DecimalError, FixedDecimalFormatter};
+use icu_locid::{LanguageIdentifier as IcuLanguageIdentifier, ParserError};
+use icu_provider::prelude::*;
+use intl_memoizer::Memoizable;
 use intl_pluralrules::operands::PluralOperands;
+use unic_langid::LanguageIdentifier;
 
 use crate::args::FluentArgs;
+use crate::bundle::{FluentBundle, IcuDataProvider};
+use crate::memoizer::MemoizerKind;
 use crate::types::FluentValue;
 
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
@@ -133,22 +143,38 @@ impl FluentNumber {
         Self { value, options }
     }
 
-    pub fn as_string(&self) -> Cow<'static, str> {
-        let mut val = self.value.to_string();
+    pub fn as_string<R, M: MemoizerKind>(&self, bundle: &FluentBundle<R, M>) -> Cow<'static, str> {
+        let fixed_decimal = self.as_fixed_decimal();
+        let options = FormatterOptions {
+            use_grouping: self.options.use_grouping,
+        };
+        if let Some(data_provider) = &bundle.icu_data_provider {
+            let formatted = bundle
+                .intls
+                .with_try_get_threadsafe::<NumberFormatter, _, _>(
+                    (options,),
+                    data_provider,
+                    |formatter| formatter.0.format_to_string(&fixed_decimal),
+                )
+                .unwrap();
+            return formatted.into();
+        }
+
+        fixed_decimal.to_string().into()
+    }
+
+    fn as_fixed_decimal(&self) -> FixedDecimal {
+        let mut fixed_decimal =
+            FixedDecimal::try_from_f64(self.value, DoublePrecision::Floating).unwrap();
+
         if let Some(minfd) = self.options.minimum_fraction_digits {
-            if let Some(pos) = val.find('.') {
-                let frac_num = val.len() - pos - 1;
-                let missing = if frac_num > minfd {
-                    0
-                } else {
-                    minfd - frac_num
-                };
-                val = format!("{}{}", val, "0".repeat(missing));
-            } else {
-                val = format!("{}.{}", val, "0".repeat(minfd));
-            }
+            fixed_decimal.pad_end(-(minfd as i16));
         }
-        val.into()
+        fixed_decimal
+    }
+
+    pub fn as_string_basic(&self) -> String {
+        self.as_fixed_decimal().to_string()
     }
 }
 
@@ -238,8 +264,58 @@ from_num!(i8 i16 i32 i64 i128 isize);
 from_num!(u8 u16 u32 u64 u128 usize);
 from_num!(f32 f64);
 
+pub type NumberFormatProvider = Box<dyn DataProvider<DecimalSymbolsV1Marker>>;
+
+#[derive(Debug, Eq, PartialEq, Clone, Default, Hash)]
+struct FormatterOptions {
+    use_grouping: bool,
+}
+
+struct NumberFormatter(FixedDecimalFormatter);
+
+#[derive(Debug)]
+enum NumberFormatterError {
+    ParserError(ParserError),
+    DecimalError(DecimalError),
+}
+
+impl Memoizable for NumberFormatter {
+    type Args = (FormatterOptions,);
+    type Error = NumberFormatterError;
+    type DataProvider = IcuDataProvider;
+
+    fn construct(
+        lang: LanguageIdentifier,
+        args: Self::Args,
+        data_provider: &Self::DataProvider,
+    ) -> Result<Self, Self::Error> {
+        let locale = to_icu_lang_id(lang).map_err(NumberFormatterError::ParserError)?;
+
+        let mut options: FixedDecimalFormatterOptions = Default::default();
+        options.grouping_strategy = match args.0.use_grouping {
+            true => GroupingStrategy::Always,
+            false => GroupingStrategy::Auto,
+        };
+
+        let inner = FixedDecimalFormatter::try_new_with_any_provider(
+            data_provider,
+            &locale.into(),
+            options,
+        )
+        .map_err(NumberFormatterError::DecimalError)?;
+        Ok(NumberFormatter(inner))
+    }
+}
+
+fn to_icu_lang_id(lang: LanguageIdentifier) -> Result<IcuLanguageIdentifier, ParserError> {
+    return IcuLanguageIdentifier::try_from_locale_bytes(lang.to_string().as_bytes());
+}
+
 #[cfg(test)]
 mod tests {
+    use super::to_icu_lang_id;
+    use unic_langid::langid;
+
     use crate::types::FluentValue;
 
     #[test]
@@ -249,4 +325,16 @@ mod tests {
         let z: FluentValue = y.into();
         assert_eq!(z, FluentValue::try_number(1));
     }
+
+    #[test]
+    fn lang_to_icu() {
+        assert_eq!(
+            to_icu_lang_id(langid!("en-US")).unwrap(),
+            icu_locid::langid!("en-US")
+        );
+        assert_eq!(
+            to_icu_lang_id(langid!("pl")).unwrap(),
+            icu_locid::langid!("pl")
+        );
+    }
 }

fluent-bundle/tests/types_test.rs

@@ -123,18 +123,18 @@ fn fluent_number_style() {
     assert_eq!(fno.use_grouping, false);
 
     let num = FluentNumber::new(0.2, FluentNumberOptions::default());
-    assert_eq!(num.as_string(), "0.2");
+    assert_eq!(num.as_string_basic(), "0.2");
 
     let opts = FluentNumberOptions {
         minimum_fraction_digits: Some(3),
         ..Default::default()
     };
 
     let num = FluentNumber::new(0.2, opts.clone());
-    assert_eq!(num.as_string(), "0.200");
+    assert_eq!(num.as_string_basic(), "0.200");
 
     let num = FluentNumber::new(2.0, opts);
-    assert_eq!(num.as_string(), "2.000");
+    assert_eq!(num.as_string_basic(), "2.000");
 }
 
 #[test]