Clean up cmd_wrapper.rs

Author: nazmulidris

TODO

@@ -60,8 +60,11 @@
       ✔ figure out how to create VDOM like result -> CommandQueue @done(22-06-19 18:44)
       ✔ rename Draw -> Render @done(22-06-20 15:35)
       ✔ accomodate Render returning CommandQueue @done(22-06-20 15:35)
-      ☐ app.rs render the state using CommandQueue (and crossterm commands)
-      ☐ main_container.rs actually flush CommandQueue in MySubscriber
+      ✔ app.rs render the state using CommandQueue (and crossterm commands) @done(22-06-21 17:51)
+      ✔ main_container.rs actually flush CommandQueue in MySubscriber @done(22-06-2118:33)
+      ✔ do initial render in event loop @done(22-06-21 19:04)
+      ✔ fix bug in app.rs that doesn't capture first input_event @done(22-06-21 18:52)
+      ✔ fix the fix above (flaky) - flush both stdin & stdout @done(22-06-22 12:45)
       ☐ add layout from test_canvas.rs into app.rs
       ☐ add all the crossterm commands to Command
     focus mgmt:

log.fish

@@ -1,3 +1,5 @@
 #!/usr/bin/env fish
 clear
+rm log.txt
+touch log.txt
 tail -f log.txt | lolcat

src/crossterm_helpers/cmd_wrapper.rs

@@ -17,61 +17,63 @@
 
 use crate::*;
 use crossterm::{
-  cursor::{self},
+  cursor::{self, *},
   event::*,
-  queue,
+  style::{self, *},
   terminal::{self, *},
+  *,
 };
-use paste::paste;
 use r3bl_rs_utils::*;
-use std::io::{stdout, Write};
+use std::{
+  fmt::Display,
+  io::{stderr, stdout, Write},
+};
 
 /// Given a crossterm command, this will run it and [log!] the [Result] that is returned.
 /// If [log!] fails, then it will print a message to stderr.
 ///
 /// Paste docs: https://github.com/dtolnay/paste
 #[macro_export]
-macro_rules! try_to_run_crossterm_command_and_log_result {
-  ($cmd: expr, $name: expr) => {{
-    paste! {
-      // Generate a new function that returns [CommonResult].
-      let [<_ $name>] = || -> CommonResult<()> {
-        throws!({
-          if let Err(err) = $cmd {
-            log!(ERROR, "crossterm: ❌ Failed to {} due to {}", $name, err);
-          } else {
-            log!(INFO, "crossterm: ✅ {} successfully", $name);
-          }
-        })
-      };
+macro_rules! exec {
+  ($cmd: expr, $msg: expr) => {{
+    // Generate a new function that returns [CommonResult].
+    let _new_fn_name = || -> CommonResult<()> {
+      throws!({
+        if let Err(err) = $cmd {
+          log!(ERROR, "crossterm: ❌ Failed to {} due to {}", $msg, err);
+        } else {
+          log!(INFO, "crossterm: ✅ {} successfully", $msg);
+        }
+      })
+    };
 
-      // Call this generated function. It will fail if there are problems w/ log!().
-      // In this case, if DEBUG is true, then it will dump the error to stderr.
-      if let Err(err) = [<_ $name>]() {
-        let msg = format!("❌ Failed to {}", $name);
-        call_if_true!(DEBUG,
-          debug!(ERROR_RAW &msg, err)
-        );
-      }
+    // Call this generated function. It will fail if there are problems w/ log!().
+    // In this case, if DEBUG is true, then it will dump the error to stderr.
+    if let Err(err) = _new_fn_name() {
+      let msg = format!("❌ Failed to {}", $msg);
+      call_if_true!(DEBUG, debug!(ERROR_RAW & msg, err));
     }
   }};
 }
 
-/// This works together w/ [Command] to enqueue commands, and then flush them at the end.
-/// Here's an example.
+/// This works together w/ [Command] to enqueue commands, but not flush them. It will
+/// return a [CommandQueue]. Here's an example.
+///
 /// ```ignore
-/// queue_and_flush!(
+/// let mut queue = queue!(
 ///   Command::EnableRawMode,
 ///   Command::EnableMouseCapture,
 ///   Command::EnterAlternateScreen,
 ///   Command::ResetCursorPosition,
 ///   Command::ClearScreen
 /// );
 /// ```
-/// Decl macro docs: https://veykril.github.io/tlborm/decl-macros/macros-methodical.html#repetitions
+///
+/// Decl macro docs:
+/// - https://veykril.github.io/tlborm/decl-macros/macros-methodical.html#repetitions
 #[macro_export]
-macro_rules! queue_and_flush {
-  (
+macro_rules! tw_queue {
+    (
       // Start a repetition:
       $(
           // Each repeat must contain an expression...
@@ -92,14 +94,14 @@ macro_rules! queue_and_flush {
               // $element replaced with the corresponding expression.
               queue.add($element);
           )*
-          queue.flush();
+          queue
       }
   };
 }
 
 #[derive(Debug)]
 #[non_exhaustive]
-pub enum Command {
+pub enum TWCommand {
   EnableRawMode,
   EnableMouseCapture,
   EnterAlternateScreen,
@@ -108,6 +110,19 @@ pub enum Command {
   DisableMouseCapture,
   MoveCursorPosition(UnitType, UnitType),
   ClearScreen,
+  SetFgColor(Color),
+  SetBgColor(Color),
+  ResetColor,
+  Print(String),
+  CursorShow,
+  CursorHide,
+}
+
+impl TWCommand {
+  pub fn flush() {
+    exec!(stdout().flush(), "flush stdout");
+    exec!(stderr().flush(), "flush stderr");
+  }
 }
 
 /// This works w/ [Command] items. It allows them to be added in sequence, and then
@@ -123,58 +138,78 @@ pub enum Command {
 /// ```
 #[derive(Default, Debug)]
 pub struct CommandQueue {
-  pub queue: Vec<Command>,
+  pub queue: Vec<TWCommand>,
+}
+
+impl Display for CommandQueue {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    write!(f, "{:?}", self)
+  }
 }
 
 impl CommandQueue {
-  pub fn add(&mut self, cmd_wrapper: Command) {
+  pub fn add(&mut self, cmd_wrapper: TWCommand) {
     self.queue.push(cmd_wrapper);
   }
 
   pub fn flush(&mut self) {
-    for cmd_wrapper in &mut self.queue {
-      match cmd_wrapper {
-        Command::EnableRawMode => try_to_run_crossterm_command_and_log_result! {
-          terminal::enable_raw_mode(),
-          "enable_raw_mode"
-        },
-        Command::EnableMouseCapture => try_to_run_crossterm_command_and_log_result! {
-          queue!(stdout(), EnableMouseCapture),
-          "enable_mouse_capture"
-        },
-        Command::EnterAlternateScreen => try_to_run_crossterm_command_and_log_result! {
-          queue!(stdout(), EnterAlternateScreen),
-          "enter_alternate_screen"
-        },
-        Command::LeaveAlternateScreen => try_to_run_crossterm_command_and_log_result! {
-          queue!(stdout(), LeaveAlternateScreen),
-          "leave_alternate_screen"
-        },
-        Command::DisableRawMode => try_to_run_crossterm_command_and_log_result! {
-          terminal::disable_raw_mode(),
-          "disable_raw_mode"
-        },
-        Command::DisableMouseCapture => try_to_run_crossterm_command_and_log_result! {
-          queue!(stdout(), DisableMouseCapture) ,
-          "disable_mouse_mode"
-        },
-        Command::MoveCursorPosition(first, second) => {
-          let msg = format!("move_to: {}, {}", first, second);
-          try_to_run_crossterm_command_and_log_result! {
-            queue!(stdout(), cursor::MoveTo(*first, *second)),
-            msg
-          }
-        }
-        Command::ClearScreen => try_to_run_crossterm_command_and_log_result! {
-          queue!(stdout(), terminal::Clear(ClearType::All)),
-          "clear_screen"
-        },
-      };
-    }
+    self.queue.iter().for_each(|cmd_wrapper| match cmd_wrapper {
+      TWCommand::EnableRawMode => {
+        exec!(terminal::enable_raw_mode(), "EnableRawMode")
+      }
+      TWCommand::EnableMouseCapture => {
+        exec!(queue!(stdout(), EnableMouseCapture), "EnableMouseCapture")
+      }
+      TWCommand::EnterAlternateScreen => {
+        exec!(queue!(stdout(), EnterAlternateScreen), "EnterAlternateScreen")
+      }
+      TWCommand::LeaveAlternateScreen => {
+        exec!(queue!(stdout(), LeaveAlternateScreen), "LeaveAlternateScreen")
+      }
+      TWCommand::DisableRawMode => {
+        exec!(terminal::disable_raw_mode(), "DisableRawMode")
+      }
+      TWCommand::DisableMouseCapture => {
+        exec!(queue!(stdout(), DisableMouseCapture), "DisableMouseCapture")
+      }
+      TWCommand::MoveCursorPosition(first, second) => {
+        exec!(
+          queue!(stdout(), cursor::MoveTo(*first, *second)),
+          format!("MoveCursorPosition({}, {})", first, second)
+        )
+      }
+      TWCommand::ClearScreen => {
+        exec!(queue!(stdout(), terminal::Clear(ClearType::All)), "ClearScreen")
+      }
+      TWCommand::SetFgColor(color) => {
+        exec!(
+          queue!(stdout(), style::SetForegroundColor(*color)),
+          format!("SetFgColor({:?})", color)
+        )
+      }
+      TWCommand::SetBgColor(color) => {
+        exec!(
+          queue!(stdout(), style::SetBackgroundColor(*color)),
+          format!("SetBgColor({:?})", color)
+        )
+      }
+      TWCommand::ResetColor => {
+        exec!(queue!(stdout(), style::ResetColor), "ResetColor")
+      }
+      TWCommand::Print(content) => {
+        exec!(
+          queue!(stdout(), style::Print(content.clone())),
+          format!("Print({:?})", content)
+        )
+      }
+      TWCommand::CursorShow => {
+        exec!(queue!(stdout(), Show), "CursorShow")
+      }
+      TWCommand::CursorHide => {
+        exec!(queue!(stdout(), Hide), "CursorHide")
+      }
+    });
 
-    try_to_run_crossterm_command_and_log_result! {
-      stdout().flush(),
-      "flush"
-    }
+    TWCommand::flush();
   }
 }

src/crossterm_helpers/raw_mode.rs

@@ -73,23 +73,27 @@ pub struct RawMode;
 
 impl RawMode {
   pub fn start() -> Self {
-    queue_and_flush!(
-      Command::EnableRawMode,
-      Command::EnableMouseCapture,
-      Command::EnterAlternateScreen,
-      Command::MoveCursorPosition(0, 0),
-      Command::ClearScreen
-    );
+    tw_queue!(
+      TWCommand::EnableRawMode,
+      TWCommand::EnableMouseCapture,
+      TWCommand::EnterAlternateScreen,
+      TWCommand::MoveCursorPosition(0, 0),
+      TWCommand::ClearScreen,
+      TWCommand::CursorHide
+    )
+    .flush();
     RawMode
   }
 }
 
 impl Drop for RawMode {
   fn drop(&mut self) {
-    queue_and_flush!(
-      Command::LeaveAlternateScreen,
-      Command::DisableMouseCapture,
-      Command::DisableRawMode
-    );
+    tw_queue!(
+      TWCommand::CursorShow,
+      TWCommand::LeaveAlternateScreen,
+      TWCommand::DisableMouseCapture,
+      TWCommand::DisableRawMode
+    )
+    .flush();
   }
 }