impl -d 1h2m3s to modify duration of an add

Cargo.lock

@@ -2,6 +2,15 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "android-tzdata"
 version = "0.1.1"
@@ -236,6 +245,12 @@ version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 
+[[package]]
+name = "memchr"
+version = "2.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
+
 [[package]]
 name = "num-traits"
 version = "0.2.17"
@@ -269,6 +284,35 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "regex"
+version = "1.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
+
 [[package]]
 name = "ryu"
 version = "1.0.15"
@@ -331,6 +375,7 @@ version = "0.1.0"
 dependencies = [
  "chrono",
  "clap",
+ "regex",
  "serde",
  "serde_yaml",
 ]

Cargo.toml

@@ -8,5 +8,6 @@ edition = "2021"
 [dependencies]
 chrono = "0.4.31"
 clap = { version = "4.4.8", features = ["derive"] }
+regex = "1.10.4"
 serde = { version = "1.0.193", features = ["derive"] }
 serde_yaml = "0.9.27"

src/main.rs

@@ -5,6 +5,8 @@ use std::time::{SystemTime, UNIX_EPOCH, Duration};
 use std::ops::{Add, Sub};
 use clap::Parser;
 use chrono::{TimeZone, Local, Timelike};
+use regex::Regex;
+use serde_yaml::from_str;
 
 #[derive(Debug, Parser)]
 struct Flags {
@@ -22,22 +24,46 @@ struct Flags {
 
    #[arg(short = 't', long = "tag")]
    tag: Option<String>,
+
+   #[arg(short = 'c', long = "clock")]
+   clock: bool,
+
+   #[arg(short = 'd', long = "duration")]
+   duration: Option<String>,
+
+   #[arg(short = 'v', long = "verbose")]
+   verbose: bool,
+
+   #[arg(short = 'p', long = "precision")]
+   precision: Option<u32>,
 }
 
 fn main() {
-   let flags = Flags::parse();
+   let mut flags = Flags::parse();
+   flags.log = flags.log || flags.since.is_some();
 
-   add(&flags.f, &flags.add, &flags.tag).unwrap();
+   let duration = parse_duration(&flags.duration).unwrap();
-   log(&flags.f, &flags.log, &flags.since).unwrap();
+
+   clock(&flags.f, &(flags.clock || flags.duration.is_some()), &duration).unwrap();
+   add(&flags.f, &flags.add, &flags.tag, &0).unwrap();
+   log(&flags.f, &flags.log, &flags.since, &flags.verbose, &flags.precision.unwrap_or(0)).unwrap();
 }
 
-fn add(f: &String, x: &Option<String>, tag: &Option<String>) -> Result<(), String> {
+fn clock(f: &String, clock: &bool, duration: &u64) -> Result<(), String> {
+   match clock {
+      true => add(&f, &Some("".to_string()), &None, duration),
+      false => Ok(()),
+   }
+}
+
+fn add(f: &String, x: &Option<String>, tag: &Option<String>, duration: &u64) -> Result<(), String> {
    match x {
       Some(x) => {
          let mut tsheet = load(&f)?;
          tsheet.add(
             x.to_string(),
             tag.clone().unwrap_or("".to_string()),
+            *duration,
          );
          save(&f, tsheet)?;
       },
@@ -58,52 +84,141 @@ struct LogX {
    x: String,
 }
 
-fn log(f: &String, enabled: &bool, since: &Option<String>) -> Result<(), String> {
+fn log(f: &String, enabled: &bool, since: &Option<String>, verbose: &bool, precision: &u32) -> Result<(), String> {
    if !enabled {
       return Ok(());
    }
    let since = parse_time(since)?;
+   if *verbose {
+      eprintln!("since = {} ({})", system_time_to_unix_seconds(&since), timestamp(&system_time_to_unix_seconds(&since)));
+   }
+
    let tsheet = load(&f)?;
    let tsheet = tsheet.since(since);
    let tsheet = tsheet.sorted();
+   if *verbose {
+      eprintln!("tsheet = {:?}", &tsheet);
+   }
 
    let mut result = vec![];
    let mut curr = Log{t: "".to_string(), d: 0.0, xs: vec![]};
    for i in 0..tsheet.xs.len() {
       let x = &tsheet.xs[i];
+      if *verbose {
+         eprintln!("{} != {}?", &curr.t, x.timestamp());
+      }
       if curr.t != x.timestamp() {
          if curr.xs.len() > 0 {
+            if *verbose {
+               eprintln!("push {:?}", &curr.xs);
+            }
             result.push(curr.clone());
          }
          curr.xs.truncate(0);
          curr.t = x.timestamp();
          curr.d = 0.0;
       }
-      let d = match curr.xs.len() {
+      let mut d = 1.0;
-         0 if x.x.len() == 0 => 0.0,
+      if x.x.len() == 0 {
-         0 => 1.0,
+         d = 0.0;
-         _ => ((tsheet.xs[i].t - tsheet.xs[i-1].t) as f32 / (60.0*60.0)) as f32,
+      } else if i > 0 {
+         d = ((tsheet.xs[i].t - tsheet.xs[i-1].t) as f32 / (60.0*60.0)) as f32;
+      }
+      if *verbose {
+         eprintln!("d={} x='{}'", &x.x, &d);
+      }
+      match x.x.len() {
+         0 => {},
+         _ => {
+            curr.t = x.timestamp();
+            curr.xs.push(LogX{d: d, x: x.x.clone()});
+         },
       };
-      curr.t = x.timestamp();
-      curr.xs.push(LogX{d: d, x: x.x.clone()});
    }
    if curr.xs.len() > 0 {
+      if *verbose {
+         eprintln!("push {:?} (final)", &curr.xs);
+      }
       result.push(curr.clone());
    }
    for i in result.iter_mut() {
       i.d = i.xs.iter().map(|x| x.d).sum();
+      if *verbose {
+         eprintln!("{} = {:?}", &i.d, &i.xs.iter().map(|x| x.d).collect::<Vec<_>>());
+      }
    }
 
    for log in result {
       for x in log.xs {
          if x.x.len() > 0 {
-            println!("{} ({}) {} ({:.1})", log.t, (0.5 + log.d) as i64, x.x, x.d + 0.05);
+            match precision {
+               0 => println!("{} ({:.0}) {} ({:.1})", log.t, log.d, x.x, x.d),
+               1 => println!("{} ({:.1}) {} ({:.2})", log.t, log.d, x.x, x.d),
+               _ => println!("{} ({:.2}) {} ({:.3})", log.t, log.d, x.x, x.d),
+            }
          }
       }
    }
    Ok(())
 }
 
+#[cfg(test)]
+mod test_parse {
+   use super::*;
+
+   #[test]
+   fn test_duration() {
+      assert_eq!(0, parse_duration(&None).unwrap());
+      assert_eq!(1, parse_duration(&Some("1s".to_string())).unwrap());
+      assert_eq!(33, parse_duration(&Some("33s".to_string())).unwrap());
+      assert_eq!(666, parse_duration(&Some("666s".to_string())).unwrap());
+      assert_eq!(60, parse_duration(&Some("1m".to_string())).unwrap());
+      assert_eq!(62, parse_duration(&Some("1m2s".to_string())).unwrap());
+      assert_eq!(3600, parse_duration(&Some("1h".to_string())).unwrap());
+      assert_eq!(3723, parse_duration(&Some("1h2m3s".to_string())).unwrap());
+   }
+}
+
+fn parse_duration(d: &Option<String>) -> Result<u64, String> {
+   match d {
+      Some(d) => {
+         let mut sum: u64 = 0;
+         let re = Regex::new(r"^(?<hours>[0-9]+h)?(?<minutes>[0-9]+m)?(?<seconds>[0-9]+s)?$").unwrap();
+         match re.captures(d) {
+            Some(captures) => {
+               match captures.name("seconds") {
+                  Some(n) => {
+                     let n = n.as_str().to_string();
+                     let n = n.trim_end_matches('s');
+                     sum += from_str::<u64>(n).unwrap();
+                  },
+                  None => {},
+               };
+               match captures.name("minutes") {
+                  Some(n) => {
+                     let n = n.as_str().to_string();
+                     let n = n.trim_end_matches('m');
+                     sum += 60 * from_str::<u64>(n).unwrap();
+                  },
+                  None => {},
+               };
+               match captures.name("hours") {
+                  Some(n) => {
+                     let n = n.as_str().to_string();
+                     let n = n.trim_end_matches('h');
+                     sum += 60 * 60 * from_str::<u64>(n).unwrap();
+                  },
+                  None => {},
+               };
+               Ok(sum)
+            },
+            None => Ok(0),
+         }
+      },
+      None => Ok(0),
+   }
+}
+
 fn parse_time(since: &Option<String>) -> Result<SystemTime, String> {
    match since {
       Some(since) => {
@@ -203,8 +318,13 @@ impl TSheet {
       result
    }
 
-   fn add(&mut self, x: String, tag: String) {
+   fn add(&mut self, x: String, tag: String, duration: u64) {
-      self.xs.push(new_x(SystemTime::now(), x, tag));
+      let now = system_time_to_unix_seconds(&SystemTime::now());
+      self.xs.push(new_x(
+         now - duration as i64,
+         x,
+         tag,
+      ));
    }
 
    fn sorted(&self) -> TSheet {
@@ -220,14 +340,22 @@ impl X {
    }
 
    fn timestamp(&self) -> String {
-      let dt = Local.timestamp_opt(self.t, 0).unwrap();
+      timestamp(&self.t)
-      dt.format("%Y-%m-%d").to_string()
    }
 }
 
-fn new_x(t: SystemTime, x: String, tag: String) -> X {
+fn system_time_to_unix_seconds(st: &SystemTime) -> i64 {
+   st.duration_since(UNIX_EPOCH).unwrap().as_secs() as i64
+}
+
+fn timestamp(t: &i64) -> String {
+   let dt = Local.timestamp_opt(*t, 0).unwrap();
+   dt.format("%Y-%m-%d").to_string()
+}
+
+fn new_x(t: i64, x: String, tag: String) -> X {
    X{
-      t: t.duration_since(UNIX_EPOCH).unwrap().as_secs() as i64,
+      t: t,
       x: x,
       tag: tag,
    }
@@ -242,7 +370,7 @@ mod test_tsheet {
       let mut given = TSheet{xs: vec![
          X{t: 1, x: "def".to_string(), tag: "abc".to_string()},
       ]};
-      given.add("ghi".to_string(), "".to_string());
+      given.add("ghi".to_string(), "".to_string(), 0);
       assert_eq!(given.xs.len(), 2);
       assert!(given.xs[1].t != 1);
       assert_eq!(given.xs[1].x, "ghi".to_string());