feat(currency): Add accounting formatting and relax constructor validation (#8177)

Author: younies

components/experimental/src/dimension/currency/compact_formatter.rs

@@ -22,7 +22,6 @@ use super::{
     CurrencyCode,
     options::{CurrencyFormatterOptions, CurrencyUsage},
 };
-use icu_pattern::DoublePlaceholderPattern;
 
 extern crate alloc;
 
@@ -116,10 +115,6 @@ impl CompactCurrencyFormatter {
             })?
             .payload;
 
-        if essential.get().standard_pattern().is_none() {
-            return Err(DataError::custom("missing standard pattern"));
-        }
-
         let decimal_formatter = DecimalFormatter::try_new((&prefs).into(), Default::default())?;
 
         let compact_data = DataProvider::<icu_decimal::provider::DecimalCompactShortV1>::load(
@@ -202,10 +197,6 @@ impl CompactCurrencyFormatter {
             })?
             .payload;
 
-        if essential.get().standard_pattern().is_none() {
-            return Err(DataError::custom("missing standard pattern"));
-        }
-
         let fractions = provider.load(Default::default())?.payload;
 
         Ok(Self {
@@ -243,18 +234,18 @@ impl CompactCurrencyFormatter {
         let (currency_placeholder, pos_pattern, neg_pattern, pattern_selection) = self
             .essential
             .get()
-            .name_and_pattern(self.options.width, currency_code);
+            .name_and_pattern(self.options.width, self.options.usage, currency_code);
 
         let mut sign = value.sign;
         let pattern = if sign == Sign::Negative {
             if let Some(neg_pattern) = neg_pattern {
                 sign = Sign::None;
                 neg_pattern
             } else {
-                pos_pattern.unwrap_or_else(|| <&DoublePlaceholderPattern>::default())
+                pos_pattern
             }
         } else {
-            pos_pattern.unwrap_or_else(|| <&DoublePlaceholderPattern>::default())
+            pos_pattern
         };
 
         let fraction_info = self.resolve_fraction_info(

components/experimental/src/dimension/currency/format.rs

@@ -396,4 +396,42 @@ mod tests {
             "-$12K"
         );
     }
+
+    #[test]
+    pub fn test_accounting_formatting() {
+        let prefs: CurrencyFormatterPreferences = locale!("en").into();
+        let currency_code = CurrencyCode(tinystr!(3, "USD"));
+        let value = "-12345.67".parse().unwrap();
+
+        let fmt_accounting = CurrencyFormatter::<Decimal>::try_new_short(
+            prefs,
+            CurrencyFormatterOptions {
+                usage: CurrencyUsage::Accounting,
+                ..Default::default()
+            },
+            &currency_code,
+        )
+        .unwrap();
+        assert_writeable_eq!(fmt_accounting.format_fixed_decimal(&value), "($12,345.67)");
+    }
+
+    #[test]
+    pub fn test_compact_accounting_formatting() {
+        let prefs: CompactCurrencyFormatterPreferences = locale!("en").into();
+        let currency_code = CurrencyCode(tinystr!(3, "USD"));
+        let value = "-12345.67".parse().unwrap();
+
+        let fmt_accounting = CompactCurrencyFormatter::try_new(
+            prefs,
+            CurrencyFormatterOptions {
+                usage: CurrencyUsage::Accounting,
+                ..Default::default()
+            },
+        )
+        .unwrap();
+        assert_writeable_eq!(
+            fmt_accounting.format_fixed_decimal(&value, &currency_code),
+            "($12K)"
+        );
+    }
 }

components/experimental/src/dimension/currency/formatter.rs

@@ -23,7 +23,6 @@ use super::super::provider::currency::{
 use super::CurrencyCode;
 use super::options::{CurrencyFormatterOptions, CurrencyUsage, Width};
 use fixed_decimal::{RoundingIncrement, Sign, SignedRoundingMode, UnsignedRoundingMode};
-use icu_pattern::DoublePlaceholderPattern;
 
 extern crate alloc;
 
@@ -146,10 +145,6 @@ impl CurrencyFormatter<Decimal> {
         let essential =
             load_with_fallback::<CurrencyEssentialsV1>(&crate::provider::Baked, ids)?.payload;
 
-        if essential.get().standard_pattern().is_none() {
-            return Err(DataError::custom("missing standard pattern"));
-        }
-
         let fractions = crate::provider::Baked.load(Default::default())?.payload;
 
         Ok(Self {
@@ -188,10 +183,6 @@ impl CurrencyFormatter<Decimal> {
         let essential =
             load_with_fallback::<CurrencyEssentialsV1>(&crate::provider::Baked, ids)?.payload;
 
-        if essential.get().standard_pattern().is_none() {
-            return Err(DataError::custom("missing standard pattern"));
-        }
-
         let fractions = crate::provider::Baked.load(Default::default())?.payload;
 
         Ok(Self {
@@ -238,10 +229,6 @@ impl CurrencyFormatter<Decimal> {
         let ids = req_id.into_iter().chain(core::iter::once(default_id));
         let essential = load_with_fallback::<CurrencyEssentialsV1>(provider, ids)?.payload;
 
-        if essential.get().standard_pattern().is_none() {
-            return Err(DataError::custom("missing standard pattern"));
-        }
-
         let fractions = provider.load(Default::default())?.payload;
 
         Ok(Self {
@@ -284,10 +271,6 @@ impl CurrencyFormatter<Decimal> {
         let ids = req_id.into_iter().chain(core::iter::once(default_id));
         let essential = load_with_fallback::<CurrencyEssentialsV1>(provider, ids)?.payload;
 
-        if essential.get().standard_pattern().is_none() {
-            return Err(DataError::custom("missing standard pattern"));
-        }
-
         let fractions = provider.load(Default::default())?.payload;
 
         Ok(Self {
@@ -481,18 +464,18 @@ impl CurrencyFormatter<Decimal> {
                 // an exact decimal/money representation.
                 let (currency_str, pos_pattern, neg_pattern, pattern_selection) = essential
                     .get()
-                    .name_and_pattern(*width, &self.bound_currency);
+                    .name_and_pattern(*width, self.options.usage, &self.bound_currency);
 
                 let mut sign = value.sign;
                 let pattern = if sign == Sign::Negative {
                     if let Some(neg_pattern) = neg_pattern {
                         sign = Sign::None;
                         neg_pattern
                     } else {
-                        pos_pattern.unwrap_or_else(|| <&DoublePlaceholderPattern>::default())
+                        pos_pattern
                     }
                 } else {
-                    pos_pattern.unwrap_or_else(|| <&DoublePlaceholderPattern>::default())
+                    pos_pattern
                 };
 
                 let fraction_info =

components/experimental/src/dimension/currency/options.rs

@@ -40,6 +40,8 @@ pub enum CurrencyUsage {
     Standard,
     /// Cash currency formatting (may use different rounding).
     Cash,
+    /// Accounting currency formatting (may use different patterns, e.g. parentheses for negative values).
+    Accounting,
 }
 
 #[derive(Default, Debug, Eq, PartialEq, Clone, Copy, Hash)]

components/experimental/src/dimension/provider/currency/essentials.rs

@@ -14,7 +14,7 @@ use zerovec::{VarZeroVec, ZeroMap, ZeroVec};
 use icu_pattern::DoublePlaceholderPattern;
 
 use crate::dimension::currency::CurrencyCode;
-use crate::dimension::currency::options::Width;
+use crate::dimension::currency::options::{CurrencyUsage, Width};
 
 #[cfg(feature = "compiled_data")]
 /// Baked data
@@ -144,17 +144,26 @@ pub struct CurrencyPatternConfig {
     pub narrow_placeholder_value: Option<PlaceholderValue>,
 }
 
+// Fallback pattern: "{0} {1}" (number followed by currency with space, e.g. "10 $")
+//
+// Even though the baked data handles the fallback at data generation time,
+// we have the fallback here for users feeding their own data without
+// handling the fallback logic in their data generation.
+const FALLBACK_PATTERN: &DoublePlaceholderPattern =
+    DoublePlaceholderPattern::from_ref_store_unchecked("\x02\x05 ");
+
 impl<'a> CurrencyEssentials<'a> {
     /// Returns the formatted currency name/symbol,
     /// the currency pattern for the given width and currency,
     /// and the pattern selection.
     pub(crate) fn name_and_pattern(
         &'a self,
         width: Width,
+        usage: CurrencyUsage,
         currency: &'a CurrencyCode,
     ) -> (
         &'a str,
-        Option<&'a DoublePlaceholderPattern>,
+        &'a DoublePlaceholderPattern,
         Option<&'a DoublePlaceholderPattern>,
         PatternSelection,
     ) {
@@ -181,16 +190,28 @@ impl<'a> CurrencyEssentials<'a> {
             Width::Long => unreachable!("CurrencyEssentials does not support Long width"),
         };
 
-        let pos_pattern = match pattern_selection {
-            PatternSelection::Standard => self.standard_pattern(),
-            PatternSelection::StandardAlphaNextToNumber => {
+        let pos_pattern = match (usage, pattern_selection) {
+            (CurrencyUsage::Accounting, PatternSelection::Standard) => {
+                self.accounting_positive_pattern()
+            }
+            (CurrencyUsage::Accounting, PatternSelection::StandardAlphaNextToNumber) => {
+                self.accounting_alpha_next_to_number_positive_pattern()
+            }
+            (_, PatternSelection::Standard) => self.standard_pattern(),
+            (_, PatternSelection::StandardAlphaNextToNumber) => {
                 self.standard_alpha_next_to_number_pattern()
             }
         };
 
-        let neg_pattern = match pattern_selection {
-            PatternSelection::Standard => self.standard_negative_pattern(),
-            PatternSelection::StandardAlphaNextToNumber => {
+        let neg_pattern = match (usage, pattern_selection) {
+            (CurrencyUsage::Accounting, PatternSelection::Standard) => {
+                self.accounting_negative_pattern()
+            }
+            (CurrencyUsage::Accounting, PatternSelection::StandardAlphaNextToNumber) => {
+                self.accounting_alpha_next_to_number_negative_pattern()
+            }
+            (_, PatternSelection::Standard) => self.standard_negative_pattern(),
+            (_, PatternSelection::StandardAlphaNextToNumber) => {
                 self.standard_alpha_next_to_number_negative_pattern()
             }
         };
@@ -199,10 +220,23 @@ impl<'a> CurrencyEssentials<'a> {
     }
 
     /// Returns the standard pattern.
-    pub fn standard_pattern(&self) -> Option<&DoublePlaceholderPattern> {
+    ///
+    /// If the standard pattern is missing (which should only happen in corrupt
+    /// or incomplete custom data), this returns a default safety pattern `"{1}{0}"`.
+    /// Note that this is a safety default, not a CLDR-defined fallback.
+    pub fn standard_pattern(&self) -> &DoublePlaceholderPattern {
         self.patterns
             .get(self.indices.standard as usize)
-            .or_else(|| self.patterns.get(0))
+            .unwrap_or_else(|| {
+                debug_assert!(
+                    false,
+                    "Standard pattern index {} is out of bounds for patterns of length {}",
+                    self.indices.standard,
+                    self.patterns.len()
+                );
+                // GIGO
+                FALLBACK_PATTERN
+            })
     }
 
     /// Returns the standard negative pattern if specified.
@@ -212,14 +246,24 @@ impl<'a> CurrencyEssentials<'a> {
             .and_then(|idx| self.patterns.get(idx as usize))
     }
 
-    /// Returns the `standard_alpha_next_to_number` pattern, falling back to `standard_pattern` if not present.
-    pub fn standard_alpha_next_to_number_pattern(&self) -> Option<&DoublePlaceholderPattern> {
+    /// Returns the `standard_alpha_next_to_number` pattern.
+    ///
+    /// Fallback hierarchy:
+    /// `standard_alpha_next_to_number` -> `standard`
+    ///
+    /// Even though the baked data handles the fallback at data generation time,
+    /// we have the fallback here for users feeding their own data without
+    /// handling the fallback logic in their data generation.
+    pub fn standard_alpha_next_to_number_pattern(&self) -> &DoublePlaceholderPattern {
         self.patterns
             .get(self.indices.standard_alpha_next_to_number as usize)
-            .or_else(|| self.standard_pattern())
+            .unwrap_or_else(|| self.standard_pattern())
     }
 
     /// Returns the `standard_alpha_next_to_number` negative pattern if specified, falling back to standard negative.
+    ///
+    /// Fallback hierarchy:
+    /// `standard_alpha_next_to_number_negative` -> `standard_negative`
     pub fn standard_alpha_next_to_number_negative_pattern(
         &self,
     ) -> Option<&DoublePlaceholderPattern> {
@@ -229,30 +273,49 @@ impl<'a> CurrencyEssentials<'a> {
             .or_else(|| self.standard_negative_pattern())
     }
 
-    /// Returns the positive accounting pattern, falling back to `standard_pattern` if not present.
-    pub fn accounting_positive_pattern(&self) -> Option<&DoublePlaceholderPattern> {
+    /// Returns the positive accounting pattern.
+    ///
+    /// Fallback hierarchy:
+    /// `accounting_positive` -> `standard`
+    ///
+    /// Even though the baked data handles the fallback at data generation time,
+    /// we have the fallback here for users feeding their own data without
+    /// handling the fallback logic in their data generation.
+    pub fn accounting_positive_pattern(&self) -> &DoublePlaceholderPattern {
         self.patterns
             .get(self.indices.accounting_positive as usize)
-            .or_else(|| self.standard_pattern())
+            .unwrap_or_else(|| self.standard_pattern())
     }
 
-    /// Returns the negative accounting pattern if present.
+    /// Returns the negative accounting pattern if present, falling back to standard negative.
+    ///
+    /// Fallback hierarchy:
+    /// `accounting_negative` -> `standard_negative`
     pub fn accounting_negative_pattern(&self) -> Option<&DoublePlaceholderPattern> {
         self.indices
             .accounting_negative
             .and_then(|idx| self.patterns.get(idx as usize))
+            .or_else(|| self.standard_negative_pattern())
     }
 
-    /// Returns the positive `accounting_alpha_next_to_number` pattern, falling back to accounting or standard.
-    pub fn accounting_alpha_next_to_number_positive_pattern(
-        &self,
-    ) -> Option<&DoublePlaceholderPattern> {
+    /// Returns the positive `accounting_alpha_next_to_number` pattern.
+    ///
+    /// Fallback hierarchy:
+    /// `accounting_alpha_next_to_number_positive` -> `standard_alpha_next_to_number` -> `standard`
+    ///
+    /// Even though the baked data handles the fallback at data generation time,
+    /// we have the fallback here for users feeding their own data without
+    /// handling the fallback logic in their data generation.
+    pub fn accounting_alpha_next_to_number_positive_pattern(&self) -> &DoublePlaceholderPattern {
         self.patterns
             .get(self.indices.accounting_alpha_next_to_number_positive as usize)
-            .or_else(|| self.accounting_positive_pattern())
+            .unwrap_or_else(|| self.standard_alpha_next_to_number_pattern())
     }
 
     /// Returns the negative `accounting_alpha_next_to_number` pattern, falling back to `accounting_negative_pattern`.
+    ///
+    /// Fallback hierarchy:
+    /// `accounting_alpha_next_to_number_negative` -> `accounting_negative` -> `standard_negative`
     pub fn accounting_alpha_next_to_number_negative_pattern(
         &self,
     ) -> Option<&DoublePlaceholderPattern> {
@@ -262,3 +325,14 @@ impl<'a> CurrencyEssentials<'a> {
             .or_else(|| self.accounting_negative_pattern())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use writeable::assert_writeable_eq;
+
+    #[test]
+    fn test_fallback_pattern() {
+        assert_writeable_eq!(FALLBACK_PATTERN.interpolate(("10", "$")), "10 $");
+    }
+}