sleep: use uucore duration parsing instead of fundu

Author: Qelxiros

Cargo.lock

@@ -61,37 +61,17 @@ pub fn uu_app() -> Command {
 fn sleep(args: &[&str]) -> UResult<()> {
     let mut arg_error = false;
 
-    use fundu::TimeUnit::{Day, Hour, Minute, Second};
-    let parser = DurationParser::with_time_units(&[Second, Minute, Hour, Day]);
-
     let sleep_dur = args
         .iter()
-        .filter_map(|input| match parser.parse(input.trim()) {
+        .filter_map(|input| match uucore::parse_time::from_str(input.trim()) {
             Ok(duration) => Some(duration),
             Err(error) => {
                 arg_error = true;
-
-                let reason = match error {
-                    ParseError::Empty if input.is_empty() => "Input was empty".to_string(),
-                    ParseError::Empty => "Found only whitespace in input".to_string(),
-                    ParseError::Syntax(pos, description)
-                    | ParseError::TimeUnit(pos, description) => {
-                        format!("{description} at position {}", pos.saturating_add(1))
-                    }
-                    ParseError::NegativeExponentOverflow | ParseError::PositiveExponentOverflow => {
-                        "Exponent was out of bounds".to_string()
-                    }
-                    ParseError::NegativeNumber => "Number was negative".to_string(),
-                    error => error.to_string(),
-                };
-                show_error!("invalid time interval '{input}': {reason}");
-
+                show_error!("{error}");
                 None
             }
         })
-        .fold(Duration::ZERO, |acc, n| {
-            acc.saturating_add(SaturatingInto::<std::time::Duration>::saturating_into(n))
-        });
+        .fold(Duration::ZERO, |acc, n| acc.saturating_add(n));
 
     if arg_error {
         return Err(UUsageError::new(1, ""));

src/uu/sleep/src/sleep.rs

@@ -51,6 +51,7 @@ sha3 = { workspace = true, optional = true }
 blake2b_simd = { workspace = true, optional = true }
 blake3 = { workspace = true, optional = true }
 sm3 = { workspace = true, optional = true }
+hexfloat2 = "0.1.3"
 
 [target.'cfg(unix)'.dependencies]
 walkdir = { workspace = true, optional = true }

src/uucore/Cargo.toml

@@ -12,6 +12,8 @@ use std::time::Duration;
 
 use crate::display::Quotable;
 
+use hexfloat2::parse;
+
 /// Parse a duration from a string.
 ///
 /// The string may contain only a number, like "123" or "4.5", or it
@@ -49,16 +51,21 @@ pub fn from_str(string: &str) -> Result<Duration, String> {
     if len == 0 {
         return Err("empty string".to_owned());
     }
+    let base = match string.get(0..2) {
+        Some("0x") => 16,
+        _ => 10,
+    };
     let slice = match string.get(..len - 1) {
         Some(s) => s,
         None => return Err(format!("invalid time interval {}", string.quote())),
     };
-    let (numstr, times) = match string.chars().next_back().unwrap() {
-        's' => (slice, 1),
-        'm' => (slice, 60),
-        'h' => (slice, 60 * 60),
-        'd' => (slice, 60 * 60 * 24),
-        val if !val.is_alphabetic() => (string, 1),
+    let (numstr, times) = match (string.chars().next_back().unwrap(), base) {
+        ('s', _) => (slice, 1),
+        ('m', _) => (slice, 60),
+        ('h', _) => (slice, 60 * 60),
+        // if the number is hex, GNU coreutils will parse the trailing d as part of the number, not as days
+        ('d', 10) => (slice, 60 * 60 * 24),
+        (val, _) if !val.is_alphabetic() => (string, 1),
         _ => {
             if string == "inf" || string == "infinity" {
                 ("inf", 1)
@@ -67,9 +74,14 @@ pub fn from_str(string: &str) -> Result<Duration, String> {
             }
         }
     };
-    let num = numstr
-        .parse::<f64>()
-        .map_err(|e| format!("invalid time interval {}: {}", string.quote(), e))?;
+    let num = if base == 16 {
+        // hexfloat2 ParseErrors are ZSTs
+        parse::<f64>(numstr).map_err(|_| format!("invalid time interval {}", string.quote()))?
+    } else {
+        numstr
+            .parse::<f64>()
+            .map_err(|e| format!("invalid time interval {}: {}", string.quote(), e))?
+    };
 
     if num < 0. {
         return Err(format!("invalid time interval {}", string.quote()));

src/uucore/src/lib/parser/parse_time.rs

@@ -14,11 +14,11 @@ fn test_invalid_time_interval() {
     new_ucmd!()
         .arg("xyz")
         .fails()
-        .usage_error("invalid time interval 'xyz': Invalid input: xyz");
+        .usage_error("invalid time interval 'xyz'");
     new_ucmd!()
         .args(&["--", "-1"])
         .fails()
-        .usage_error("invalid time interval '-1': Number was negative");
+        .usage_error("invalid time interval '-1'");
 }
 
 #[test]
@@ -208,16 +208,14 @@ fn test_sleep_when_input_has_only_whitespace_then_error(#[case] input: &str) {
         .arg(input)
         .timeout(Duration::from_secs(10))
         .fails()
-        .usage_error(format!(
-            "invalid time interval '{input}': Found only whitespace in input"
-        ));
+        .usage_error("empty string");
 }
 
 #[test]
 fn test_sleep_when_multiple_input_some_with_error_then_shows_all_errors() {
-    let expected = "invalid time interval 'abc': Invalid input: abc\n\
-        sleep: invalid time interval '1years': Invalid time unit: 'years' at position 2\n\
-        sleep: invalid time interval ' ': Found only whitespace in input";
+    let expected = "invalid time interval 'abc'\n\
+        sleep: invalid time interval '1years': invalid float literal\n\
+        sleep: empty string";
 
     // Even if one of the arguments is valid, but the rest isn't, we should still fail and exit early.
     // So, the timeout of 10 seconds ensures we haven't executed `thread::sleep` with the only valid
@@ -234,5 +232,13 @@ fn test_negative_interval() {
     new_ucmd!()
         .args(&["--", "-1"])
         .fails()
-        .usage_error("invalid time interval '-1': Number was negative");
+        .usage_error("invalid time interval '-1'");
+}
+
+#[rstest]
+#[case::int("0x0")]
+#[case::frac("0x0.1")]
+#[case::scientific("0x1.0p-3")]
+fn test_hex_duration(#[case] input: &str) {
+    new_ucmd!().arg(input).succeeds().no_output();
 }