date: don't pad locale month/weekday names with trailing spaces

The ls-specific column alignment padding (from abmon-align) was leaking
into date output. Add a `pad` parameter to `localize_format_string` so
ls gets padded names and date gets raw names.

Author: sylvestre

src/uu/date/src/date.rs

@@ -22,7 +22,7 @@ use uucore::display::Quotable;
 use uucore::error::FromIo;
 use uucore::error::{UResult, USimpleError};
 #[cfg(feature = "i18n-datetime")]
-use uucore::i18n::datetime::{localize_format_string, should_use_icu_locale};
+use uucore::i18n::datetime::{NamePadding, localize_format_string, should_use_icu_locale};
 use uucore::translate;
 use uucore::{format_usage, show};
 #[cfg(windows)]
@@ -727,7 +727,7 @@ fn format_date_with_locale_aware_months(
     let result = if !should_use_icu_locale() || skip_localization {
         broken_down.to_string_with_config(config, format_string)
     } else {
-        let fmt = localize_format_string(format_string, date.date());
+        let fmt = localize_format_string(format_string, date.date(), NamePadding::Raw);
         broken_down.to_string_with_config(config, &fmt)
     };
     #[cfg(not(feature = "i18n-datetime"))]

src/uucore/src/lib/features/i18n/datetime.rs

@@ -17,6 +17,7 @@ use jiff_icu::ConvertFrom;
 use std::sync::OnceLock;
 
 use crate::i18n::get_locale_from_env;
+pub use crate::time::NamePadding;
 
 /// Get the locale for time/date formatting from LC_TIME environment variable
 pub fn get_time_locale() -> &'static (Locale, super::UEncoding) {
@@ -104,15 +105,26 @@ fn pad_names<const N: usize>(names: [String; N]) -> [String; N] {
 /// Cached locale name arrays, computed once per process. Each variant is
 /// `None` when the ICU formatter for that field width cannot be created
 /// (should only happen for truly broken locale data).
+///
+/// Both raw and padded variants are stored: `date` needs raw names (no
+/// trailing spaces) while `ls` needs padded names for column alignment.
 struct CachedLocaleNames {
-    /// `%B` — full month names, padded to uniform display width
+    /// `%B` — full month names, raw
     month_long: Option<[String; 12]>,
-    /// `%b` / `%h` — abbreviated month names (trailing dots stripped), padded
+    /// `%B` — full month names, padded to uniform display width
+    month_long_padded: Option<[String; 12]>,
+    /// `%b` / `%h` — abbreviated month names (trailing dots stripped), raw
     month_abbrev: Option<[String; 12]>,
-    /// `%A` — full weekday names, padded
+    /// `%b` / `%h` — abbreviated month names, padded
+    month_abbrev_padded: Option<[String; 12]>,
+    /// `%A` — full weekday names, raw
     weekday_long: Option<[String; 7]>,
-    /// `%a` — abbreviated weekday names, padded
+    /// `%A` — full weekday names, padded
+    weekday_long_padded: Option<[String; 7]>,
+    /// `%a` — abbreviated weekday names, raw
     weekday_short: Option<[String; 7]>,
+    /// `%a` — abbreviated weekday names, padded
+    weekday_short_padded: Option<[String; 7]>,
 }
 
 /// Return the cached, pre-padded locale names (computed once per process).
@@ -141,40 +153,50 @@ fn get_cached_locale_names() -> &'static CachedLocaleNames {
 
         let month_long = DateTimeFormatter::try_new(locale_prefs, fieldsets::M::long())
             .ok()
-            .map(|f| pad_names(month_dates.each_ref().map(|d| f.format(d).to_string())));
+            .map(|f| month_dates.each_ref().map(|d| f.format(d).to_string()));
+        let month_long_padded = month_long.clone().map(pad_names);
 
         // ICU's medium format may include trailing periods (e.g., "febr."
         // for Hungarian). The standard C/POSIX locale via nl_langinfo
         // returns abbreviations WITHOUT trailing periods, so we strip them.
         let month_abbrev = DateTimeFormatter::try_new(locale_prefs, fieldsets::M::medium())
             .ok()
             .map(|f| {
-                pad_names(
-                    month_dates
-                        .each_ref()
-                        .map(|d| f.format(d).to_string().trim_end_matches('.').to_string()),
-                )
+                month_dates
+                    .each_ref()
+                    .map(|d| f.format(d).to_string().trim_end_matches('.').to_string())
             });
+        let month_abbrev_padded = month_abbrev.clone().map(pad_names);
 
         let weekday_long = DateTimeFormatter::try_new(locale_prefs, fieldsets::E::long())
             .ok()
-            .map(|f| pad_names(weekday_dates.each_ref().map(|d| f.format(d).to_string())));
+            .map(|f| weekday_dates.each_ref().map(|d| f.format(d).to_string()));
+        let weekday_long_padded = weekday_long.clone().map(pad_names);
 
         let weekday_short = DateTimeFormatter::try_new(locale_prefs, fieldsets::E::short())
             .ok()
-            .map(|f| pad_names(weekday_dates.each_ref().map(|d| f.format(d).to_string())));
+            .map(|f| weekday_dates.each_ref().map(|d| f.format(d).to_string()));
+        let weekday_short_padded = weekday_short.clone().map(pad_names);
 
         CachedLocaleNames {
             month_long,
+            month_long_padded,
             month_abbrev,
+            month_abbrev_padded,
             weekday_long,
+            weekday_long_padded,
             weekday_short,
+            weekday_short_padded,
         }
     })
 }
 
-/// Transform a strftime format string to use locale-specific calendar values
-pub fn localize_format_string(format: &str, date: JiffDate) -> String {
+/// Transform a strftime format string to use locale-specific calendar values.
+///
+/// When `padding` is [`NamePadding::Padded`], month and weekday names are
+/// padded to uniform display width (for columnar output like `ls`). When
+/// [`NamePadding::Raw`], raw names are used (for `date` and similar utilities).
+pub fn localize_format_string(format: &str, date: JiffDate, padding: NamePadding) -> String {
     const PERCENT_PLACEHOLDER: &str = "\x00\x00";
 
     let (locale, _) = get_time_locale();
@@ -219,30 +241,51 @@ pub fn localize_format_string(format: &str, date: JiffDate) -> String {
             .replace("%e", &format!("{cal_day:2}"));
     }
 
-    // Look up the pre-padded locale name from the once-per-process cache.
+    // Look up locale names from the once-per-process cache.
+    let pad = matches!(padding, NamePadding::Padded);
     let cached = get_cached_locale_names();
     let month_idx = date.month() as usize - 1;
     let weekday_idx = date.weekday().to_monday_zero_offset() as usize;
 
     if fmt.contains("%B") {
-        if let Some(names) = &cached.month_long {
+        let src = if pad {
+            &cached.month_long_padded
+        } else {
+            &cached.month_long
+        };
+        if let Some(names) = src {
             fmt = fmt.replace("%B", &names[month_idx]);
         }
     }
     if fmt.contains("%b") || fmt.contains("%h") {
-        if let Some(names) = &cached.month_abbrev {
+        let src = if pad {
+            &cached.month_abbrev_padded
+        } else {
+            &cached.month_abbrev
+        };
+        if let Some(names) = src {
             fmt = fmt
                 .replace("%b", &names[month_idx])
                 .replace("%h", &names[month_idx]);
         }
     }
     if fmt.contains("%A") {
-        if let Some(names) = &cached.weekday_long {
+        let src = if pad {
+            &cached.weekday_long_padded
+        } else {
+            &cached.weekday_long
+        };
+        if let Some(names) = src {
             fmt = fmt.replace("%A", &names[weekday_idx]);
         }
     }
     if fmt.contains("%a") {
-        if let Some(names) = &cached.weekday_short {
+        let src = if pad {
+            &cached.weekday_short_padded
+        } else {
+            &cached.weekday_short
+        };
+        if let Some(names) = src {
             fmt = fmt.replace("%a", &names[weekday_idx]);
         }
     }

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

@@ -128,7 +128,7 @@ pub fn format_system_time_locale_aware<W: Write>(
         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());
+                let localized = localize_format_string(fmt, zoned.date(), padding);
                 return format_zoned(out, zoned, &localized);
             }
             // Out-of-range: fall through to the plain fallback below.

tests/by-util/test_date.rs

@@ -2198,6 +2198,67 @@ fn test_date_thai_locale_solar_calendar() {
     assert!(rfc_output.starts_with(&current_year.to_string()));
 }
 
+/// Regression test: `date +%B` / `+%b` / `+%A` / `+%a` must not have trailing
+/// padding spaces. The ls-specific column alignment padding must not leak into
+/// date output.
+#[cfg(unix)]
+#[test]
+fn test_date_month_weekday_names_no_trailing_spaces() {
+    let current_year: i32 = new_ucmd!()
+        .env("LC_ALL", "C")
+        .arg("+%Y")
+        .succeeds()
+        .stdout_str()
+        .trim()
+        .parse()
+        .unwrap();
+
+    for locale in ["fr_FR.UTF-8", "th_TH.UTF-8", "fi_FI.UTF-8"] {
+        if !is_locale_available(locale) {
+            continue;
+        }
+        // Check month names (%B, %b) for all 12 months
+        for month in 1..=12 {
+            for fmt in ["+%B", "+%b"] {
+                let output = new_ucmd!()
+                    .env("LC_ALL", locale)
+                    .arg("--date")
+                    .arg(format!("{current_year}-{month:02}-01"))
+                    .arg(fmt)
+                    .succeeds()
+                    .stdout_str()
+                    .to_string();
+                let name = output.trim_end_matches('\n');
+                assert_eq!(
+                    name,
+                    name.trim_end(),
+                    "[{locale}] {fmt} month {month:02} has trailing spaces: {name:?}"
+                );
+            }
+        }
+        // Check weekday names (%A, %a) for 7 consecutive days (Apr 6–12)
+        for day_offset in 0..7 {
+            let day = 6 + day_offset;
+            for fmt in ["+%A", "+%a"] {
+                let output = new_ucmd!()
+                    .env("LC_ALL", locale)
+                    .arg("--date")
+                    .arg(format!("{current_year}-04-{day:02}"))
+                    .arg(fmt)
+                    .succeeds()
+                    .stdout_str()
+                    .to_string();
+                let name = output.trim_end_matches('\n');
+                assert_eq!(
+                    name,
+                    name.trim_end(),
+                    "[{locale}] {fmt} day offset {day_offset} has trailing spaces: {name:?}"
+                );
+            }
+        }
+    }
+}
+
 #[cfg(unix)]
 fn check_date(locale: &str, date: &str, fmt: &str, expected: &str) {
     let actual = new_ucmd!()