uucore: time: Add options for format_system_time

Depending on the caller, we want the number of seconds, that
and an error printed out, or seconds+nanoseconds.

Author: drinkcat

src/uu/du/src/du.rs

@@ -27,6 +27,7 @@ use uucore::locale::{get_message, get_message_with_args};
 use uucore::parser::parse_glob;
 use uucore::parser::parse_size::{ParseSizeError, parse_size_u64};
 use uucore::parser::shortcut_value_parser::ShortcutValueParser;
+use uucore::time::{FormatSystemTimeFallback, format_system_time};
 use uucore::{format_usage, show, show_error, show_warning};
 #[cfg(windows)]
 use windows_sys::Win32::Foundation::HANDLE;
@@ -528,7 +529,12 @@ impl StatPrinter {
 
         if let Some(md_time) = &self.time {
             if let Some(time) = metadata_get_time(&stat.metadata, *md_time) {
-                uucore::time::format_system_time(&mut stdout(), time, &self.time_format, true)?;
+                format_system_time(
+                    &mut stdout(),
+                    time,
+                    &self.time_format,
+                    FormatSystemTimeFallback::IntegerError,
+                )?;
                 print!("\t");
             } else {
                 print!("???\t");

src/uu/ls/src/ls.rs

@@ -60,6 +60,7 @@ use uucore::libc::{dev_t, major, minor};
 use uucore::line_ending::LineEnding;
 use uucore::locale::{get_message, get_message_with_args};
 use uucore::quoting_style::{QuotingStyle, locale_aware_escape_dir_name, locale_aware_escape_name};
+use uucore::time::{FormatSystemTimeFallback, format_system_time};
 use uucore::{
     display::Quotable,
     error::{UError, UResult, set_exit_code},
@@ -2968,7 +2969,7 @@ fn display_date(
         _ => &config.time_format_recent,
     };
 
-    uucore::time::format_system_time(out, time, fmt, false)
+    format_system_time(out, time, fmt, FormatSystemTimeFallback::Integer)
 }
 
 #[allow(dead_code)]

src/uu/stat/src/stat.rs

@@ -28,7 +28,7 @@ use std::{env, fs};
 use std::collections::HashMap;
 use thiserror::Error;
 use uucore::locale::{get_message, get_message_with_args};
-use uucore::time::{format_system_time, system_time_to_sec};
+use uucore::time::{FormatSystemTimeFallback, format_system_time, system_time_to_sec};
 
 #[derive(Debug, Error)]
 enum StatError {
@@ -1288,7 +1288,14 @@ const PRETTY_DATETIME_FORMAT: &str = "%Y-%m-%d %H:%M:%S.%N %z";
 fn pretty_time(meta: &Metadata, md_time_field: MetadataTimeField) -> String {
     if let Some(time) = metadata_get_time(meta, md_time_field) {
         let mut tmp = Vec::new();
-        if format_system_time(&mut tmp, time, PRETTY_DATETIME_FORMAT, false).is_ok() {
+        if format_system_time(
+            &mut tmp,
+            time,
+            PRETTY_DATETIME_FORMAT,
+            FormatSystemTimeFallback::Float,
+        )
+        .is_ok()
+        {
             return String::from_utf8(tmp).unwrap();
         }
     }

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

@@ -36,12 +36,19 @@ pub fn system_time_to_sec(time: SystemTime) -> (i64, u32) {
     }
 }
 
+/// Sets how `format_system_time` behaves if the time cannot be converted.
+pub enum FormatSystemTimeFallback {
+    Integer,      // Just print seconds since epoch (`ls`)
+    IntegerError, // The above, and print an error (`du``)
+    Float,        // Just print seconds+nanoseconds since epoch (`stat`)
+}
+
 /// 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,
-    show_error: bool,
+    mode: FormatSystemTimeFallback,
 ) -> UResult<()> {
     let zoned: Result<Zoned, _> = time.try_into();
     match zoned {
@@ -53,20 +60,30 @@ pub fn format_system_time<W: Write>(
             // 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 ts: i64 = system_time_to_sec(time).0;
-            let str = ts.to_string();
-            if show_error {
-                show_error!("time '{str}' is out of range");
-            }
-            out.write_all(str.as_bytes())?;
+            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(())
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::time::format_system_time;
+    use crate::time::{FormatSystemTimeFallback, format_system_time};
     use std::time::{Duration, UNIX_EPOCH};
 
     // Test epoch SystemTime get printed correctly at UTC0, with 2 simple formats.
@@ -76,12 +93,23 @@ mod tests {
 
         let time = UNIX_EPOCH;
         let mut out = Vec::new();
-        format_system_time(&mut out, time, "%Y-%m-%d %H:%M", false).expect("Formatting error.");
+        format_system_time(
+            &mut out,
+            time,
+            "%Y-%m-%d %H:%M",
+            FormatSystemTimeFallback::Integer,
+        )
+        .expect("Formatting error.");
         assert_eq!(String::from_utf8(out).unwrap(), "1970-01-01 00:00");
 
         let mut out = Vec::new();
-        format_system_time(&mut out, time, "%Y-%m-%d %H:%M:%S.%N %z", false)
-            .expect("Formatting error.");
+        format_system_time(
+            &mut out,
+            time,
+            "%Y-%m-%d %H:%M:%S.%N %z",
+            FormatSystemTimeFallback::Integer,
+        )
+        .expect("Formatting error.");
         assert_eq!(
             String::from_utf8(out).unwrap(),
             "1970-01-01 00:00:00.000000000 +0000"
@@ -93,12 +121,58 @@ mod tests {
     fn test_large_system_time() {
         let time = UNIX_EPOCH + Duration::from_secs(67_768_036_191_763_200);
         let mut out = Vec::new();
-        format_system_time(&mut out, time, "%Y-%m-%d %H:%M", false).expect("Formatting error.");
+        format_system_time(
+            &mut out,
+            time,
+            "%Y-%m-%d %H:%M",
+            FormatSystemTimeFallback::Integer,
+        )
+        .expect("Formatting error.");
         assert_eq!(String::from_utf8(out).unwrap(), "67768036191763200");
 
         let time = UNIX_EPOCH - Duration::from_secs(67_768_040_922_076_800);
         let mut out = Vec::new();
-        format_system_time(&mut out, time, "%Y-%m-%d %H:%M", false).expect("Formatting error.");
+        format_system_time(
+            &mut out,
+            time,
+            "%Y-%m-%d %H:%M",
+            FormatSystemTimeFallback::Integer,
+        )
+        .expect("Formatting error.");
         assert_eq!(String::from_utf8(out).unwrap(), "-67768040922076800");
     }
+
+    // Test that very large (positive or negative) lead to just the timestamp being printed.
+    #[test]
+    fn test_large_system_time_float() {
+        let time =
+            UNIX_EPOCH + Duration::from_secs(67_768_036_191_763_000) + Duration::from_nanos(123);
+        let mut out = Vec::new();
+        format_system_time(
+            &mut out,
+            time,
+            "%Y-%m-%d %H:%M",
+            FormatSystemTimeFallback::Float,
+        )
+        .expect("Formatting error.");
+        assert_eq!(
+            String::from_utf8(out).unwrap(),
+            "67768036191763000.000000123"
+        );
+
+        let time =
+            UNIX_EPOCH - Duration::from_secs(67_768_040_922_076_000) + Duration::from_nanos(123);
+        let mut out = Vec::new();
+        format_system_time(
+            &mut out,
+            time,
+            "%Y-%m-%d %H:%M",
+            FormatSystemTimeFallback::Float,
+        )
+        .expect("Formatting error.");
+        assert_eq!(
+            String::from_utf8(out).unwrap(),
+            "-67768040922076000.000000123"
+        );
+    }
 }