Print sync_response instead of crashing

Cargo.toml

@@ -30,6 +30,7 @@ hostname = "0.3.1"
 json5 = "0.4.1"
 serde = { version = "1.0.188", features = ["derive"] }
 serde_json = "1.0.107"
+# TODO: switch to toml_edit to preserve (and write) doc comments
 
 # Error handling
 better-panic = "0.3.0"

src/app.rs

@@ -122,9 +122,11 @@ impl App {
     let sync_clients = self.clients.clone();
     let mut sync_results = FuturesUnordered::new();
     for client in sync_clients.iter() {
-      client.add_event_handler(|ev: matrix_sdk::ruma::events::room::message::SyncRoomMessageEvent| async move {
+      client.add_event_handler(
+        |ev: matrix_sdk::ruma::events::room::message::SyncRoomMessageEvent| async move {
           println!("Received a message {:?}", ev);
-      });
+        },
+      );
       let server_name = client.user_id().expect("missing user id").server_name();
       let mut sync_settings = matrix_sdk::config::SyncSettings::default();
       if server_name == "matrix.org" {
@@ -132,38 +134,37 @@ impl App {
         // let's quadruple the default
         sync_settings = sync_settings.timeout(std::time::Duration::from_secs(120));
       }
-      sync_results.push(client.sync_with_result_callback(
-        sync_settings,
-        |res| {
+      sync_results.push(client.sync_with_result_callback(sync_settings, |res| {
         let client2 = client.clone();
         async {
           let sync_response = res.expect("Failed sync");
-            println!("sync response {:?}", sync_response);
-            sync_responses_tx.send((client2, sync_response)).expect("could not send sync response");
+          sync_responses_tx
+            .send((client2, sync_response))
+            .expect("could not send sync response");
           if self.should_quit.load(Ordering::Acquire) {
             Ok(matrix_sdk::LoopCtrl::Break)
           } else {
             Ok(matrix_sdk::LoopCtrl::Continue)
           }
         }
-        },
-      ));
+      }));
     }
 
     loop {
       tokio::select! {
         e = tui.next() => {
           if let Some(e) = e {
-            self.handle_tui_event(&action_tx, e.clone())?;
+            self.handle_tui_event(&action_tx, e.clone()).context("Error while handling TUI event")?;
             for component in self.components.iter_mut() {
               if let Some(action) = component.handle_events(Some(e.clone()))? {
-                action_tx.send(action)?;
+                action_tx.send(action).context("Error while sending action from component")?;
               }
             }
           }
         }
         sync_response = sync_responses_rx.recv() => {
-          todo!("handle {:?}", sync_response);
+          let (client, sync_response) = sync_response.expect("sync_responses_rx unexpectedly closed");
+          self.handle_sync_response(&action_tx, client, sync_response).await.context("Error while handling sync response")?;
         }
         sync_result = sync_results.next() => {
           if !self.should_quit.load(Ordering::Acquire) {
@@ -268,4 +269,14 @@ impl App {
 
     Ok(())
   }
+
+  async fn handle_sync_response(
+    &self,
+    action_tx: &mpsc::UnboundedSender<Action>,
+    client: matrix_sdk::Client,
+    sync_response: matrix_sdk::deserialized_responses::SyncResponse,
+  ) -> Result<()> {
+    println!("{:?}", sync_response);
+    Ok(())
+  }
 }