refactor into Runnable commands

Author: vim-zz

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "swordfish-rs"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 license-file = "LICENSE"
 description = "Cli tool for typing effect in Termainl for screencasts"
@@ -20,6 +20,7 @@ name = "swordfish"
 anyhow = "1"
 clap = { version = "3", features = ["derive"] }
 colored = "2"
+enum_dispatch = "0.3"
 serde = { version = "1", features = ["derive"] }
 serde_yaml = "0.9"
 shellwords = "1"
@@ -28,3 +29,4 @@ shellwords = "1"
 strip = true
 lto = true
 codegen-units = 1
+opt-level = "z"  # Optimize for size.

Cargo.toml

@@ -1,15 +1,164 @@
+use anyhow::Result;
+use std::{cmp, process};
+use std::io::{self, stdout, Write as IOWrite};
 use serde::{Deserialize};
+use enum_dispatch::enum_dispatch;
+use crate::{functions, terminal, state::State};
 
+#[enum_dispatch]
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum Command<'a> {
-    Clear,
-    Erase {msec: u32, by_chars: Option<&'a str>, amount: Option<u32>},
-    Execute {line: &'a str},
-    NewLine,
-    Pause,
-    Prompt {text: &'a str, color: Option<&'a str>},
-    Wait {msec: u32},
-    Write {msec: u32, color: Option<&'a str>, text: &'a str},
-    Turbo {by: u32},
-}
+pub enum Command {
+    Clear(Clear),
+    Erase(Erase),
+    Execute(Execute),
+    NewLine(NewLine),
+    Pause(Pause),
+    Prompt(Prompt),
+    Wait(Wait),
+    Write(Write),
+    Turbo(Turbo),
+}
+
+#[enum_dispatch(Command)]
+pub trait Runnable {
+    fn run(&self, state: &mut State) -> Result<()>;
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Clear {}
+
+impl Runnable for Clear {
+    fn run(&self, state: &mut State) -> Result<()> {
+        print!("\x1B[2J\x1B[1;1H");
+        functions::show_prompt(&state.prompt)?;
+        state.cursor = 0;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Erase {
+    pub msec: u32, 
+    pub by_chars: Option<String>, 
+    pub amount: Option<u32>,
+}
+
+impl Runnable for Erase {
+    fn run(&self, state: &mut State) -> Result<()> {
+        let deletions = match (self.by_chars.as_ref(), self.amount) {
+            (Some(by_chars), None) => by_chars.len(),
+            (None, Some(amount)) => amount as usize,
+            (Some(by_chars), Some(amount)) => amount as usize + by_chars.len(),
+            (None, None) => 0,
+        };
+
+        // Remove the deletions up till the cursor
+        let deletions = cmp::min(deletions, state.cursor);
+        state.cursor -= deletions;
+        functions::erase(deletions, self.msec, state.speed_factor)?;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Execute {
+    pub line: String, 
+}
+
+impl Runnable for Execute {
+    fn run(&self, state: &mut State) -> Result<()> {
+        println!("");
+        let words = shellwords::split(&self.line).unwrap();
+
+        if let Some((cmd, args)) = words.split_first() {
+            process::Command::new(cmd).args(args).spawn()?;
+        }
+        functions::delay(crate::DELAY_AFTER_EXECUTE, state.speed_factor);
+        functions::show_prompt(&state.prompt)?;
+        state.cursor = 0;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct NewLine {}
+
+impl Runnable for NewLine {
+    fn run(&self, state: &mut State) -> Result<()> {
+        print!("\n");
+        functions::show_prompt(&state.prompt)?;
+        state.cursor = 0;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Pause {}
+
+impl Runnable for Pause {
+    fn run(&self, _state: &mut State) -> Result<()> {
+        let mut answer = String::new();
+        io::stdin().read_line(&mut answer)?;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Prompt {
+    pub text: String, 
+    pub color: Option<String>,
+}
+
+impl Runnable for Prompt {
+    fn run(&self, state: &mut State) -> Result<()> {
+        let ps1 = terminal::colorful(&self.text, self.color.as_deref());
+        state.prompt = Some(ps1);
+        functions::show_prompt(&state.prompt)?;
+        state.cursor = 0;
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Wait {
+    pub msec: u32,
+}
+
+impl Runnable for Wait {
+    fn run(&self, state: &mut State) -> Result<()> {
+        functions::delay(self.msec, state.speed_factor);
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Write {
+    pub msec: u32, 
+    pub color: Option<String>, 
+    pub text: String,
+}
+
+impl Runnable for Write {
+    fn run(&self, state: &mut State) -> Result<()> {
+        for c in self.text.chars() { 
+            functions::delay(self.msec, state.speed_factor);
+            print!("{}", terminal::colorful(&c.to_string(), self.color.as_deref()));
+            stdout().flush()?;
+        }
+        state.cursor += self.text.len();
+        Ok(())
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Turbo {
+    pub by: u32,
+}
+
+impl Runnable for Turbo {
+    fn run(&self, state: &mut State) -> Result<()> {
+        state.speed_factor = self.by;
+        Ok(())
+    }
+}

src/commands.rs

@@ -0,0 +1,26 @@
+use anyhow::Result;
+use std::{thread, time};
+use std::io::{stdout, Write};
+use crate::terminal::BACKSPACE;
+
+pub fn delay(msec: u32, speed_factor: u32) {
+    let t = msec / speed_factor;
+    thread::sleep(time::Duration::from_millis(t.into()));
+}
+
+pub fn erase(amount: usize, msec: u32, speed_factor: u32) -> Result<()> {
+    for _ in 0..amount { 
+        delay(msec, speed_factor);
+        print!("{} {}", BACKSPACE, BACKSPACE);
+        stdout().flush()?;
+    }
+    Ok(())
+}
+
+pub fn show_prompt(prompt: &Option<String>) -> Result<()> {
+    if let Some(ps1) = prompt {
+        print!("{ps1} ");
+        stdout().flush()?;
+    }
+    Ok(())
+}

src/functions.rs

@@ -1,11 +1,12 @@
 mod commands;
 mod terminal;
+mod functions;
+mod state;
 
 use anyhow::Result;
-use std::{cmp, process, thread, time};
-use std::io::{self, stdout, Write};
 use commands::Command;
-use terminal::BACKSPACE;
+use state::State;
+use commands::Runnable;
 
 pub fn from_yaml(data: &str) -> Result<Vec<Command>> {
     let yaml = serde_yaml::from_str(data)?;
@@ -15,95 +16,15 @@ pub fn from_yaml(data: &str) -> Result<Vec<Command>> {
 const DELAY_AFTER_EXECUTE: u32 = 250;
 
 pub fn execute(commands: Vec<Command>) -> Result<()> {
-    let mut prompt = None;
-    let mut cursor = 0;
-    let mut speed_factor = 1;
+    let mut state = State {
+        prompt: None,
+        cursor: 0,
+        speed_factor: 1,
+    };
 
     for cmd in commands {
-        match cmd {
-            Command::Write {msec, text, color} => {
-                for c in text.chars() { 
-                    delay(msec, speed_factor);
-                    print!("{}", terminal::colorful(&c.to_string(), color));
-                    stdout().flush()?;
-                }
-                cursor += text.len();
-            },
-            Command::Erase {msec, by_chars, amount} => {
-                let deletions = match (by_chars, amount) {
-                    (Some(by_chars), None) => by_chars.len(),
-                    (None, Some(amount)) => amount as usize,
-                    (Some(by_chars), Some(amount)) => amount as usize + by_chars.len(),
-                    (None, None) => 0,
-                };
-
-                // Remove the deletions up till the cursor
-                let deletions = cmp::min(deletions, cursor);
-                cursor -= deletions;
-                erase(deletions, msec, speed_factor)?;
-            },
-            Command::Execute {line} => {
-                println!("");
-                let words = shellwords::split(line).unwrap();
-
-                if let Some((cmd, args)) = words.split_first() {
-                    process::Command::new(cmd).args(args).spawn()?;
-                }
-                delay(DELAY_AFTER_EXECUTE, speed_factor);
-                show_prompt(&prompt)?;
-                cursor = 0;
-            },
-            Command::Wait {msec} => {
-                delay(msec, speed_factor);
-            },
-            Command::Pause => {
-                let mut answer = String::new();
-                io::stdin().read_line(&mut answer)?;
-            },
-            Command::Clear => {
-                print!("\x1B[2J\x1B[1;1H");
-                show_prompt(&prompt)?;
-                cursor = 0;
-            }
-            Command::Prompt {text, color} => {
-                let ps1 = terminal::colorful(text, color);
-                prompt = Some(ps1);
-                show_prompt(&prompt)?;
-                cursor = 0;
-            },
-            Command::NewLine => {
-                print!("\n");
-                show_prompt(&prompt)?;
-                cursor = 0;
-            },
-            Command::Turbo {by} => {
-                speed_factor = by;
-            },
-        }
+        cmd.run(&mut state)?;
     }
 
     Ok(())
 }
-
-
-fn show_prompt(prompt: &Option<String>) -> Result<()> {
-    if let Some(ps1) = prompt {
-        print!("{ps1} ");
-        stdout().flush()?;
-    }
-    Ok(())
-}
-
-fn erase(amount: usize, msec: u32, speed_factor: u32) -> Result<()> {
-    for _ in 0..amount { 
-        delay(msec, speed_factor);
-        print!("{} {}", BACKSPACE, BACKSPACE);
-        stdout().flush()?;
-    }
-    Ok(())
-}
-
-fn delay(msec: u32, speed_factor: u32) {
-    let t = msec / speed_factor;
-    thread::sleep(time::Duration::from_millis(t.into()));
-}

src/lib.rs

@@ -0,0 +1,5 @@
+pub struct State {
+    pub prompt: Option<String>,
+    pub cursor: usize,
+    pub speed_factor: u32,
+}