feat: return Event from task state updates

src/main.rs

@@ -27,21 +27,21 @@ mod tasks;
 */
 
 static MY_KEYS: Lazy<Keys> = Lazy::new(|| Keys::generate());
-static CLIENT: Lazy<Client> = Lazy::new(|| Client::new(MY_KEYS.borrow().deref()));
 
 #[tokio::main]
 async fn main() {
     let proxy = Some(SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 9050)));
 
-    CLIENT.add_relay("ws://localhost:4736").await;
-    //CLIENT.add_relay("wss://relay.damus.io").await;
-    //CLIENT
+    let client = Client::new(MY_KEYS.borrow().deref());
+    client.add_relay("ws://localhost:4736").await;
+    //client.add_relay("wss://relay.damus.io").await;
+    //client
     //    .add_relay_with_opts(
     //        "wss://relay.nostr.info",
     //        RelayOptions::new().proxy(proxy).flags(RelayServiceFlags::default().remove(RelayServiceFlags::WRITE)),
     //    )
     //    .await?;
-    //CLIENT
+    //client
     //    .add_relay_with_opts(
     //        "ws://jgqaglhautb4k6e6i2g34jakxiemqp6z4wynlirltuukgkft2xuglmqd.onion",
     //        RelayOptions::new().proxy(proxy),
@@ -58,38 +58,20 @@ async fn main() {
     //    .lud16("yuki@getalby.com")
     //    .custom_field("custom_field", "my value");
 
-    //CLIENT.set_metadata(&metadata).await?;
+    //client.set_metadata(&metadata).await?;
 
-    CLIENT.connect().await;
+    client.connect().await;
 
-    repl().await;
-
-}
-
-fn make_task(text: &str, tags: &[Tag]) -> Event {
-    make_event(Kind::from(1621), text, tags)
-}
-fn make_event(kind: Kind, text: &str, tags: &[Tag]) -> Event {
-    EventBuilder::new(kind, text, tags.to_vec())
-        .to_event(&MY_KEYS)
-        .unwrap()
-}
-
-fn print_event(event: &Event) {
-    println!("At {} found {} kind {} '{}' {:?}", event.created_at, event.id, event.kind, event.content, event.tags);
-}
-
-async fn repl() {
     let mut tasks: Tasks = Default::default();
     for argument in args().skip(1) {
         tasks.add_task(make_task(&argument, &[Tag::Hashtag("arg".to_string())]));
     }
 
-    let sub_id: SubscriptionId = CLIENT.subscribe(vec![Filter::new()], None).await;
-    let mut notifications = CLIENT.notifications();
+    let sub_id: SubscriptionId = client.subscribe(vec![Filter::new()], None).await;
+    let mut notifications = client.notifications();
 
     println!("Finding existing events");
-    let res = CLIENT
+    let res = client
         .get_events_of(vec![Filter::new()], None)
         .map_ok(|res| {
             println!("Found {} events", res.len());
@@ -217,7 +199,7 @@ async fn repl() {
     println!();
     println!("Submitting events");
     // TODO send via message passing
-    let _ = CLIENT
+    let _ = client
         .batch_event(
             tasks
                 .tasks
@@ -232,3 +214,16 @@ async fn repl() {
         )
         .await;
 }
+
+fn make_task(text: &str, tags: &[Tag]) -> Event {
+    make_event(Kind::from(1621), text, tags)
+}
+fn make_event(kind: Kind, text: &str, tags: &[Tag]) -> Event {
+    EventBuilder::new(kind, text, tags.to_vec())
+        .to_event(&MY_KEYS)
+        .unwrap()
+}
+
+fn print_event(event: &Event) {
+    println!("At {} found {} kind {} '{}' {:?}", event.created_at, event.id, event.kind, event.content, event.tags);
+}

src/task.rs

@@ -65,12 +65,14 @@ impl Task {
         self.state().map_or(State::Open, |s| s.state)
     }
 
-    pub(crate) fn update_state(&mut self, state: State, comment: &str) {
-        self.props.push(make_event(
+    pub(crate) fn update_state(&mut self, state: State, comment: &str) -> Event {
+        let event = make_event(
             state.kind(),
             comment,
             &[Tag::event(self.event.id)],
-        ))
+        );
+        self.props.push(event.clone());
+        event
     }
 
     fn default_state(&self) -> TaskState {

src/tasks.rs

@@ -178,24 +178,24 @@ impl Tasks {
         }
     }
 
-    pub(crate) fn update_state_for<F>(&mut self, id: &EventId, comment: &str, f: F)
+    pub(crate) fn update_state_for<F>(&mut self, id: &EventId, comment: &str, f: F) -> Option<Event>
     where
         F: FnOnce(&Task) -> Option<State>,
     {
-        self.tasks.get_mut(id).map(|t| {
+        self.tasks.get_mut(id).and_then(|t| {
             f(t).map(|s| {
-                t.update_state(s, comment);
+                t.update_state(s, comment)
+            })
         })
-        });
     }
 
-    pub(crate) fn update_state<F>(&mut self, comment: &str, f: F)
+    pub(crate) fn update_state<F>(&mut self, comment: &str, f: F) -> Option<Event>
     where
         F: FnOnce(&Task) -> Option<State>,
     {
-        self.position.inspect(|id| {
-            self.update_state_for(id, comment, f);
-        });
+        self.position.and_then(|id| {
+            self.update_state_for(&id, comment, f)
+        })
     }
 }