refactor continues with use of str instead of String

Author: vim-zz

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "swordfish-rs"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 license-file = "LICENSE"
 description = "Cli tool for typing effect in Termainl for screencasts"

Cargo.toml

@@ -112,6 +112,8 @@ Speed everything, useful when iterating over the screenplay.
 
 #### `wait` 
 
+Pauses execution for the specified time, then contrinues.
+
 | Argument | Type | Description |
 | - | - | - |
 |`msec`| Integer |  delay before next command in millisecs |

README.md

@@ -8,23 +8,29 @@ use crate::{functions, terminal, state::State};
 #[enum_dispatch]
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "snake_case")]
-pub enum Command {
+pub enum Command<'a> {
     Clear(Clear),
-    Erase(Erase),
-    Execute(Execute),
+    #[serde(borrow)]
+    Erase(Erase<'a>),
+    #[serde(borrow)]
+    Execute(Execute<'a>),
     NewLine(NewLine),
     Pause(Pause),
-    Prompt(Prompt),
-    Wait(Wait),
-    Write(Write),
+    #[serde(borrow)]
+    Prompt(Prompt<'a>),
     Turbo(Turbo),
+    Wait(Wait),
+    #[serde(borrow)]
+    Write(Write<'a>),
 }
 
 #[enum_dispatch(Command)]
 pub trait Runnable {
     fn run(&self, state: &mut State) -> Result<()>;
 }
 
+/// `!clear`
+/// Clear screen command.
 #[derive(Debug, Deserialize)]
 pub struct Clear {}
 
@@ -37,14 +43,16 @@ impl Runnable for Clear {
     }
 }
 
+/// `!erase`
+/// Erase characters to the left.
 #[derive(Debug, Deserialize)]
-pub struct Erase {
+pub struct Erase<'a> {
     pub msec: u32, 
-    pub by_chars: Option<String>, 
+    pub by_chars: Option<&'a str>, 
     pub amount: Option<u32>,
 }
 
-impl Runnable for Erase {
+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(),
@@ -61,12 +69,14 @@ impl Runnable for Erase {
     }
 }
 
+/// `!execute`
+/// Execute shell commands or other applications and show their output.
 #[derive(Debug, Deserialize)]
-pub struct Execute {
-    pub line: String, 
+pub struct Execute<'a> {
+    pub line: &'a str, 
 }
 
-impl Runnable for Execute {
+impl<'a> Runnable for Execute<'a> {
     fn run(&self, state: &mut State) -> Result<()> {
         println!("");
         let words = shellwords::split(&self.line).unwrap();
@@ -81,6 +91,8 @@ impl Runnable for Execute {
     }
 }
 
+/// `!new_line`
+/// Simulate user's `ENTER`.
 #[derive(Debug, Deserialize)]
 pub struct NewLine {}
 
@@ -93,6 +105,8 @@ impl Runnable for NewLine {
     }
 }
 
+/// `!pasue`
+/// Pause before next command and wait for user input (any key...)
 #[derive(Debug, Deserialize)]
 pub struct Pause {}
 
@@ -104,13 +118,15 @@ impl Runnable for Pause {
     }
 }
 
+/// `!prompt`
+/// Prompt specify a constant text that is shown after every `execute` and cis not affected by `erase`.
 #[derive(Debug, Deserialize)]
-pub struct Prompt {
-    pub text: String, 
-    pub color: Option<String>,
+pub struct Prompt<'a> {
+    pub text: &'a str, 
+    pub color: Option<&'a str>,
 }
 
-impl Runnable for Prompt {
+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);
@@ -120,6 +136,22 @@ impl Runnable for Prompt {
     }
 }
 
+/// `!turbo`
+/// Speed everything, useful when iterating over the screenplay.
+#[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(())
+    }
+}
+
+/// `!wait`
+/// Pauses execution for the specified time, then contrinues.
 #[derive(Debug, Deserialize)]
 pub struct Wait {
     pub msec: u32,
@@ -132,14 +164,16 @@ impl Runnable for Wait {
     }
 }
 
+/// `!write`
+/// Write text to the terminal.
 #[derive(Debug, Deserialize)]
-pub struct Write {
+pub struct Write<'a> {
     pub msec: u32, 
-    pub color: Option<String>, 
-    pub text: String,
+    pub color: Option<&'a str>, 
+    pub text: &'a str,
 }
 
-impl Runnable for Write {
+impl Runnable for Write<'_> {
     fn run(&self, state: &mut State) -> Result<()> {
         for c in self.text.chars() { 
             functions::delay(self.msec, state.speed_factor);
@@ -151,14 +185,3 @@ impl Runnable for Write {
     }
 }
 
-#[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(())
-    }
-}