Fix reading input

Wait for confirmation after sending a message to a thread.

Also, use unwrap() to crash and burn than using unwrap_or_default() when
message passing fails.

It's highly unlikely to happen and also trivial to the core logic. But
let's see the error when it does happen.

Fixes https://github.com/sayanarijit/xplr/issues/301

src/event_reader.rs

@@ -1,16 +1,34 @@
 use crate::app::Task;
 use crate::app::{ExternalMsg, InternalMsg, MsgIn};
 use crate::input::Key;
+use anyhow::Result;
 use crossterm::event::{self, Event, MouseEventKind};
 use std::sync::mpsc::{Receiver, Sender};
 use std::thread;
 
-pub fn keep_reading(tx_msg_in: Sender<Task>, rx_event_reader: Receiver<bool>) {
+pub fn pause_reading(tx_event_reader: &Sender<bool>, rx_loop_waiter: &Receiver<()>) -> Result<()> {
+    tx_event_reader.send(true)?;
+    rx_loop_waiter.recv()?;
+    Ok(())
+}
+
+pub fn resume_reading(tx_event_reader: &Sender<bool>, rx_loop_waiter: &Receiver<()>) -> Result<()> {
+    tx_event_reader.send(false)?;
+    rx_loop_waiter.recv()?;
+    Ok(())
+}
+
+pub fn keep_reading(
+    tx_msg_in: Sender<Task>,
+    rx_event_reader: Receiver<bool>,
+    tx_loop_waiter: Sender<()>,
+) {
     thread::spawn(move || {
         let mut is_paused = false;
         loop {
             if let Ok(paused) = rx_event_reader.try_recv() {
                 is_paused = paused;
+                tx_loop_waiter.send(()).unwrap();
             };
 
             if is_paused {
@@ -23,27 +41,25 @@ pub fn keep_reading(tx_msg_in: Sender<Task>, rx_event_reader: Receiver<bool>) {
                     Ok(Event::Key(key)) => {
                         let key = Key::from_event(key);
                         let msg = MsgIn::Internal(InternalMsg::HandleKey(key));
-                        tx_msg_in
-                            .send(Task::new(msg, Some(key)))
-                            .unwrap_or_default();
+                        tx_msg_in.send(Task::new(msg, Some(key))).unwrap();
                     }
 
                     Ok(Event::Mouse(evt)) => match evt.kind {
                         MouseEventKind::ScrollUp => {
                             let msg = MsgIn::External(ExternalMsg::FocusPrevious);
-                            tx_msg_in.send(Task::new(msg, None)).unwrap_or_default();
+                            tx_msg_in.send(Task::new(msg, None)).unwrap();
                         }
 
                         MouseEventKind::ScrollDown => {
                             let msg = MsgIn::External(ExternalMsg::FocusNext);
-                            tx_msg_in.send(Task::new(msg, None)).unwrap_or_default();
+                            tx_msg_in.send(Task::new(msg, None)).unwrap();
                         }
                         _ => {}
                     },
 
                     Ok(Event::Resize(_, _)) => {
                         let msg = MsgIn::External(ExternalMsg::Refresh);
-                        tx_msg_in.send(Task::new(msg, None)).unwrap_or_default();
+                        tx_msg_in.send(Task::new(msg, None)).unwrap();
                     }
 
                     Err(e) => {
@@ -52,7 +68,7 @@ pub fn keep_reading(tx_msg_in: Sender<Task>, rx_event_reader: Receiver<bool>) {
                                 MsgIn::External(ExternalMsg::LogError(e.to_string())),
                                 None,
                             ))
-                            .unwrap_or_default();
+                            .unwrap();
                     }
                 }
             }

src/explorer.rs

@@ -61,7 +61,7 @@ pub(crate) fn explore_async(
                         MsgIn::Internal(InternalMsg::SetDirectory(buf)),
                         None,
                     ))
-                    .unwrap_or_default();
+                    .unwrap();
             })
             .unwrap_or_else(|e| {
                 tx_msg_in
@@ -69,7 +69,7 @@ pub(crate) fn explore_async(
                         MsgIn::External(ExternalMsg::LogError(e.to_string())),
                         None,
                     ))
-                    .unwrap_or_default();
+                    .unwrap();
             })
     });
 }

src/pwd_watcher.rs

@@ -23,7 +23,7 @@ pub fn keep_watching(
                 .map(|modified| {
                     if modified != last_modified {
                         let msg = MsgIn::External(ExternalMsg::ExplorePwdAsync);
-                        tx_msg_in.send(Task::new(msg, None)).unwrap_or_default();
+                        tx_msg_in.send(Task::new(msg, None)).unwrap();
                         last_modified = modified;
                     } else {
                         thread::sleep(Duration::from_secs(1));
@@ -31,7 +31,7 @@ pub fn keep_watching(
                 })
                 .unwrap_or_else(|e| {
                     let msg = MsgIn::External(ExternalMsg::LogError(e.to_string()));
-                    tx_msg_in.send(Task::new(msg, None)).unwrap_or_default();
+                    tx_msg_in.send(Task::new(msg, None)).unwrap();
                     thread::sleep(Duration::from_secs(1));
                 })
         }

src/runner.rs

@@ -147,6 +147,7 @@ impl Runner {
 
         let (tx_msg_in, rx_msg_in) = mpsc::channel();
         let (tx_event_reader, rx_event_reader) = mpsc::channel();
+        let (tx_loop_waiter, rx_loop_waiter) = mpsc::channel();
         let (tx_pwd_watcher, rx_pwd_watcher) = mpsc::channel();
 
         app = app.explore_pwd()?;
@@ -207,7 +208,7 @@ impl Runner {
         terminal.hide_cursor()?;
 
         // Threads
-        event_reader::keep_reading(tx_msg_in.clone(), rx_event_reader);
+        event_reader::keep_reading(tx_msg_in.clone(), rx_event_reader, tx_loop_waiter);
         pwd_watcher::keep_watching(app.pwd(), tx_msg_in.clone(), rx_pwd_watcher)?;
 
         // Enqueue on_load messages
@@ -381,7 +382,7 @@ impl Runner {
                             }
 
                             CallLuaSilently(func) => {
-                                tx_event_reader.send(true)?;
+                                event_reader::pause_reading(&tx_event_reader, &rx_loop_waiter)?;
 
                                 match call_lua(&app, &lua, &func, false) {
                                     Ok(Some(msgs)) => {
@@ -398,11 +399,11 @@ impl Runner {
                                     }
                                 };
 
-                                tx_event_reader.send(false)?;
+                                event_reader::resume_reading(&tx_event_reader, &rx_loop_waiter)?;
                             }
 
                             CallSilently(cmd) => {
-                                tx_event_reader.send(true)?;
+                                event_reader::pause_reading(&tx_event_reader, &rx_loop_waiter)?;
 
                                 app.write_pipes()?;
                                 let status = call(&app, cmd, true)
@@ -435,14 +436,14 @@ impl Runner {
                                     app = app.log_error(e.to_string())?;
                                 };
 
-                                tx_event_reader.send(false)?;
+                                event_reader::resume_reading(&tx_event_reader, &rx_loop_waiter)?;
                             }
 
                             CallLua(func) => {
                                 execute!(terminal.backend_mut(), event::DisableMouseCapture)
                                     .unwrap_or_default();
 
-                                tx_event_reader.send(true)?;
+                                event_reader::pause_reading(&tx_event_reader, &rx_loop_waiter)?;
 
                                 terminal.clear()?;
                                 terminal.set_cursor(0, 0)?;
@@ -467,7 +468,7 @@ impl Runner {
                                 terminal.clear()?;
                                 term::enable_raw_mode()?;
                                 terminal.hide_cursor()?;
-                                tx_event_reader.send(false)?;
+                                event_reader::resume_reading(&tx_event_reader, &rx_loop_waiter)?;
 
                                 if mouse_enabled {
                                     match execute!(
@@ -488,7 +489,7 @@ impl Runner {
                                 execute!(terminal.backend_mut(), event::DisableMouseCapture)
                                     .unwrap_or_default();
 
-                                tx_event_reader.send(true)?;
+                                event_reader::pause_reading(&tx_event_reader, &rx_loop_waiter)?;
 
                                 terminal.clear()?;
                                 terminal.set_cursor(0, 0)?;
@@ -529,7 +530,7 @@ impl Runner {
                                 terminal.clear()?;
                                 term::enable_raw_mode()?;
                                 terminal.hide_cursor()?;
-                                tx_event_reader.send(false)?;
+                                event_reader::resume_reading(&tx_event_reader, &rx_loop_waiter)?;
 
                                 if mouse_enabled {
                                     match execute!(