stat: Stop relying on fsext::Birth

We can rely on other fsext/time functions, and stay a bit more
consistent.

Author: drinkcat

Cargo.lock

@@ -26,7 +26,6 @@ uucore = { workspace = true, features = [
   "fsext",
   "time",
 ] }
-chrono = { workspace = true }
 thiserror = { workspace = true }
 
 [features]

src/uu/stat/Cargo.toml

@@ -10,13 +10,12 @@ use clap::builder::ValueParser;
 use uucore::display::Quotable;
 use uucore::fs::display_permissions;
 use uucore::fsext::{
-    BirthTime, FsMeta, MetadataTimeField, StatFs, metadata_get_time, pretty_filetype,
-    pretty_fstype, read_fs_list, statfs,
+    FsMeta, MetadataTimeField, StatFs, metadata_get_time, pretty_filetype, pretty_fstype,
+    read_fs_list, statfs,
 };
 use uucore::libc::mode_t;
 use uucore::{entries, format_usage, show_error, show_warning};
 
-use chrono::{DateTime, Local};
 use clap::{Arg, ArgAction, ArgMatches, Command};
 use std::borrow::Cow;
 use std::ffi::{OsStr, OsString};
@@ -29,6 +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};
 
 #[derive(Debug, Error)]
 enum StatError {
@@ -1030,7 +1030,10 @@ impl Stater {
                     'w' => OutputType::Str(pretty_time(meta, MetadataTimeField::Birth)),
 
                     // time of file birth, seconds since Epoch; 0 if unknown
-                    'W' => OutputType::Unsigned(meta.birth().unwrap_or_default().0),
+                    'W' => OutputType::Integer(
+                        metadata_get_time(meta, MetadataTimeField::Birth)
+                            .map_or(0, |x| system_time_to_sec(x).0),
+                    ),
 
                     // time of last access, human-readable
                     'x' => OutputType::Str(pretty_time(meta, MetadataTimeField::Access)),
@@ -1040,21 +1043,9 @@ impl Stater {
                     'y' => OutputType::Str(pretty_time(meta, MetadataTimeField::Modification)),
                     // time of last data modification, seconds since Epoch
                     'Y' => {
-                        let sec = meta.mtime();
-                        let nsec = meta.mtime_nsec();
-                        let tm = DateTime::from_timestamp(sec, nsec as u32).unwrap_or_default();
-                        let tm: DateTime<Local> = tm.into();
-                        match tm.timestamp_nanos_opt() {
-                            None => {
-                                let micros = tm.timestamp_micros();
-                                let secs = micros as f64 / 1_000_000.0;
-                                OutputType::Float(secs)
-                            }
-                            Some(ns) => {
-                                let secs = ns as f64 / 1_000_000_000.0;
-                                OutputType::Float(secs)
-                            }
-                        }
+                        let (sec, nsec) = metadata_get_time(meta, MetadataTimeField::Modification)
+                            .map_or((0, 0), system_time_to_sec);
+                        OutputType::Float(sec as f64 + nsec as f64 / 1_000_000_000.0)
                     }
                     // time of last status change, human-readable
                     'z' => OutputType::Str(pretty_time(meta, MetadataTimeField::Change)),
@@ -1297,7 +1288,7 @@ 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 uucore::time::format_system_time(&mut tmp, time, PRETTY_DATETIME_FORMAT, false).is_ok() {
+        if format_system_time(&mut tmp, time, PRETTY_DATETIME_FORMAT, false).is_ok() {
             return String::from_utf8(tmp).unwrap();
         }
     }

src/uu/stat/src/stat.rs

@@ -69,7 +69,9 @@ use std::io::Error as IOError;
 use std::mem;
 #[cfg(windows)]
 use std::path::Path;
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::SystemTime;
+#[cfg(not(windows))]
+use std::time::UNIX_EPOCH;
 use std::{borrow::Cow, ffi::OsString};
 
 use std::fs::Metadata;
@@ -114,19 +116,6 @@ pub use libc::statfs as statfs_fn;
 ))]
 pub use libc::statvfs as statfs_fn;
 
-pub trait BirthTime {
-    fn birth(&self) -> Option<(u64, u32)>;
-}
-
-impl BirthTime for Metadata {
-    fn birth(&self) -> Option<(u64, u32)> {
-        self.created()
-            .ok()
-            .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
-            .map(|e| (e.as_secs(), e.subsec_nanos()))
-    }
-}
-
 #[derive(Debug, Copy, Clone)]
 pub enum MetadataTimeField {
     Modification,

src/uucore/src/lib/features/fsext.rs

@@ -25,6 +25,17 @@ fn format_zoned<W: Write>(out: &mut W, zoned: Zoned, fmt: &str) -> UResult<()> {
         .map_err(|x| USimpleError::new(1, x.to_string()))
 }
 
+/// Convert a SystemTime` to a number of seconds since UNIX_EPOCH
+pub fn system_time_to_sec(time: SystemTime) -> (i64, u32) {
+    if time > UNIX_EPOCH {
+        let d = time.duration_since(UNIX_EPOCH).unwrap();
+        (d.as_secs() as i64, d.subsec_nanos())
+    } else {
+        let d = UNIX_EPOCH.duration_since(time).unwrap();
+        (-(d.as_secs() as i64), d.subsec_nanos())
+    }
+}
+
 /// Format a `SystemTime` according to given fmt, and append to vector out.
 pub fn format_system_time<W: Write>(
     out: &mut W,
@@ -42,11 +53,7 @@ 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 = if time > UNIX_EPOCH {
-                time.duration_since(UNIX_EPOCH).unwrap().as_secs() as i64
-            } else {
-                -(UNIX_EPOCH.duration_since(time).unwrap().as_secs() as i64)
-            };
+            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");