release: 0.6.3 - enhance quick access

Cargo.lock

@@ -1488,7 +1488,7 @@ dependencies = [
 
 [[package]]
 name = "mostr"
-version = "0.6.2"
+version = "0.6.3"
 dependencies = [
  "chrono",
  "chrono-english",

Cargo.toml

@@ -5,7 +5,7 @@ repository  = "https://forge.ftt.gmbh/janek/mostr"
 readme = "README.md"
 license = "GPL 3.0"
 authors = ["melonion"]
-version = "0.6.2"
+version = "0.6.3"
 rust-version = "1.82"
 edition = "2021"
 default-run = "mostr"

src/event_sender.rs

@@ -65,7 +65,7 @@ impl EventSender {
         })?)
     }
     /// Sends all pending events
-    fn force_flush(&self) {
+    pub(crate) fn force_flush(&self) {
         debug!("Flushing {} events from queue", self.queue.borrow().len());
         let values = self.clear();
         self.url.as_ref().map(|url| {

src/helpers.rs

@@ -36,6 +36,7 @@ impl<T: TimeZone> ToTimestamp for DateTime<T> {
 
 /// Parses the hour from a plain number in the 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();

src/kinds.rs

@@ -1,7 +1,7 @@
 use crate::task::MARKER_PARENT;
 use crate::tasks::HIGH_PRIO;
 use itertools::Itertools;
-use nostr_sdk::{Alphabet, EventBuilder, EventId, Kind, Tag, TagKind, TagStandard};
+use nostr_sdk::{EventBuilder, EventId, Kind, Tag, TagKind, TagStandard};
 use std::borrow::Cow;
 
 pub const TASK_KIND: Kind = Kind::GitIssue;

src/task.rs

@@ -175,7 +175,7 @@ impl Task {
         }
     }
 
-    pub(crate) fn list_hashtags(&self) -> impl Iterator<Item=Hashtag> + use<'_> {
+    pub(crate) fn list_hashtags(&self) -> impl Iterator<Item=Hashtag> + '_ {
         self.tags().filter_map(|t| Hashtag::try_from(t).ok())
     }
 
@@ -362,13 +362,13 @@ mod tasks_test {
         assert_eq!(task.pure_state(), State::Done);
         task.props.insert(
             EventBuilder::new(State::Open.into(), "").tags([Tag::hashtag("tag2")])
-                .custom_created_at(Timestamp::from(Timestamp::now() - 2))
+                .custom_created_at(Timestamp::now() - 2)
                 .sign_with_keys(&keys).unwrap());
         assert_eq!(task.pure_state(), State::Done);
         assert_eq!(task.list_hashtags().count(), 2);
         task.props.insert(
             EventBuilder::new(State::Closed.into(), "")
-                .custom_created_at(Timestamp::from(Timestamp::now() + 1))
+                .custom_created_at(Timestamp::now() + 1)
                 .sign_with_keys(&keys).unwrap());
         assert_eq!(task.pure_state(), State::Closed);
     }

src/tasks.rs

@@ -13,11 +13,12 @@ use crate::task::{State, Task, TaskState, MARKER_DEPENDS, MARKER_PARENT, MARKER_
 use colored::Colorize;
 use itertools::Itertools;
 use log::{debug, error, info, trace, warn};
-use nostr_sdk::{Alphabet, Event, EventBuilder, EventId, JsonUtil, Keys, Kind, Metadata, PublicKey, SingleLetterTag, Tag, TagKind, TagStandard, Timestamp, Url};
+use nostr_sdk::{Alphabet, Event, EventBuilder, EventId, JsonUtil, Keys, Kind, Metadata, PublicKey, SingleLetterTag, Tag, TagKind, Timestamp, Url};
 use regex::bytes::Regex;
 use tokio::sync::mpsc::Sender;
 
 const DEFAULT_PRIO: Prio = 25;
+const QUICK_PRIO: Prio = 35;
 pub const HIGH_PRIO: Prio = 85;
 
 /// Amount of seconds to treat as "now"
@@ -93,6 +94,10 @@ pub(crate) enum StateFilter {
     State(String),
 }
 impl StateFilter {
+    fn from(str: &str) -> Self {
+        StateFilter::State(str.to_string())
+    }
+
     fn indicator(&self) -> String {
         match self {
             StateFilter::Default => "".to_string(),
@@ -398,7 +403,7 @@ impl TasksRelay {
             prompt.push_str(&format!(" -#{}", tag));
         }
         prompt.push_str(&self.state.indicator());
-        self.priority.map(|p| 
+        self.priority.map(|p|
             prompt.push_str(&format!(" *{:02}", p)));
         prompt
     }
@@ -489,7 +494,7 @@ impl TasksRelay {
 
     fn filter(&self, task: &Task) -> bool {
         self.state.matches(task) &&
-            self.pubkey.is_none_or(|p| p == task.event.pubkey) &&
+            (!!task.is_task() || self.pubkey.is_none_or(|p| p == task.event.pubkey)) &&
             self.priority.is_none_or(|prio| {
                 task.priority().unwrap_or(DEFAULT_PRIO) >= prio
             }) &&
@@ -500,7 +505,7 @@ impl TasksRelay {
             })
     }
 
-    // TODO sparse is deprecated
+    // TODO sparse is deprecated and only left for tests
     pub(crate) fn filtered_tasks(
         &self,
         position: Option<EventId>,
@@ -562,30 +567,35 @@ impl TasksRelay {
                 self.search_depth + self.view_depth,
             )
         } else {
-            self.resolve_tasks_rec(view.into_iter(), true, self.view_depth)
+            self.resolve_tasks_rec(view.into_iter(), true, self.view_depth + 1)
         }
     }
 
+    fn quick_access_raw(&self) -> impl Iterator<Item=&EventId> {
+        // TODO add recent tasks (most time tracked + recently created)
+        self.bookmarks.iter()
+            .chain(
+                // Latest
+                self.tasks.values()
+                    .sorted_unstable()
+                    .take(3).map(|t| t.get_id()))
+            .chain(
+                // Highest Prio
+                self.tasks.values()
+                    .filter_map(|t| t.priority().filter(|p| *p >= QUICK_PRIO)
+                        .map(|p| (p, t)))
+                    .sorted_unstable().rev()
+                    .take(3).map(|(_, t)| t.get_id())
+            )
+    }
+
     fn bookmarked_tasks_deduped(&self, visible: &[&Task]) -> impl Iterator<Item=&Task> {
         let tree = visible.iter()
             .flat_map(|task| self.traverse_up_from(Some(task.event.id)))
             .unique();
         let pos = self.get_position();
         let ids: HashSet<&EventId> = tree.map(|t| t.get_id()).chain(pos.as_ref()).collect();
-        // TODO add recent tasks (most time tracked + recently created)
-        self.bookmarks.iter()
-            .chain(
-                // Latest
-                self.tasks.values()
-                    .sorted_unstable().rev()
-                    .take(3).map(|t| t.get_id()))
-            .chain(
-                // Highest Prio
-                self.tasks.values()
-                    .filter_map(|t| t.priority().filter(|p| *p > 35).map(|p| (p, t)))
-                    .sorted_unstable()
-                    .take(3).map(|(_, t)| t.get_id())
-            )
+        self.quick_access_raw()
             .filter(|id| !ids.contains(id))
             .filter_map(|id| self.get_by_id(id))
             .filter(|t| self.filter(t))
@@ -767,6 +777,7 @@ impl TasksRelay {
     pub(crate) fn clear_filters(&mut self) {
         self.state = StateFilter::Default;
         self.pubkey = Some(self.sender.pubkey());
+        self.priority = None;
         self.view.clear();
         self.tags.clear();
         self.tags_excluded.clear();
@@ -844,7 +855,7 @@ impl TasksRelay {
     }
 
     pub(crate) fn flush(&self) {
-        self.sender.flush();
+        self.sender.force_flush();
     }
 
     /// Returns ids of tasks matching the given string.
@@ -944,7 +955,7 @@ impl TasksRelay {
         let pos = self.get_position();
         if target == pos {
             debug!("Flushing Tasks because of move in place");
-            self.flush();
+            self.sender.flush();
             return;
         }
 
@@ -953,7 +964,7 @@ impl TasksRelay {
             .is_some_and(|t| t.parent_id() == pos.as_ref())
         {
             debug!("Flushing Tasks because of move beyond child");
-            self.flush();
+            self.sender.flush();
         }
 
         let now = Timestamp::now();
@@ -966,7 +977,7 @@ impl TasksRelay {
         }
         self.submit(
             build_tracking(target)
-                .custom_created_at(Timestamp::from(now.as_u64() + offset)),
+                .custom_created_at(now + offset),
         );
     }
 
@@ -1014,7 +1025,7 @@ impl TasksRelay {
         })
     }
 
-    fn context_hashtags(&self) -> impl Iterator<Item=Tag> + use<'_> {
+    fn context_hashtags(&self) -> impl Iterator<Item=Tag> + '_ {
         self.tags.iter().map(Tag::from)
     }
 
@@ -1385,12 +1396,13 @@ impl Display for TasksRelay {
         let visible = self.viewed_tasks();
 
         if visible.is_empty() {
-            writeln!(lock, "No tasks here matching{}", self.get_prompt_suffix())?;
+            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();
-            // TODO Add recent prefix
-            writeln!(lock, "{}\n{}", label.italic(), times_recent.join("\n"))?;
+            writeln!(lock, "{}\n{}", format!("Recent {}", label).italic(), times_recent.join("\n"))?;
             return Ok(());
         }
 
@@ -1419,8 +1431,7 @@ impl Display for TasksRelay {
         for task in visible {
             writeln!(
                 lock,
-                "{}",
-                self.properties.iter()
+                "{}", self.properties.iter()
                     .map(|p| self.get_property(task, p.as_str()))
                     .join(" \t")
             )?;
@@ -1511,9 +1522,8 @@ pub(crate) fn join_tasks<'a>(
         })
 }
 
-fn referenced_events(event: &Event) -> impl Iterator<Item=EventId> + use < '_ > {
-event.tags.iter()
-.filter_map(| tag | match_event_tag(tag).map(| t | t.id))
+fn referenced_events(event: &Event) -> impl Iterator<Item=EventId> + '_ {
+    event.tags.iter().filter_map(|tag| match_event_tag(tag).map(|t| t.id))
 }
 
 fn referenced_event(event: &Event) -> Option<EventId> {
@@ -1773,30 +1783,32 @@ mod tasks_test {
 
     macro_rules! assert_tasks_visible {
         ($left:expr, $right:expr $(,)?) => {
-            assert_eq!(
-                $left
-                    .visible_tasks()
-                    .iter()
-                    .map(|t| t.event.id)
-                    .collect::<HashSet<EventId>>(),
-                HashSet::from($right)
-            )
+            let tasks = $left.visible_tasks();
+            assert_tasks!($left, tasks, $right,
+                "\nQuick Access: {:?}", $left.quick_access_raw().map(|id| $left.get_relative_path(*id)).collect_vec());
         };
     }
 
     macro_rules! assert_tasks_view {
         ($left:expr, $right:expr $(,)?) => {
             let tasks = $left.viewed_tasks();
+            assert_tasks!($left, tasks, $right, "");
+        };
+    }
+
+    macro_rules! assert_tasks {
+        ($left:expr, $tasks:expr, $right:expr $(, $($arg:tt)*)?) => {
             assert_eq!(
-                tasks
+                $tasks
                     .iter()
                     .map(|t| t.event.id)
                     .collect::<HashSet<EventId>>(),
-                HashSet::from($right),
-                "Tasks Visible: {:?}\nExpected: {:?}",
-                tasks,
-                $right.map(|id| $left.get_relative_path(id))
-            )
+                HashSet::from_iter($right.clone()),
+                "Tasks Visible: {:?}\nExpected: {:?}{}",
+                $tasks.iter().map(|t| t.event.id).map(|id| $left.get_relative_path(id)).collect_vec(),
+                $right.into_iter().map(|id| $left.get_relative_path(id)).collect_vec(),
+                format!($($($arg)*)?)
+            );
         };
     }
 
@@ -1833,21 +1845,54 @@ mod tasks_test {
         assert_eq!(tasks.get_prompt_suffix(), " #dp #yeah");
         tasks.remove_tag("Y");
         assert_eq!(tasks.tags, ["dp"].into_iter().map(Hashtag::from).collect());
+
         tasks.set_priority(Some(HIGH_PRIO));
         assert_eq!(tasks.get_prompt_suffix(), " #dp *85");
-        let id = tasks.make_task("test # tag");
-        let task1 = tasks.get_by_id(&id).unwrap();
-        assert_eq!(task1.priority(), Some(HIGH_PRIO));
+        let id_hp = tasks.make_task("high prio tagged # tag");
+        let hp = tasks.get_by_id(&id_hp).unwrap();
+        assert_eq!(hp.priority(), Some(HIGH_PRIO));
         assert_eq!(
-            task1.list_hashtags().collect_vec(),
+            hp.list_hashtags().collect_vec(),
             vec!["DP", "tag"].into_iter().map(Hashtag::from).collect_vec()
         );
+
+        tasks.state = StateFilter::from("WIP");
+        tasks.set_priority(Some(QUICK_PRIO));
+
         tasks.make_task_and_enter("another *4", State::Pending);
-        assert_eq!(tasks.get_current_task().unwrap().priority(), Some(40));
+        let task2 = tasks.get_current_task().unwrap();
+        assert_eq!(task2.priority(), Some(40));
+        assert_eq!(task2.pure_state(), State::Pending);
+        assert_eq!(task2.state().unwrap().get_label(), "Pending");
         tasks.make_note("*3");
         let task2 = tasks.get_current_task().unwrap();
         assert_eq!(task2.descriptions().next(), None);
         assert_eq!(task2.priority(), Some(30));
+        let anid = task2.event.id;
+
+        tasks.custom_time = Some(Timestamp::now() + 1);
+        let s1 = tasks.make_task("sub1");
+        tasks.custom_time = Some(Timestamp::now() + 2);
+        tasks.set_priority(Some(QUICK_PRIO + 1));
+        let s2 = tasks.make_task("sub2");
+        let s3 = tasks.make_task("sub3");
+        tasks.set_priority(Some(QUICK_PRIO));
+
+        assert_tasks_visible!(tasks, [s1, s2, s3]);
+        tasks.state = StateFilter::Default;
+        assert_tasks_view!(tasks, [s1, s2, s3]);
+        assert_tasks_visible!(tasks, [id_hp, s1, s2, s3]);
+        tasks.move_up();
+        tasks.set_search_depth(1);
+        assert_tasks_view!(tasks, [id_hp]);
+        assert_tasks_visible!(tasks, [s1, s2, s3, id_hp]);
+
+        tasks.set_priority(None);
+        let s4 = tasks.make_task_with("sub4", [tasks.make_event_tag_from_id(anid, MARKER_PARENT)], true);
+        assert_eq!(tasks.get_parent(Some(&s4)), Some(&anid));
+        assert_tasks_view!(tasks, [anid, id_hp]);
+        // s2-4 are newest while s2,s3,hp are highest prio
+        assert_tasks_visible!(tasks, [s4, s2, s3, anid, id_hp]);
 
         tasks.pubkey = Some(Keys::generate().public_key);
     }
@@ -1860,9 +1905,10 @@ mod tasks_test {
             EventBuilder::new(TASK_KIND, "sub")
                 .tags([tasks.make_event_tag_from_id(parent, MARKER_PARENT)])
         );
-        assert_eq!(tasks.viewed_tasks().len(), 1);
+        assert_tasks_view!(tasks, [parent]);
         tasks.track_at(Timestamp::now(), Some(sub));
         assert_eq!(tasks.get_own_events_history().count(), 1);
+        assert_tasks_view!(tasks, []);
 
         tasks.make_dependent_sibling("sibling");
         assert_eq!(tasks.len(), 3);
@@ -1913,10 +1959,15 @@ mod tasks_test {
         );
 
         tasks.submit(EventBuilder::new(Kind::Bookmarks, ""));
+        assert!(tasks.bookmarks.is_empty());
         tasks.clear_filters();
         assert_tasks_visible!(tasks, [pin, test]);
         tasks.set_view_depth(0);
-        assert_tasks_visible!(tasks, [test, parent]);
+        tasks.custom_time = Some(now());
+        let mut new = (0..3).map(|t| tasks.make_task(t.to_string().as_str())).collect_vec();
+        // Show the newest tasks in quick access and remove old pin
+        new.extend([test, parent]);
+        assert_tasks_visible!(tasks, new);
     }
 
     #[test]
@@ -2013,7 +2064,7 @@ mod tasks_test {
         let mut tasks = stub_tasks();
         let zero = EventId::all_zeros();
 
-        tasks.track_at(Timestamp::from(Timestamp::now().as_u64() + 100), Some(zero));
+        tasks.track_at(Timestamp::now() + 100, Some(zero));
         assert_eq!(
             timestamps(tasks.get_own_events_history(), &[zero])
                 .collect_vec()
@@ -2081,7 +2132,7 @@ mod tasks_test {
         assert_tasks_view!(tasks, [t11]);
         tasks.set_view_depth(1);
         assert_tasks_view!(tasks, [t111]);
-        tasks.set_search_depth(1); // resets view
+        tasks.set_search_depth(2); // resets view
         assert_tasks_view!(tasks, [t111, t12]);
         tasks.set_view_depth(0);
         assert_tasks_view!(tasks, [t11, t12]);