date: width prefix in %N format specifier fix

src/uu/date/src/format_modifiers.rs

@@ -75,9 +75,10 @@ struct ParsedSpec<'a> {
     /// Flag characters from `[_0^#+-]`.
     flags: &'a str,
     /// Explicit width, if present. `None` means no width was specified.
-    /// A value that overflows `usize` is represented as `Some(usize::MAX)` so
+    /// Negative widths are used when `-` flag precedes the width.
+    /// A value that overflows `isize` is represented as `Some(isize::MAX)` so
     /// the downstream allocation check surfaces it as `FieldWidthTooLarge`.
-    width: Option<usize>,
+    width: Option<isize>,
     /// The specifier itself, including any leading colons (e.g. `Y`, `:z`, `::z`).
     spec: &'a str,
     /// Total byte length of the parsed sequence including the leading `%`.
@@ -104,13 +105,18 @@ fn parse_format_spec(s: &str) -> Option<ParsedSpec<'_>> {
     }
     let flags = &s[flags_start..pos];
 
+    // Check if '-' flag is present
+    let has_minus_flag = flags.contains('-');
+
     // Width: zero or more ASCII digits.
     let width_start = pos;
     while pos < bytes.len() && bytes[pos].is_ascii_digit() {
         pos += 1;
     }
     let width = if pos > width_start {
-        Some(s[width_start..pos].parse::<usize>().unwrap_or(usize::MAX))
+        let parsed: isize = s[width_start..pos].parse::<isize>().unwrap_or(isize::MAX);
+        // Make width negative if '-' flag is present
+        Some(if has_minus_flag { -parsed } else { parsed })
     } else {
         None
     };
@@ -343,6 +349,11 @@ fn apply_modifiers(value: &str, parsed: &ParsedSpec<'_>) -> Result<String, Forma
     let specifier = parsed.spec;
     let mut result = value.to_string();
 
+    // Ensure nanoseconds are always zero-padded to 9 digits from the start
+    // if result.len() < 9 {
+    //     result = format!("{:0>9}", result);
+    // }
+
     // Determine default pad character based on specifier type
     // Determine default pad character based on specifier type.
     // Text specifiers (month names, etc.) and numeric specifiers like %e, %k, %l
@@ -411,14 +422,24 @@ fn apply_modifiers(value: &str, parsed: &ParsedSpec<'_>) -> Result<String, Forma
 
     // If no_pad flag is active, suppress all padding and return
     if no_pad {
+            if let Some(w) = width {
+                let abs_w = w.abs() as usize;
+                let end = abs_w.min(result.len());
+                let truncated = &result[..end];
+                // Return truncated nanoseconds without trimming trailing zeros (GNU behavior)
+                return Ok(truncated.to_string());
+            }
         return Ok(strip_default_padding(&result));
     }
 
     // Handle padding flag without explicit width: use default width.
     // This applies when _ or 0 flag overrides the default padding character
     // and no explicit width is specified (e.g., %_m, %0e).
     let effective_width = match width {
-        Some(w) => w,
+        Some(w) => {
+            let abs_w = w.abs() as usize;
+            abs_w
+        }
         None if underscore_flag || pad_char != default_pad => get_default_width(specifier),
         None => 0,
     };
@@ -525,7 +546,7 @@ mod tests {
 
     /// Build a `ParsedSpec` for unit-testing `apply_modifiers` without a real
     /// format string.  `len` is set to 0 because these tests never use it.
-    fn spec<'a>(flags: &'a str, width: Option<usize>, spec: &'a str) -> ParsedSpec<'a> {
+    fn spec<'a>(flags: &'a str, width: Option<isize>, spec: &'a str) -> ParsedSpec<'a> {
         ParsedSpec {
             flags,
             width,
@@ -844,11 +865,11 @@ mod tests {
 
     #[test]
     fn test_apply_modifiers_width_too_large() {
-        let err = apply_modifiers("x", &spec("", Some(usize::MAX), "c")).unwrap_err();
+        let err = apply_modifiers("x", &spec("", Some(isize::MAX), "c")).unwrap_err();
         assert!(matches!(
             err,
             FormatError::FieldWidthTooLarge { width, specifier }
-            if width == usize::MAX && specifier == "c"
+            if width == isize::MAX && specifier == "c"
         ));
     }
 
@@ -865,7 +886,7 @@ mod tests {
         assert!(matches!(
             err,
             FormatError::FieldWidthTooLarge { width, specifier }
-            if width == usize::MAX && specifier == "Y"
+            if width == isize::MAX && specifier == "Y"
         ));
     }
 
@@ -939,7 +960,7 @@ mod tests {
     #[test]
     fn test_parse_format_spec() {
         // (input, expected: Some((flags, width, spec, len)) or None)
-        type ParsedTuple = (&'static str, Option<usize>, &'static str, usize);
+        type ParsedTuple = (&'static str, Option<isize>, &'static str, usize);
         let cases: &[(&str, Option<ParsedTuple>)] = &[
             // ---- plain single-letter specifiers ----
             ("%Y", Some(("", None, "Y", 2))),
@@ -988,6 +1009,7 @@ mod tests {
 
         for (input, expected) in cases {
             let actual = parse_format_spec(input).map(|p| (p.flags, p.width, p.spec, p.len));
+
             assert_eq!(actual, *expected, "input = {input:?}");
         }
     }