src/main.rs

@@ -417,8 +417,8 @@ async fn main() -> Result<()> {
                                 }
                             }
                             Some(arg) => {
-                                if arg.trim().len() < 2 {
-                                    warn!("Needs at least 2 characters!");
+                                if arg.len() < CHARACTER_THRESHOLD {
+                                    warn!("Note needs at least {CHARACTER_THRESHOLD} characters!");
                                     continue 'repl;
                                 }
                                 tasks.make_note(arg);

src/task.rs

@@ -135,15 +135,16 @@ impl Task {
         })
     }
 
-    pub fn last_state_update(&self) -> Timestamp {
+    pub(crate) fn last_state_update(&self) -> Timestamp {
         self.state().map(|s| s.time).unwrap_or(self.event.created_at)
     }
-    
-    pub fn state_at(&self, time: Timestamp) -> Option<TaskState> {
+
+    pub(crate) fn state(&self) -> Option<TaskState> {
+        let now = now();
         // TODO do not iterate constructed state objects
-        let state = self.states().take_while_inclusive(|ts| ts.time > time);
+        let state = self.states().take_while_inclusive(|ts| ts.time > now);
         state.last().map(|ts| {
-            if ts.time <= time {
+            if ts.time <= now {
                 ts
             } else {
                 self.default_state()
@@ -151,12 +152,6 @@ impl Task {
         })
     }
 
-    /// Returns the current state if this is a task rather than an activity
-    pub fn state(&self) -> Option<TaskState> {
-        let now = now();
-        self.state_at(now)
-    }
-
     pub(crate) fn pure_state(&self) -> State {
         self.state().map_or(State::Open, |s| s.state)
     }
@@ -237,7 +232,6 @@ impl Task {
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub(crate) struct TaskState {
     pub(crate) state: State,
     name: Option<String>,
@@ -273,7 +267,7 @@ impl Display for TaskState {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[derive(Debug, Copy, Clone, PartialEq, Ord, PartialOrd, Eq)]
 pub(crate) enum State {
     /// Actionable
     Open = 1630,
@@ -362,33 +356,20 @@ mod tasks_test {
                 .sign_with_keys(&keys).unwrap());
         assert_eq!(task.pure_state(), State::Open);
         assert_eq!(task.list_hashtags().count(), 1);
-        
-        let now = Timestamp::now();
         task.props.insert(
             EventBuilder::new(State::Done.into(), "")
-                .custom_created_at(now)
                 .sign_with_keys(&keys).unwrap());
         assert_eq!(task.pure_state(), State::Done);
         task.props.insert(
-            EventBuilder::new(State::Open.into(), "Ready").tags([Tag::hashtag("tag2")])
-                .custom_created_at(now - 2)
+            EventBuilder::new(State::Open.into(), "").tags([Tag::hashtag("tag2")])
+                .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(now + 9)
+                .custom_created_at(Timestamp::now() + 1)
                 .sign_with_keys(&keys).unwrap());
         assert_eq!(task.pure_state(), State::Closed);
-        assert_eq!(task.state_at(now), Some(TaskState {
-            state: State::Done,
-            name: None,
-            time: now,
-        }));
-        assert_eq!(task.state_at(now - 1), Some(TaskState {
-            state: State::Open,
-            name: Some("Ready".to_string()),
-            time: now - 2,
-        }));
     }
 }

src/tasks.rs

@@ -1316,8 +1316,9 @@ impl TasksRelay {
         let (name, tags) = extract_tags(note.trim());
         let format = format!("\"{name}\" with tags [{}]", join_tags(&tags));
         let mut prop =
-            EventBuilder::new(Kind::TextNote, name)
-                .tags(tags);
+            EventBuilder::new(Kind::TextNote, name).tags(tags);
+        //.filter(|id| self.get_by_id(id).is_some_and(|t| t.is_task()))
+        //.map(|id| 
         let marker =
             if self.get_current_task().is_some_and(|t| t.is_task()) {
                 MARKER_PROPERTY