date: fix handling of case-change flags in locale format specifiers

Author: CrazyRoka

src/uu/date/src/date.rs

@@ -395,12 +395,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
     };
 
     let format_string = make_format_string(&settings);
+    let format_string = locale::expand_locale_format(format_string);
 
     // Format all the dates
     for date in dates {
         match date {
             // TODO: Switch to lenient formatting.
-            Ok(date) => match strtime::format(format_string, &date) {
+            Ok(date) => match strtime::format(format_string.as_ref(), &date) {
                 Ok(s) => println!("{s}"),
                 Err(e) => {
                     return Err(USimpleError::new(

src/uu/date/src/locale.rs

@@ -53,19 +53,109 @@ cfg_langinfo! {
         })
     }
 
-    /// Retrieves the date/time format string from the system locale
-    fn get_locale_format_string() -> Option<String> {
+    /// Replaces %c, %x, %X with their locale-specific format strings.
+    ///
+    /// If a flag like `^` is present (e.g., `%^c`), it is distributed to the
+    /// sub-specifiers within the locale string.
+    pub fn expand_locale_format(format: &str) -> std::borrow::Cow<str> {
+        let mut result = String::with_capacity(format.len());
+        let mut chars = format.chars().peekable();
+        let mut modified = false;
+
+        while let Some(c) = chars.next() {
+            if c != '%' {
+                result.push(c);
+                continue;
+            }
+
+            // Capture flags
+            let mut flags = Vec::new();
+            while let Some(&peek) = chars.peek() {
+                 match peek {
+                    '_' | '-' | '0' | '^' | '#' => {
+                        flags.push(peek);
+                        chars.next();
+                    },
+                    _ => break,
+                 }
+            }
+
+            match chars.peek() {
+                Some(&spec @ ('c' | 'x' | 'X')) => {
+                    chars.next();
+
+                    let item = match spec {
+                        'c' => libc::D_T_FMT,
+                        'x' => libc::D_FMT,
+                        'X' => libc::T_FMT,
+                        _ => unreachable!(),
+                    };
+
+                    if let Some(s) = get_langinfo(item) {
+                        // If the user requested uppercase (%^c), distribute that flag
+                        // to the expanded specifiers.
+                        let replacement = if flags.contains(&'^') {
+                            distribute_flag(&s, '^')
+                        } else {
+                            s
+                        };
+                        result.push_str(&replacement);
+                        modified = true;
+                    } else {
+                        // Reconstruct original sequence if lookup fails
+                        result.push('%');
+                        result.extend(flags);
+                        result.push(spec);
+                    }
+                },
+                Some(_) | None => {
+                    // Not a locale specifier, or end of string.
+                    // Push captured flags and let loop handle the next char.
+                    result.push('%');
+                    result.extend(flags);
+                }
+            }
+        }
+
+        if modified {
+            std::borrow::Cow::Owned(result)
+        } else {
+            std::borrow::Cow::Borrowed(format)
+        }
+    }
+
+    fn distribute_flag(fmt: &str, flag: char) -> String {
+        let mut res = String::with_capacity(fmt.len() * 2);
+        let mut chars = fmt.chars().peekable();
+        while let Some(c) = chars.next() {
+            res.push(c);
+            if c == '%' {
+                if let Some(&n) = chars.peek() {
+                    if n == '%' {
+                         chars.next();
+                         res.push('%');
+                    } else {
+                        res.push(flag);
+                    }
+                }
+            }
+        }
+        res
+    }
+
+    /// Retrieves the date/time format string from the system locale (D_T_FMT, D_FMT, T_FMT)
+    pub fn get_langinfo(item: libc::nl_item) -> Option<String> {
         unsafe {
             // Set locale from environment variables
             libc::setlocale(libc::LC_TIME, c"".as_ptr());
 
             // Get the date/time format string
-            let d_t_fmt_ptr = libc::nl_langinfo(libc::D_T_FMT);
-            if d_t_fmt_ptr.is_null() {
+            let fmt_ptr = libc::nl_langinfo(item);
+            if fmt_ptr.is_null() {
                 return None;
             }
 
-            let format = CStr::from_ptr(d_t_fmt_ptr).to_str().ok()?;
+            let format = CStr::from_ptr(fmt_ptr).to_str().ok()?;
             if format.is_empty() {
                 return None;
             }
@@ -74,6 +164,11 @@ cfg_langinfo! {
         }
     }
 
+    /// Retrieves the date/time format string from the system locale
+    fn get_locale_format_string() -> Option<String> {
+        get_langinfo(libc::D_T_FMT)
+    }
+
     /// Ensures the format string includes timezone (%Z)
     fn ensure_timezone_in_format(format: &str) -> String {
         if format.contains("%Z") {
@@ -107,6 +202,18 @@ pub fn get_locale_default_format() -> &'static str {
     "%a %b %e %X %Z %Y"
 }
 
+#[cfg(not(any(
+    target_os = "linux",
+    target_vendor = "apple",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "dragonfly"
+)))]
+pub fn expand_locale_format(format: &str) -> std::borrow::Cow<str> {
+    std::borrow::Cow::Borrowed(format)
+}
+
 #[cfg(test)]
 mod tests {
     cfg_langinfo! {

tests/by-util/test_date.rs

@@ -1404,3 +1404,19 @@ fn test_date_locale_fr_french() {
         "Output should include timezone information, got: {stdout}"
     );
 }
+
+#[test]
+fn test_format_upper_c_locale_expansion() {
+    new_ucmd!()
+        .env("LC_ALL", "C")
+        .env("TZ", "UTC")
+        .arg("-d")
+        .arg("2024-01-01")
+        .arg("+%^c")
+        .succeeds()
+        .stdout_str_check(|out| {
+            // In C locale, %c expands to "%a %b %e %H:%M:%S %Y" (e.g., "Mon Jan  1 ...")
+            // With the ^ flag, we expect "MON JAN  1 ..."
+            out.contains("MON") && out.contains("JAN")
+        });
+}