uucore/human: cache locale and use ICU for thousands separator (#9090)

Author: naoNao89

src/uucore/src/lib/features/format/human.rs

@@ -9,8 +9,16 @@
 //!
 //! Format sizes like gnulibs human_readable() would
 
+use std::sync::OnceLock;
 use unit_prefix::NumberPrefix;
 
+#[cfg(feature = "i18n-decimal")]
+use icu_decimal::provider::DecimalSymbolsV1;
+#[cfg(feature = "i18n-decimal")]
+use icu_locale::Locale;
+#[cfg(feature = "i18n-decimal")]
+use icu_provider::prelude::*;
+
 #[derive(Copy, Clone, PartialEq)]
 pub enum SizeFormat {
     Bytes,
@@ -59,36 +67,80 @@ pub fn human_readable(size: u64, sfmt: SizeFormat) -> String {
 /// - `'\0'` for C/POSIX locale (no separator)
 /// - `'.'` for European locales (de_DE, fr_FR, it_IT, es_ES, etc.)
 /// - `','` for other locales (default, en_US style)
+/// Get the thousands/grouping separator for the given locale using ICU
+#[cfg(feature = "i18n-decimal")]
+fn get_grouping_separator_from_icu(loc: Locale) -> char {
+    let data_locale = DataLocale::from(loc);
+
+    let request = DataRequest {
+        id: DataIdentifierBorrowed::for_locale(&data_locale),
+        metadata: DataRequestMetadata::default(),
+    };
+
+    let response: DataResponse<DecimalSymbolsV1> =
+        icu_decimal::provider::Baked.load(request).unwrap();
+
+    let symbols = response.payload.get();
+    let grouping_str = symbols.grouping_separator();
+    
+    // Convert the grouping separator string to a char
+    // ICU returns a string, but we need a char. Take the first char or default to comma.
+    grouping_str.chars().next().unwrap_or(',')
+}
+
+/// Get the cached thousands separator based on the current locale
 fn get_thousands_separator() -> char {
-    // Try to read LC_NUMERIC or LANG environment variable
-    if let Ok(locale) = std::env::var("LC_NUMERIC")
-        .or_else(|_| std::env::var("LC_ALL"))
-        .or_else(|_| std::env::var("LANG"))
-    {
-        // C and POSIX locales have no thousands separator
-        if locale == "C" || locale == "POSIX" || locale.starts_with("C.") {
-            return '\0';
-        }
+    static THOUSANDS_SEP: OnceLock<char> = OnceLock::new();
 
-        // Simple heuristic: European locales use period, others use comma
-        // This covers common cases like de_DE, fr_FR, it_IT, es_ES, nl_NL, etc.
-        if locale.starts_with("de_")
-            || locale.starts_with("fr_")
-            || locale.starts_with("it_")
-            || locale.starts_with("es_")
-            || locale.starts_with("nl_")
-            || locale.starts_with("pt_")
-            || locale.starts_with("da_")
-            || locale.starts_with("sv_")
-            || locale.starts_with("no_")
-            || locale.starts_with("fi_")
+    *THOUSANDS_SEP.get_or_init(|| {
+        #[cfg(feature = "i18n-decimal")]
         {
-            return '.';
+            use crate::i18n::get_numeric_locale;
+            let (locale, _encoding) = get_numeric_locale();
+            
+            // C and POSIX locales have no thousands separator
+            // The default locale from i18n is en-US-posix for C/POSIX
+            if locale.to_string().contains("posix") {
+                return '\0';
+            }
+            
+            get_grouping_separator_from_icu(locale.clone())
         }
-    }
+        
+        #[cfg(not(feature = "i18n-decimal"))]
+        {
+            // Fallback implementation when i18n-decimal feature is disabled
+            // Try to read LC_NUMERIC or LANG environment variable
+            if let Ok(locale) = std::env::var("LC_NUMERIC")
+                .or_else(|_| std::env::var("LC_ALL"))
+                .or_else(|_| std::env::var("LANG"))
+            {
+                // C and POSIX locales have no thousands separator
+                if locale == "C" || locale == "POSIX" || locale.starts_with("C.") {
+                    return '\0';
+                }
+
+                // Simple heuristic: European locales use period, others use comma
+                // This covers common cases like de_DE, fr_FR, it_IT, es_ES, nl_NL, etc.
+                if locale.starts_with("de_")
+                    || locale.starts_with("fr_")
+                    || locale.starts_with("it_")
+                    || locale.starts_with("es_")
+                    || locale.starts_with("nl_")
+                    || locale.starts_with("pt_")
+                    || locale.starts_with("da_")
+                    || locale.starts_with("sv_")
+                    || locale.starts_with("no_")
+                    || locale.starts_with("fi_")
+                {
+                    return '.';
+                }
+            }
 
-    // Default to comma (en_US style)
-    ','
+            // Default to comma (en_US style)
+            ','
+        }
+    })
 }
 
 /// Format a number with thousands separators based on LC_NUMERIC locale.