use command queues

Cargo.toml

@@ -4,7 +4,7 @@ edition = "2021"
 version = "0.1.0"
 
 [dependencies]
-futures = { default-features = false, version = "0.3" }
+futures = { version = "0.3", default-features = false }
 crossterm = { version = "0.26", default-features = false, features = ["event-stream"] }
 tokio = { version = "1.25", default-features = false, features = ["time", "macros", "rt"] }
 

src/main.rs

@@ -2,7 +2,7 @@ use std::io::{stdout, Stdout, Write};
 use std::process::Command;
 use std::time::Duration;
 
-use crossterm::cursor;
+use crossterm::{cursor, QueueableCommand};
 use crossterm::{
     cursor::MoveTo,
     event::{Event, EventStream, KeyCode, KeyModifiers},
@@ -15,36 +15,37 @@ use tokio::time::sleep;
 const ONE_SECOND: Duration = Duration::from_secs(1);
 
 #[tokio::main(flavor = "current_thread")]
-async fn main() {
+async fn main() -> Result<()> {
     let timer = Pomodoro::new();
 
     let timer_task = tokio::spawn(async move { timer.main_loop().await });
     let ui_task = tokio::spawn(async move { Ui::main_loop().await });
 
     tokio::select! (
-        _ = timer_task => (),
+        result = timer_task => result??,
-        _ = ui_task => (),
+        result = ui_task => result??,
     );
 
-    Ui::clear_terminal().unwrap();
+    Ui::clear_terminal()?;
+    Ok(())
 }
 
 struct Ui;
 
 impl Ui {
-    async fn main_loop() {
+    async fn main_loop() -> Result<()> {
         let mut reader = EventStream::new();
 
         loop {
-            enable_raw_mode().unwrap();
+            enable_raw_mode()?;
-            stdout().execute(cursor::Hide).unwrap();
+            stdout().execute(cursor::Hide)?;
 
             if let Some(Ok(Event::Key(key_event))) = reader.next().await {
                 if Self::is_char_q(key_event) || Self::is_ctrl_c(&key_event) {
-                    disable_raw_mode().unwrap();
+                    disable_raw_mode()?;
-                    stdout().execute(cursor::Show).unwrap();
+                    stdout().execute(cursor::Show)?;
 
-                    return;
+                    return Ok(());
                 }
             }
         }
@@ -60,9 +61,10 @@ impl Ui {
 
     fn clear_terminal() -> Result<()> {
         let mut stdout = stdout();
-        stdout.execute(terminal::Clear(terminal::ClearType::All))?;
+        stdout.queue(terminal::Clear(terminal::ClearType::All))?;
-        stdout.execute(terminal::Clear(terminal::ClearType::Purge))?;
+        stdout.queue(terminal::Clear(terminal::ClearType::Purge))?;
-        stdout.execute(MoveTo(0, 0))?;
+        stdout.queue(MoveTo(0, 0))?;
+        stdout.flush()?;
         Ok(())
     }
 }
@@ -97,7 +99,7 @@ impl Pomodoro {
             self.interval_idx + 1,
             self.intervals.len()
         )?;
-        self.stdout.execute(MoveTo(0, 1))?;
+        self.stdout.queue(MoveTo(0, 1))?;
         write!(self.stdout, "remaining: {}", format(self.remaining))?;
         self.stdout.flush()?;
         Ok(())