oops rust evidently will do some rounding for prints

src/main.rs

@@ -25,6 +25,9 @@ struct Flags {
 
    #[arg(short = 'c', long = "clock")]
    clock: bool,
+
+   #[arg(short = 'v', long = "verbose")]
+   verbose: bool,
 }
 
 fn main() {
@@ -33,7 +36,7 @@ fn main() {
 
    clock(&flags.f, &flags.clock).unwrap();
    add(&flags.f, &flags.add, &flags.tag).unwrap();
-   log(&flags.f, &flags.log, &flags.since).unwrap();
+   log(&flags.f, &flags.log, &flags.since, &flags.verbose).unwrap();
 }
 
 fn clock(f: &String, clock: &bool) -> Result<(), String> {
@@ -70,32 +73,49 @@ 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) -> 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 => {},
          _ => {
@@ -105,16 +125,22 @@ fn log(f: &String, enabled: &bool, since: &Option<String>) -> Result<(), String>
       };
    }
    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);
+            println!("{} ({:.0}) {} ({:.1})", log.t, log.d, x.x, x.d);
          }
       }
    }
@@ -237,14 +263,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 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: SystemTime, x: String, tag: String) -> X {
    X{
-      t: t.duration_since(UNIX_EPOCH).unwrap().as_secs() as i64,
+      t: system_time_to_unix_seconds(&t),
       x: x,
       tag: tag,
    }