feat(helpers): parse HHMM timestamps

src/helpers.rs

@@ -1,5 +1,3 @@
-use std::ops::Sub;
-
 use chrono::LocalResult::Single;
 use chrono::{DateTime, Local, NaiveTime, TimeDelta, TimeZone, Utc};
 use log::{debug, error, info, trace, warn};
@@ -34,16 +32,24 @@ impl<T: TimeZone> ToTimestamp for DateTime<T> {
     }
 }
 
-/// Parses the hour from a plain number in the String,
+
+/// Parses the hour optionally with minute from a plain number in a String,
 /// with max of max_future hours into the future.
-// TODO parse HHMM as well
 pub fn parse_hour(str: &str, max_future: i64) -> Option<DateTime<Local>> {
-    str.parse::<u32>().ok().and_then(|hour| {
-        let now = Local::now();
+    parse_hour_after(str, Local::now() - TimeDelta::hours(24 - max_future))
+}
+
+/// Parses the hour optionally with minute from a plain number in a String.
+pub fn parse_hour_after<T: TimeZone>(str: &str, after: DateTime<T>) -> Option<DateTime<T>> {
+    str.parse::<u32>().ok().and_then(|number| {
         #[allow(deprecated)]
-        now.date().and_hms_opt(hour, 0, 0).map(|time| {
-            if time - now > TimeDelta::hours(max_future) {
-                time.sub(TimeDelta::days(1))
+        after.date().and_hms_opt(
+            if number > 23 { number / 100 } else { number },
+            if number > 23 { number % 100 } else { 0 },
+            0,
+        ).map(|time| {
+            if time < after {
+                time + TimeDelta::days(1)
             } else {
                 time
             }
@@ -160,3 +166,41 @@ pub fn format_timestamp_relative_to(stamp: &Timestamp, reference: &Timestamp) ->
         _ => format_timestamp_local(stamp),
     }
 }
+
+mod test {
+    use super::*;
+    use chrono::{NaiveDate, NaiveDateTime, Timelike};
+    use interim::datetime::DateTime;
+
+    #[test]
+    fn parse_hours() {
+        let now = Local::now();
+        #[allow(deprecated)]
+        let date = now.date();
+        if now.hour() > 2 {
+            assert_eq!(
+                parse_hour("23", 22).unwrap(),
+                date.and_hms_opt(23, 0, 0).unwrap()
+            );
+        }
+        if now.hour() < 22 {
+            assert_eq!(
+                parse_hour("02", 2).unwrap(),
+                date.and_hms_opt(2, 0, 0).unwrap()
+            );
+            assert_eq!(
+                parse_hour("2301", 1).unwrap(),
+                (date - TimeDelta::days(1)).and_hms_opt(23, 01, 0).unwrap()
+            );
+        }
+
+        let date = NaiveDate::from_ymd_opt(2020, 10, 10).unwrap();
+        let time = Utc.from_utc_datetime(
+            &date.and_hms_opt(10, 1,0).unwrap()
+        );
+        assert_eq!(parse_hour_after("2201", time).unwrap(), Utc.from_utc_datetime(&date.and_hms_opt(22, 1, 0).unwrap()));
+        assert_eq!(parse_hour_after("10", time).unwrap(), Utc.from_utc_datetime(&(date + TimeDelta::days(1)).and_hms_opt(10, 0, 0).unwrap()));
+
+        // TODO test timezone offset issues
+    }
+}

src/main.rs

@@ -631,32 +631,17 @@ async fn main() -> Result<()> {
                                         Err(e) => warn!("Ignoring extra {:?}: {}\nSyntax: ((INT", remaining, e),
                                     }
                                 }
-                                let (label, times) = tasks.times_tracked();
-                                let vec = times.rev().take(max).collect_vec();
-                                println!("{}\n{}",
-                                         if vec.is_empty() {
-                                             label
-                                         } else {
-                                             format!("{} {}",
-                                                     if max == usize::MAX { "All".to_string() } else { format!("Latest {max} entries of") },
-                                                     label)
-                                         }.italic(),
-                                         vec.iter().rev().join("\n"));
+                                println!("{}", tasks.times_tracked(max));
                             } else if let Some((key, _)) = tasks.find_user(arg) {
                                 let (label, mut times) = tasks.times_tracked_for(&key);
-                                println!("{}\n{}", label.italic(),
-                                         times.join("\n"));
+                                println!("{}\n{}", label.italic(), times.join("\n"));
                             } else {
                                 if tasks.track_from(arg) {
-                                    let (label, times) = tasks.times_tracked();
-                                    println!("{}\n{}", label.italic(),
-                                             times.rev().take(15).collect_vec().iter().rev().join("\n"));
+                                    println!("{}", tasks.times_tracked(15));
                                 }
                             }
                         } else {
-                            let (label, times) = tasks.times_tracked();
-                            println!("{}\n{}", label.italic(),
-                                     times.rev().take(80).collect_vec().iter().rev().join("\n"));
+                            println!("{}", tasks.times_tracked(60));
                         }
                         continue 'repl;
                     }
@@ -666,9 +651,7 @@ async fn main() -> Result<()> {
                             None => tasks.move_to(None),
                             Some(arg) => {
                                 if parse_tracking_stamp(arg).and_then(|stamp| tasks.track_at(stamp, None)).is_some() {
-                                    let (label, times) = tasks.times_tracked();
-                                    println!("{}\n{}", label.italic(),
-                                             times.rev().take(15).collect_vec().iter().rev().join("\n"));
+                                    println!("{}", tasks.times_tracked(15));
                                 }
                                 // So the error message is not covered up
                                 continue 'repl;

src/tasks.rs

@@ -269,8 +269,20 @@ impl TasksRelay {
     }
 
     /// Dynamic time tracking overview for current task or current user.
-    pub(crate) fn times_tracked(&self) -> (String, Box<dyn DoubleEndedIterator<Item=String> + '_>) {
-        self.times_tracked_with(&self.sender.pubkey())
+    pub(crate) fn times_tracked(&self, limit: usize) -> String {
+        let (label, times) = self.times_tracked_with(&self.sender.pubkey());
+        let times = times.collect_vec();
+        format!("{}\n{}",
+                if times.is_empty() {
+                    label
+                } else {
+                    format!("{}{}",
+                            if limit > times.len() || limit == usize::MAX { "All ".to_string() }
+                            else if limit < 20 { "Recent ".to_string() }
+                            else { format!("Latest {limit} Entries of ") },
+                            label)
+                }.italic(),
+                &times[times.len().saturating_sub(limit)..].join("\n"))
     }
 
     pub(crate) fn history_for(
@@ -318,6 +330,8 @@ impl TasksRelay {
         }
     }
 
+    /// Time tracked for current position or key
+    /// Note: reversing the iterator skips most recent timetracking stops
     pub(crate) fn times_tracked_with(
         &self,
         key: &PublicKey,
@@ -1454,10 +1468,7 @@ impl Display for TasksRelay {
             if self.tasks.children_for(self.get_position()).next().is_some() {
                 writeln!(lock, "No tasks here matching{}", self.get_prompt_suffix())?;
             }
-            let (label, times) = self.times_tracked();
-            let mut times_recent = times.rev().take(6).collect_vec();
-            times_recent.reverse();
-            writeln!(lock, "{}\n{}", format!("Recent {}", label).italic(), times_recent.join("\n"))?;
+            writeln!(lock, "{}", self.times_tracked(6))?;
             return Ok(());
         }
 

src/tasks/tests.rs

@@ -281,6 +281,20 @@ fn test_filter_or_create() {
     assert_eq!(tasks.len(), 3);
 }
 
+#[test]
+fn test_history() {
+    let mut tasks = stub_tasks();
+    let zero = EventId::all_zeros();
+
+    tasks.track_at(Timestamp::now() - 3, Some(zero));
+    tasks.move_to(None);
+    assert_eq!(tasks.times_tracked(1).len(), 121);
+    let all = tasks.times_tracked(10);
+    assert_eq!(all.len(), 202, "{}", all);
+    assert!(all.contains(" 0000000000000000000000000000000000000000000000000000000000000000"), "{}", all);
+    assert!(all.ends_with(" ---"), "{}", all);
+}
+
 #[test]
 fn test_tracking() {
     let mut tasks = stub_tasks();