ls: honor LC_TIME for --time-style=locale via uucore helper

Add format_system_time_locale_aware in uucore::time that runs the
format string through i18n::datetime::localize_format_string when a
non-C LC_TIME locale is active, and route ls's display_date through
it. Fixes month names and alternate-calendar years (Persian,
Buddhist, Ethiopian) matching GNU. Also generalize uutests'
is_locale_available to derive the expected charmap from the locale
suffix so non-UTF-8 locales work, and consolidate the ls locale
tests into a single data-driven case.

Author: sylvestre

src/uu/ls/Cargo.toml

@@ -36,6 +36,7 @@ uucore = { workspace = true, features = [
   "fs",
   "fsext",
   "fsxattr",
+  "i18n-datetime",
   "parser-size",
   "parser-glob",
   "quoting-style",

src/uu/ls/src/display.rs

@@ -56,7 +56,7 @@ use uucore::{
     os_str_as_bytes_lossy,
     quoting_style::{QuotingStyle, locale_aware_escape_dir_name, locale_aware_escape_name},
     show,
-    time::{FormatSystemTimeFallback, format_system_time},
+    time::{FormatSystemTimeFallback, format_system_time_locale_aware},
 };
 
 use crate::colors::{StyleManager, color_name};
@@ -620,7 +620,7 @@ fn display_date(
         _ => &config.time_format_recent,
     };
 
-    format_system_time(out, time, fmt, FormatSystemTimeFallback::Integer)
+    format_system_time_locale_aware(out, time, fmt, FormatSystemTimeFallback::Integer)
 }
 
 fn display_len_or_rdev(metadata: &Metadata, config: &Config) -> SizeOrDeviceId {

src/uucore/src/lib/features/time.rs

@@ -49,41 +49,78 @@ pub enum FormatSystemTimeFallback {
     Float,        // Just print seconds+nanoseconds since epoch (`stat`)
 }
 
+/// Write the seconds-since-epoch fallback used when a `SystemTime` is out of
+/// the range representable by `jiff::Zoned`.
+fn write_fallback_seconds<W: Write>(
+    out: &mut W,
+    time: SystemTime,
+    mode: FormatSystemTimeFallback,
+) -> UResult<()> {
+    // TODO: The range allowed by jiff is different from what GNU accepts,
+    // but it still far enough in the future/past to be unlikely to matter:
+    //  jiff: Year between -9999 to 9999 (UTC) [-377705023201..=253402207200]
+    //  GNU: Year fits in signed 32 bits (timezone dependent)
+    let (mut secs, mut nsecs) = system_time_to_sec(time);
+    match mode {
+        FormatSystemTimeFallback::Integer => out.write_all(secs.to_string().as_bytes())?,
+        FormatSystemTimeFallback::IntegerError => {
+            let str = secs.to_string();
+            show_error!("time '{str}' is out of range");
+            out.write_all(str.as_bytes())?;
+        }
+        FormatSystemTimeFallback::Float => {
+            if secs < 0 && nsecs != 0 {
+                secs -= 1;
+                nsecs = 1_000_000_000 - nsecs;
+            }
+            out.write_fmt(format_args!("{secs}.{nsecs:09}"))?;
+        }
+    }
+    Ok(())
+}
+
 /// Format a `SystemTime` according to given fmt, and append to vector out.
 pub fn format_system_time<W: Write>(
     out: &mut W,
     time: SystemTime,
     fmt: &str,
     mode: FormatSystemTimeFallback,
 ) -> UResult<()> {
-    let zoned: Result<Zoned, _> = time.try_into();
-    if let Ok(zoned) = zoned {
-        format_zoned(out, zoned, fmt)
-    } else {
+    match time.try_into() {
+        Ok(zoned) => format_zoned(out, zoned, fmt),
         // Assume that if we cannot build a Zoned element, the timestamp is
         // out of reasonable range, just print it then.
-        // TODO: The range allowed by jiff is different from what GNU accepts,
-        // but it still far enough in the future/past to be unlikely to matter:
-        //  jiff: Year between -9999 to 9999 (UTC) [-377705023201..=253402207200]
-        //  GNU: Year fits in signed 32 bits (timezone dependent)
-        let (mut secs, mut nsecs) = system_time_to_sec(time);
-        match mode {
-            FormatSystemTimeFallback::Integer => out.write_all(secs.to_string().as_bytes())?,
-            FormatSystemTimeFallback::IntegerError => {
-                let str = secs.to_string();
-                show_error!("time '{str}' is out of range");
-                out.write_all(str.as_bytes())?;
-            }
-            FormatSystemTimeFallback::Float => {
-                if secs < 0 && nsecs != 0 {
-                    secs -= 1;
-                    nsecs = 1_000_000_000 - nsecs;
-                }
-                out.write_fmt(format_args!("{secs}.{nsecs:09}"))?;
+        Err(_) => write_fallback_seconds(out, time, mode),
+    }
+}
+
+/// Like [`format_system_time`], but when built with the `i18n-datetime`
+/// feature and a non-C `LC_TIME` locale is active, rewrites locale-dependent
+/// strftime directives (`%b`, `%B`, `%a`, `%A`, and `%Y`/`%m`/`%d`/`%e` for
+/// non-Gregorian calendars) to their localized values before formatting.
+/// For Gregorian locales, `%Y`/`%m`/`%d`/`%e` are unaffected (e.g. `en_US`
+/// still renders 2025 as `2025`).
+///
+/// With the feature disabled or a C/POSIX locale, this is identical to
+/// `format_system_time`.
+pub fn format_system_time_locale_aware<W: Write>(
+    out: &mut W,
+    time: SystemTime,
+    fmt: &str,
+    mode: FormatSystemTimeFallback,
+) -> UResult<()> {
+    #[cfg(feature = "i18n-datetime")]
+    {
+        use crate::i18n::datetime::{localize_format_string, should_use_icu_locale};
+        if should_use_icu_locale() {
+            if let Ok(zoned) = <SystemTime as TryInto<Zoned>>::try_into(time) {
+                let localized = localize_format_string(fmt, zoned.date());
+                return format_zoned(out, zoned, &localized);
             }
+            // Out-of-range: fall through to the plain fallback below.
         }
-        Ok(())
     }
+    format_system_time(out, time, fmt, mode)
 }
 
 #[cfg(test)]