feat(flagset): support time duration (#11)

Zaba505 · web-flow · commit 6f680f7e6429 · 2020-09-13T01:12:07.000-04:00
* feat(duration): wrap std time duration and impl value trait

* feat(mod): rexport time mod

* test(duration): properly parse subsecond units

* build(feature): use duration constants

* feat(duration): format to milli,micro,or nanoseconds when subsecond

* test(duration): add case for fractional special cases

* feat(duration): completely parse and format duration

* refactor(duration): impl fromstr vs value

* feat(value/slice): impl intoiterator and fromiterator traits

* feat(time/duration): add simple constructor method

* feat(flagset): add methods for creating flags based on time durations
diff --git a/src/lib.rs b/src/lib.rs
@@ -5,9 +5,11 @@
 
 #![feature(type_name_of_val)]
 #![feature(test)]
+#![feature(duration_constants)]
 
 extern crate test;
 
+pub mod time;
 mod value;
 
 pub use value::Slice;
@@ -528,6 +530,90 @@ impl FlagSet {
         })
     }
 
+    #[doc = "Defines a `time::Duration` flag with specified name, default value, and usage string."]
+    pub fn duration<S: Into<String>, U: Into<String>>(
+        &mut self,
+        name: S,
+        value: time::Duration,
+        usage: U,
+    ) {
+        self.add_flag(Flag {
+            name: name.into(),
+            shorthand: char::default(),
+            usage: usage.into(),
+            value: Box::new(value),
+            def_value: String::new(),
+            changed: false,
+            no_opt_def_value: String::new(),
+            deprecated: String::new(),
+            hidden: false,
+            shorthand_deprecated: String::new(),
+        })
+    }
+
+    #[doc = "duration_p is like duration, but accepts a shorthand letter that can be used after a single dash."]
+    pub fn duration_p<S, U>(&mut self, name: S, shorthand: char, value: time::Duration, usage: U)
+    where
+        S: Into<String>,
+        U: Into<String>,
+    {
+        self.add_flag(Flag {
+            name: name.into(),
+            shorthand,
+            usage: usage.into(),
+            value: Box::new(value),
+            def_value: String::new(),
+            changed: false,
+            no_opt_def_value: String::new(),
+            deprecated: String::new(),
+            hidden: false,
+            shorthand_deprecated: String::new(),
+        })
+    }
+
+    #[doc = "duration_slice defines a `Slice<time::Duration>` flag with specified name, default value, and usage string."]
+    pub fn duration_slice<S: Into<String>, U: Into<String>>(
+        &mut self,
+        name: S,
+        value: value::Slice<time::Duration>,
+        usage: U,
+    ) {
+        self.add_flag(Flag {
+            name: name.into(),
+            shorthand: char::default(),
+            usage: usage.into(),
+            value: Box::new(value),
+            def_value: String::new(),
+            changed: false,
+            no_opt_def_value: String::new(),
+            deprecated: String::new(),
+            hidden: false,
+            shorthand_deprecated: String::new(),
+        })
+    }
+
+    #[doc = "duration_p_slice is like duration_slice, but accepts a shorthand letter that can used after a single dash."]
+    pub fn duration_p_slice<S: Into<String>, U: Into<String>>(
+        &mut self,
+        name: S,
+        shorthand: char,
+        value: value::Slice<time::Duration>,
+        usage: U,
+    ) {
+        self.add_flag(Flag {
+            name: name.into(),
+            shorthand,
+            usage: usage.into(),
+            value: Box::new(value),
+            def_value: String::new(),
+            changed: false,
+            no_opt_def_value: String::new(),
+            deprecated: String::new(),
+            hidden: false,
+            shorthand_deprecated: String::new(),
+        })
+    }
+
     builtin_flag_val!(char, char);
     builtin_flag_val!(string, String);
     builtin_flag_val!(uint8, u8);
@@ -951,6 +1037,15 @@ mod tests {
         assert_eq!(flags.args().len(), 1);
     }
 
+    #[test]
+    fn duration_value() {
+        let mut flags = FlagSet::new("test");
+        flags.duration("time", time::Duration::new(1, 0), "test");
+
+        let val = flags.value_of::<time::Duration>("time").unwrap();
+        assert_eq!(val.as_secs(), 1);
+    }
+
     #[bench]
     fn bench_parse(b: &mut Bencher) {
         let mut flags = FlagSet::new("bench");
diff --git a/src/time.rs b/src/time.rs
@@ -0,0 +1,253 @@
+//! Temporal quantification.
+
+use std::convert;
+use std::fmt;
+use std::num;
+use std::ops;
+use std::str;
+use std::time;
+
+/// A Duration type to represent a span of time.
+///
+/// A string representing the duration is of the form "72h3m0.5s".
+/// As a special case, durations less than one second format use a
+/// smaller unit (milli-, micro-, or nanoseconds) to ensure that the
+/// leading digit is non-zero. The zero duration formats as 0s.
+///
+/// ```
+/// use std::time;
+/// use pflag::Value;
+/// use pflag::time::Duration;
+///
+/// let mut d = Duration::default();
+/// d.set("1h1m10.987654321s".to_string());
+///
+/// assert_eq!(d, Duration::from(time::Duration::new(3670, 987654321)));
+/// assert_eq!(format!("{}", d), "1h1m10.987654321s");
+/// ```
+#[derive(Debug, Default, Copy, Clone, PartialEq, PartialOrd)]
+pub struct Duration(time::Duration);
+
+impl Duration {
+    pub fn new(secs: u64, nanos: u32) -> Self {
+        Self(time::Duration::new(secs, nanos))
+    }
+}
+
+impl str::FromStr for Duration {
+    type Err = num::ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut chars = s.chars().peekable();
+        let mut secs = 0;
+        let mut nanos = 0;
+
+        loop {
+            let (s, c) = scan_digits(&mut chars);
+            let num: u64 = s.parse()?;
+            match c {
+                'h' => {
+                    secs += num * 3600;
+                }
+                'm' => {
+                    let c = chars.peek().unwrap();
+                    if *c == 's' {
+                        chars.next();
+                        nanos += num * 1e6 as u64;
+                        break;
+                    }
+                    secs += num * 60;
+                }
+                'µ' => {
+                    nanos += num * 1e3 as u64;
+                    break;
+                }
+                'n' => {
+                    nanos += num;
+                    break;
+                }
+                's' => {
+                    secs += num;
+                    break;
+                }
+                '.' => {
+                    let (mut s, c) = scan_digits(&mut chars);
+                    let mut pad = 9;
+                    if c == 's' {
+                        secs += num;
+                    } else if c == 'm' {
+                        nanos += num * 1e6 as u64;
+                        pad = 6;
+                    } else {
+                        nanos += num * 1e3 as u64;
+                        pad = 3;
+                    }
+                    (0..pad - s.len()).for_each(|_| s.push('0'));
+                    let s = s.trim_start_matches('0');
+                    let frac: u64 = s.parse()?;
+                    nanos += frac;
+                    break;
+                }
+                _ => break,
+            }
+        }
+
+        Ok(Self(time::Duration::new(secs, nanos as u32)))
+    }
+}
+
+fn scan_digits<I: Iterator<Item = char>>(iter: &mut I) -> (String, char) {
+    let mut s = String::new();
+    loop {
+        let c = iter.next().unwrap();
+        if c.is_alphabetic() || c == '.' {
+            return (s, c);
+        }
+
+        s.push(c);
+    }
+}
+
+impl fmt::Display for Duration {
+    // largest time fmt is 5119296h10m10.000000000s
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.0 == time::Duration::default() {
+            return write!(f, "0s");
+        }
+        let mut buf = [0 as u8; 32];
+        let mut w = buf.len();
+        if self.0 < time::Duration::SECOND {
+            let mut prec = 0;
+            w -= 1;
+            buf[w] = 's' as u8;
+            w -= 1;
+            if self.0 < time::Duration::MICROSECOND {
+                buf[w] = 'n' as u8;
+            } else if self.0 < time::Duration::MILLISECOND {
+                prec = 3;
+                w -= 1;
+                // U+00B5 'µ' micro sign == 0xC2 0xB5
+                buf[w] = 0xC2;
+                buf[w + 1] = 0xB5;
+            } else {
+                prec = 6;
+                buf[w] = 'm' as u8;
+            }
+            let (w2, u) = fmt_frac(&mut buf[..w], self.0.as_nanos() as u64, prec);
+            w = fmt_int(&mut buf[..w2], u);
+        } else {
+            w -= 1;
+            buf[w] = 's' as u8;
+
+            let (w2, mut u) = fmt_frac(&mut buf[..w], self.0.as_nanos() as u64, 9);
+
+            w = fmt_int(&mut buf[..w2], u % 60);
+            u /= 60;
+
+            if u > 0 {
+                w -= 1;
+                buf[w] = 'm' as u8;
+                w = fmt_int(&mut buf[..w], u % 60);
+                u /= 60;
+
+                if u > 0 {
+                    w -= 1;
+                    buf[w] = 'h' as u8;
+                    w = fmt_int(&mut buf[..w], u)
+                }
+            }
+        }
+
+        f.write_str(str::from_utf8(&buf[w..]).unwrap())
+    }
+}
+
+fn fmt_frac(buf: &mut [u8], mut v: u64, prec: u8) -> (usize, u64) {
+    // Omit trailing zeros up to and including decimal point.
+    let mut w = buf.len();
+    let mut print = false;
+    for _ in 0..prec {
+        let digit = v % 10;
+        print = print || digit != 0;
+        if print {
+            w -= 1;
+            buf[w] = digit as u8 + '0' as u8;
+        }
+        v /= 10;
+    }
+    if print {
+        w -= 1;
+        buf[w] = '.' as u8;
+    }
+    (w, v)
+}
+
+fn fmt_int(buf: &mut [u8], mut v: u64) -> usize {
+    let mut w = buf.len();
+    if v == 0 {
+        w -= 1;
+        buf[w] = '0' as u8;
+    } else {
+        while v > 0 {
+            w -= 1;
+            buf[w] = (v % 10) as u8 + '0' as u8;
+            v /= 10;
+        }
+    }
+    w
+}
+
+impl From<time::Duration> for Duration {
+    fn from(d: time::Duration) -> Self {
+        Self(d)
+    }
+}
+
+impl Into<time::Duration> for Duration {
+    fn into(self) -> time::Duration {
+        self.0
+    }
+}
+
+impl ops::Deref for Duration {
+    type Target = time::Duration;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl convert::AsRef<time::Duration> for Duration {
+    fn as_ref(&self) -> &time::Duration {
+        &self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::value::Value;
+
+    #[test]
+    fn format() {
+        let cases = vec![
+            ("3ns", time::Duration::new(0, 3)),
+            ("3.000001ms", time::Duration::new(0, 3000001)),
+            ("3s", time::Duration::new(3, 0)),
+            ("1m0s", time::Duration::new(60, 0)),
+            ("1h0m0s", time::Duration::new(3600, 0)),
+            ("1h0m0.0001s", time::Duration::new(3600, 100000)),
+        ];
+
+        cases
+            .into_iter()
+            .map(|(f, d)| (f, Duration::from(d)))
+            .for_each(|(f, d)| {
+                assert_eq!(f, format!("{}", d));
+                let mut d2 = Duration::default();
+                let res = d2.set(f.to_string());
+                assert!(res.is_ok());
+                assert_eq!(d, d2);
+            })
+    }
+}
diff --git a/src/value.rs b/src/value.rs
