add missing options for FluentNumber use_grouping

Author: JasperDeSutter

fluent-bundle/src/types/mod.rs

@@ -273,7 +273,7 @@ impl<'source> FluentValue<'source> {
         }
         match self {
             FluentValue::String(s) => s,
-            FluentValue::Number(n) => n.as_string(),
+            FluentValue::Number(n) => n.as_string(scope.bundle),
             FluentValue::Custom(s) => scope.bundle.intls.stringify_value(s.as_ref()),
             FluentValue::Error => "".into(),
             FluentValue::None => "".into(),

fluent-bundle/src/types/number.rs

@@ -73,37 +73,34 @@ impl From<&str> for FluentNumberCurrencyDisplayStyle {
     }
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum FluentNumberUseGrouping {
+    Auto,
+    False,
+    Always,
+    Min2,
+}
+
+impl Default for FluentNumberUseGrouping {
+    fn default() -> Self {
+        Self::Auto
+    }
+}
+
+#[derive(Default, Debug, Clone, Hash, PartialEq, Eq)]
 pub struct FluentNumberOptions {
     pub r#type: FluentNumberType,
     pub style: FluentNumberStyle,
     pub currency: Option<String>,
     pub currency_display: FluentNumberCurrencyDisplayStyle,
-    pub use_grouping: bool,
+    pub use_grouping: FluentNumberUseGrouping,
     pub minimum_integer_digits: Option<usize>,
     pub minimum_fraction_digits: Option<usize>,
     pub maximum_fraction_digits: Option<usize>,
     pub minimum_significant_digits: Option<usize>,
     pub maximum_significant_digits: Option<usize>,
 }
 
-impl Default for FluentNumberOptions {
-    fn default() -> Self {
-        Self {
-            r#type: Default::default(),
-            style: Default::default(),
-            currency: None,
-            currency_display: Default::default(),
-            use_grouping: true,
-            minimum_integer_digits: None,
-            minimum_fraction_digits: None,
-            maximum_fraction_digits: None,
-            minimum_significant_digits: None,
-            maximum_significant_digits: None,
-        }
-    }
-}
-
 impl FluentNumberOptions {
     pub fn merge(&mut self, opts: &FluentArgs) {
         for (key, value) in opts.iter() {
@@ -121,7 +118,12 @@ impl FluentNumberOptions {
                     self.currency_display = n.as_ref().into();
                 }
                 ("useGrouping", FluentValue::String(n)) => {
-                    self.use_grouping = n != "false";
+                    self.use_grouping = match n.as_ref() {
+                        "false" => FluentNumberUseGrouping::False,
+                        "always" => FluentNumberUseGrouping::Always,
+                        "min2" => FluentNumberUseGrouping::Min2,
+                        _ => FluentNumberUseGrouping::Auto,
+                    }
                 }
                 ("minimumIntegerDigits", FluentValue::Number(n)) => {
                     self.minimum_integer_digits = Some(n.into());
@@ -278,9 +280,9 @@ from_num!(f32 f64);
 
 pub type NumberFormatProvider = Box<dyn DataProvider<DecimalSymbolsV1Marker>>;
 
-#[derive(Debug, Eq, PartialEq, Clone, Default, Hash)]
+#[derive(Clone, Hash, PartialEq, Eq)]
 struct FormatterOptions {
-    use_grouping: bool,
+    use_grouping: FluentNumberUseGrouping,
 }
 
 struct NumberFormatter(FixedDecimalFormatter);
@@ -306,8 +308,10 @@ impl Memoizable for NumberFormatter {
 
         let mut options: FixedDecimalFormatterOptions = Default::default();
         options.grouping_strategy = match args.0.use_grouping {
-            true => GroupingStrategy::Always,
-            false => GroupingStrategy::Auto,
+            FluentNumberUseGrouping::Auto => GroupingStrategy::Auto,
+            FluentNumberUseGrouping::False => GroupingStrategy::Never,
+            FluentNumberUseGrouping::Always => GroupingStrategy::Always,
+            FluentNumberUseGrouping::Min2 => GroupingStrategy::Min2,
         };
 
         let inner = FixedDecimalFormatter::try_new_with_any_provider(

fluent-bundle/tests/types_test.rs

@@ -1,6 +1,6 @@
 use fluent_bundle::resolver::Scope;
 use fluent_bundle::types::{
-    FluentNumber, FluentNumberCurrencyDisplayStyle, FluentNumberOptions, FluentNumberStyle,
+    FluentNumber, FluentNumberCurrencyDisplayStyle, FluentNumberOptions, FluentNumberStyle, FluentNumberUseGrouping,
 };
 use fluent_bundle::FluentArgs;
 use fluent_bundle::FluentBundle;
@@ -120,7 +120,7 @@ fn fluent_number_style() {
     assert_eq!(fno.style, FluentNumberStyle::Currency);
     assert_eq!(fno.currency, Some("EUR".to_string()));
     assert_eq!(fno.currency_display, FluentNumberCurrencyDisplayStyle::Code);
-    assert!(!fno.use_grouping);
+    assert_eq!(fno.use_grouping, FluentNumberUseGrouping::False);
 
     let num = FluentNumber::new(0.2, FluentNumberOptions::default());
     assert_eq!(num.as_string_basic(), "0.2");