since multi day prints expected

src/main.rs

@@ -1,12 +1,12 @@
-use serde::{Serialize, Deserialize};
+use chrono::{Local, TimeZone, Timelike};
-use std::io::{Read, Write};
-use std::fs::File;
-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::{Deserialize, Serialize};
 use serde_yaml::from_str;
+use std::fs::File;
+use std::io::{Read, Write};
+use std::ops::{Add, Sub};
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
 #[derive(Debug, Parser)]
 struct Flags {
@@ -44,9 +44,21 @@ fn main() {
 
     let duration = parse_duration(&flags.duration).unwrap();
 
-   clock(&flags.f, &(flags.clock || flags.duration.is_some()), &duration).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();
+    log(
+        &flags.f,
+        &flags.log,
+        &flags.since,
+        &flags.verbose,
+        &flags.precision.unwrap_or(0),
+    )
+    .unwrap();
 }
 
 fn clock(f: &String, clock: &bool, duration: &u64) -> Result<(), String> {
@@ -66,8 +78,8 @@ fn add(f: &String, x: &Option<String>, tag: &Option<String>, duration: &u64) ->
                 *duration,
             );
             save(&f, tsheet)?;
-      },
+        }
-      None => {},
+        None => {}
     };
     Ok(())
 }
@@ -84,13 +96,23 @@ struct LogX {
     x: String,
 }
 
-fn log(f: &String, enabled: &bool, since: &Option<String>, verbose: &bool, precision: &u32) -> 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), &2));
+        eprintln!(
+            "since = {} ({})",
+            system_time_to_unix_seconds(&since),
+            timestamp(&system_time_to_unix_seconds(&since), &2)
+        );
     }
 
     let tsheet = load(&f)?;
@@ -100,7 +122,11 @@ fn log(f: &String, enabled: &bool, since: &Option<String>, verbose: &bool, preci
     }
 
     let mut result = vec![];
-   let mut curr = Log{t: "".to_string(), d: 0.0, xs: vec![]};
+    let mut curr = Log {
+        t: "".to_string(),
+        d: 0.0,
+        xs: vec![],
+    };
     let mut currt = "".to_string();
     for i in 0..tsheet.xs.len() {
         let x = &tsheet.xs[i];
@@ -120,21 +146,26 @@ fn log(f: &String, enabled: &bool, since: &Option<String>, verbose: &bool, preci
             curr.d = 0.0;
         }
         let mut d = 1.0;
-      if x.x.len() == 0 { // clock ins get duration zero
+        if x.x.len() == 0 {
+            // clock ins get duration zero
             d = 0.0;
-      } else if i > 0 && tsheet.xs[i].timestamp(&0) == tsheet.xs[i-1].timestamp(&0) { // if same day as previous then use elapsed as duration
+        } else if i > 0 && tsheet.xs[i].timestamp(&0) == tsheet.xs[i - 1].timestamp(&0) {
+            // if same day as previous then use elapsed as duration
             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 => {},
+            0 => {}
             _ => {
                 curr.t = x.timestamp(&precision);
                 currt = x.timestamp(&0);
-            curr.xs.push(LogX{d: d, x: x.x.clone()});
+                curr.xs.push(LogX {
-         },
+                    d: d,
+                    x: x.x.clone(),
+                });
+            }
         };
     }
     if curr.xs.len() > 0 {
@@ -148,7 +179,11 @@ fn log(f: &String, enabled: &bool, since: &Option<String>, verbose: &bool, preci
         i.d = i.xs.iter().map(|x| x.d).sum();
         total_d += i.d;
         if *verbose {
-         eprintln!("{} = {:?}", &i.d, &i.xs.iter().map(|x| x.d).collect::<Vec<_>>());
+            eprintln!(
+                "{} = {:?}",
+                &i.d,
+                &i.xs.iter().map(|x| x.d).collect::<Vec<_>>()
+            );
         }
     }
 
@@ -166,9 +201,24 @@ fn log(f: &String, enabled: &bool, since: &Option<String>, verbose: &bool, preci
 
     if result.len() > 1 {
         match precision {
-      0 => eprintln!("({:.0}h over {} dates)", total_d, result.len()),
+            0 => eprintln!(
-      1 => eprintln!("({:.1}h over {} dates)", total_d, result.len()),
+                "({:.0}h of {}h over {} dates)",
-      _ => eprintln!("({:.2}h over {} dates)", total_d, result.len()),
+                total_d,
+                8 * result.len(),
+                result.len()
+            ),
+            1 => eprintln!(
+                "({:.1}h of {}h over {} dates)",
+                total_d,
+                8 * result.len(),
+                result.len()
+            ),
+            _ => eprintln!(
+                "({:.2}h of {}h over {} dates)",
+                total_d,
+                8 * result.len(),
+                result.len()
+            ),
         }
     }
 
@@ -196,7 +246,8 @@ 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();
+            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") {
@@ -204,49 +255,47 @@ fn parse_duration(d: &Option<String>) -> Result<u64, String> {
                             let n = n.as_str().to_string();
                             let n = n.trim_end_matches('s');
                             sum += from_str::<u64>(n).unwrap();
-                  },
+                        }
-                  None => {},
+                        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 => {},
+                        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 => {},
+                        None => {}
                     };
                     Ok(sum)
-            },
+                }
                 None => Ok(0),
             }
-      },
+        }
         None => Ok(0),
     }
 }
 
 fn parse_time(since: &Option<String>) -> Result<SystemTime, String> {
     match since {
-      Some(since) => {
+        Some(since) => match chrono::NaiveDate::parse_from_str(since, "%Y-%m-%d") {
-         match chrono::NaiveDate::parse_from_str(since, "%Y-%m-%d") {
             Ok(nd) => {
                 let ndt = nd.and_hms_opt(1, 1, 1).unwrap();
                 let dt = Local.from_local_datetime(&ndt).unwrap();
-               Ok(UNIX_EPOCH.add(
+                Ok(UNIX_EPOCH.add(Duration::from_secs(dt.timestamp() as u64)))
-                  Duration::from_secs(dt.timestamp() as u64)
-               ))
-            },
-            Err(msg) => Err(format!("failed to parse {}: {}", since, msg)),
             }
+            Err(msg) => Err(format!("failed to parse {}: {}", since, msg)),
         },
-      None => Ok(SystemTime::now().sub(Duration::from_secs(Local::now().hour() as u64*60*60))),
+        None => {
+            Ok(SystemTime::now().sub(Duration::from_secs(Local::now().hour() as u64 * 60 * 60)))
+        }
     }
 }
 
@@ -265,7 +314,10 @@ struct X {
 fn save(path: &String, tsheet: TSheet) -> Result<(), String> {
     match File::create(path.clone()) {
         Ok(mut writer) => _save(&mut writer, tsheet),
-      Err(reason) => Err(format!("failed to open {} to save tsheet: {}", path, reason)),
+        Err(reason) => Err(format!(
+            "failed to open {} to save tsheet: {}",
+            path, reason
+        )),
     }
 }
 
@@ -307,10 +359,20 @@ mod test_save_load {
 
     #[test]
     fn test_testdata_standalone_yaml() {
-      let want = TSheet{xs: vec![
+        let want = TSheet {
-         X{t: 1, x: "def".to_string(), tag: "abc".to_string()},
+            xs: vec![
-         X{t: 2, x: "ghi".to_string(), tag: "".to_string()},
+                X {
-      ]};
+                    t: 1,
+                    x: "def".to_string(),
+                    tag: "abc".to_string(),
+                },
+                X {
+                    t: 2,
+                    x: "ghi".to_string(),
+                    tag: "".to_string(),
+                },
+            ],
+        };
         assert_eq!(
             load(&"./src/testdata/standalone.yaml".to_string()).expect("cant load standalone.yaml"),
             want,
@@ -318,14 +380,18 @@ mod test_save_load {
 
         let mut w = vec![];
         _save(&mut w, want).expect("failed saving tsheet to writer");
-      assert_eq!(String::from_utf8(w).unwrap(), "xs:\n- t: 1\n  x: def\n  tag: abc\n- t: 2\n  x: ghi\n  tag: ''\n".to_string());
+        assert_eq!(
+            String::from_utf8(w).unwrap(),
+            "xs:\n- t: 1\n  x: def\n  tag: abc\n- t: 2\n  x: ghi\n  tag: ''\n".to_string()
+        );
     }
 }
 
 impl TSheet {
     fn since(&self, t: SystemTime) -> TSheet {
         let mut result = TSheet { xs: vec![] };
-      self.xs.iter()
+        self.xs
+            .iter()
             .filter(|x| x.ts() >= t)
             .for_each(|x| result.xs.push(x.clone()));
         result
@@ -333,11 +399,7 @@ impl TSheet {
 
     fn add(&mut self, x: String, tag: String, duration: u64) {
         let now = system_time_to_unix_seconds(&SystemTime::now());
-      self.xs.push(new_x(
+        self.xs.push(new_x(now - duration as i64, x, tag));
-         now - duration as i64,
-         x,
-         tag,
-      ));
     }
 }
 
@@ -378,9 +440,13 @@ mod test_tsheet {
 
     #[test]
     fn test_add() {
-      let mut given = TSheet{xs: vec![
+        let mut given = TSheet {
-         X{t: 1, x: "def".to_string(), tag: "abc".to_string()},
+            xs: vec![X {
-      ]};
+                t: 1,
+                x: "def".to_string(),
+                tag: "abc".to_string(),
+            }],
+        };
         given.add("ghi".to_string(), "".to_string(), 0);
         assert_eq!(given.xs.len(), 2);
         assert!(given.xs[1].t != 1);
@@ -390,15 +456,39 @@ mod test_tsheet {
 
     #[test]
     fn test_since_date() {
-      let given = TSheet{xs: vec![
+        let given = TSheet {
-         X{t: 1, x: "def".to_string(), tag: "abc".to_string()},
+            xs: vec![
-         X{t: 2, x: "ghi".to_string(), tag: "".to_string()},
+                X {
-         X{t: 3, x: "jkl".to_string(), tag: "".to_string()},
+                    t: 1,
-      ]};
+                    x: "def".to_string(),
-      let want = TSheet{xs: vec![
+                    tag: "abc".to_string(),
-         X{t: 2, x: "ghi".to_string(), tag: "".to_string()},
+                },
-         X{t: 3, x: "jkl".to_string(), tag: "".to_string()},
+                X {
-      ]};
+                    t: 2,
+                    x: "ghi".to_string(),
+                    tag: "".to_string(),
+                },
+                X {
+                    t: 3,
+                    x: "jkl".to_string(),
+                    tag: "".to_string(),
+                },
+            ],
+        };
+        let want = TSheet {
+            xs: vec![
+                X {
+                    t: 2,
+                    x: "ghi".to_string(),
+                    tag: "".to_string(),
+                },
+                X {
+                    t: 3,
+                    x: "jkl".to_string(),
+                    tag: "".to_string(),
+                },
+            ],
+        };
         let got = given.since(UNIX_EPOCH.add(Duration::from_secs(2)));
         assert_eq!(got, want);
     }