Merge pull request #4 from ynqa/v0.1.2/main

v0.1.2

Author: ynqa

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sigrs"
-version = "0.1.1"
+version = "0.1.2"
 authors = ["ynqa <un.pensiero.vano@gmail.com>"]
 edition = "2021"
 description = "Interactive grep (for streaming)"

Cargo.toml

@@ -12,8 +12,16 @@ Interactive grep
 - Interactive grep (for streaming)
   - *sig* allows users to interactively search through (streaming) data,
     updating results in real-time.
+- Re-execute command
+  - If `--cmd` is specified instread of piping data to *sig*,
+    the command will be executed on initial and retries.
+  - This feature is designed to address the issue where data streams
+    past while the user is fine-tuning the search criteria.
+    In other words, even if the data has already passed,
+    executing the command again allows
+    the retrieval of the data for re-evaluation.
 - Archived mode
-  - In Archived mode, since there is no seeking capability
+  - In archived mode, since there is no seeking capability
     for streaming data received through a pipe,
     it is not possible to search backwards without exiting the process.
     Therefore, in *sig*, the latest N entries of streaming data are saved,
@@ -79,11 +87,28 @@ in
   }
 ```
 
+## Examples
+
+```bash
+stern --context kind-kind etcd |& sig
+# or
+sig --cmd "stern --context kind-kind etcd" # this is able to retry command by ctrl+r.
+```
+
+### Archived mode
+
+```bash
+cat README.md |& sig -a
+# or
+sig -a --cmd "cat README.md"
+```
+
 ## Keymap
 
 | Key                  | Action
 | :-                   | :-
 | <kbd>Ctrl + C</kbd>  | Exit `sig`
+| <kbd>Ctrl + R</kbd>  | Retry command if `--cmd` is specified
 | <kbd>Ctrl + F</kbd>  | Enter Archived mode
 | <kbd>←</kbd>         | Move the cursor one character to the left
 | <kbd>→</kbd>         | Move the cursor one character to the right
@@ -111,6 +136,17 @@ Interactive grep (for streaming)
 
 Usage: sig [OPTIONS]
 
+Examples:
+
+$ stern --context kind-kind etcd |& sig
+Or the method to retry command by pressing ctrl+r:
+$ sig --cmd "stern --context kind-kind etcd"
+
+Archived mode:
+$ cat README.md |& sig -a
+Or
+$ sig -a --cmd "cat README.md"
+
 Options:
       --retrieval-timeout <RETRIEVAL_TIMEOUT_MILLIS>
           Timeout to read a next line from the stream in milliseconds. [default: 10]
@@ -122,6 +158,8 @@ Options:
           Archived mode to grep through static data.
   -i, --ignore-case
           Case insensitive search.
+      --cmd <CMD>
+          Command to execute on initial and retries.
   -h, --help
           Print help (see more with '--help')
   -V, --version

README.md

@@ -20,6 +20,7 @@ struct Archived {
     lines: Snapshot<listbox::State>,
     highlight_style: ContentStyle,
     case_insensitive: bool,
+    cmd: Option<String>,
 }
 
 impl promkit::Finalizer for Archived {
@@ -39,7 +40,12 @@ impl promkit::Renderer for Archived {
     }
 
     fn evaluate(&mut self, event: &Event) -> anyhow::Result<PromptSignal> {
-        let signal = self.keymap.get()(event, &mut self.text_editor_snapshot, &mut self.lines);
+        let signal = self.keymap.get()(
+            event,
+            &mut self.text_editor_snapshot,
+            &mut self.lines,
+            self.cmd.clone(),
+        );
         if self
             .text_editor_snapshot
             .after()
@@ -85,6 +91,7 @@ pub fn run(
     lines: listbox::State,
     highlight_style: ContentStyle,
     case_insensitive: bool,
+    cmd: Option<String>,
 ) -> anyhow::Result<()> {
     Prompt {
         renderer: Archived {
@@ -93,6 +100,7 @@ pub fn run(
             lines: Snapshot::new(lines),
             highlight_style,
             case_insensitive,
+            cmd,
         },
     }
     .run()

src/archived.rs

@@ -9,17 +9,33 @@ pub type Keymap = fn(
     &Event,
     &mut Snapshot<text_editor::State>,
     &mut Snapshot<listbox::State>,
+    Option<String>,
 ) -> anyhow::Result<PromptSignal>;
 
 pub fn default(
     event: &Event,
     text_editor_snapshot: &mut Snapshot<text_editor::State>,
     logs_snapshot: &mut Snapshot<listbox::State>,
+    cmd: Option<String>,
 ) -> anyhow::Result<PromptSignal> {
     let text_editor_state = text_editor_snapshot.after_mut();
     let logs_state = logs_snapshot.after_mut();
 
     match event {
+        Event::Key(KeyEvent {
+            code: KeyCode::Char('r'),
+            modifiers: KeyModifiers::CONTROL,
+            kind: KeyEventKind::Press,
+            state: KeyEventState::NONE,
+        }) => {
+            if cmd.is_some() {
+                // Exiting archive mode here allows
+                // the caller to re-enter streaming mode,
+                // as it is running in an infinite loop.
+                return Ok(PromptSignal::Quit);
+            }
+        }
+
         Event::Key(KeyEvent {
             code: KeyCode::Char('c'),
             modifiers: KeyModifiers::CONTROL,

src/archived/keymap.rs

@@ -0,0 +1,54 @@
+use std::process::Stdio;
+
+use tokio::{
+    io::{AsyncBufReadExt, BufReader},
+    process::Command,
+    sync::mpsc,
+    time::{timeout, Duration},
+};
+use tokio_util::sync::CancellationToken;
+
+pub async fn execute(
+    cmdstr: &str,
+    tx: mpsc::Sender<String>,
+    retrieval_timeout: Duration,
+    canceled: CancellationToken,
+) -> anyhow::Result<()> {
+    let args: Vec<&str> = cmdstr.split_whitespace().collect();
+    let mut child = Command::new(args[0])
+        .args(&args[1..])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()?;
+
+    let stdout = child
+        .stdout
+        .take()
+        .ok_or_else(|| anyhow::anyhow!("stdout is not available"))?;
+    let stderr = child
+        .stderr
+        .take()
+        .ok_or_else(|| anyhow::anyhow!("stderr is not available"))?;
+    let mut stdout_reader = BufReader::new(stdout).lines();
+    let mut stderr_reader = BufReader::new(stderr).lines();
+
+    while !canceled.is_cancelled() {
+        tokio::select! {
+            stdout_res = timeout(retrieval_timeout, stdout_reader.next_line()) => {
+                if let Ok(Ok(Some(line))) = stdout_res {
+                    let escaped = strip_ansi_escapes::strip_str(line.replace(['\n', '\t'], " "));
+                    tx.send(escaped).await?;
+                }
+            },
+            stderr_res = timeout(retrieval_timeout, stderr_reader.next_line()) => {
+                if let Ok(Ok(Some(line))) = stderr_res {
+                    let escaped = strip_ansi_escapes::strip_str(line.replace(['\n', '\t'], " "));
+                    tx.send(escaped).await?;
+                }
+            }
+        }
+    }
+
+    child.kill().await?;
+    Ok(())
+}

src/cmd.rs

@@ -19,13 +19,44 @@ use promkit::{
 };
 
 mod archived;
+mod cmd;
 mod sig;
 mod stdin;
 mod terminal;
 
+#[derive(Eq, PartialEq)]
+pub enum Signal {
+    Continue,
+    GotoArchived,
+    GotoStreaming,
+}
+
 /// Interactive grep (for streaming)
 #[derive(Parser)]
 #[command(name = "sig", version)]
+#[command(
+    name = "sig",
+    version,
+    help_template = "
+{about}
+
+Usage: {usage}
+
+Examples:
+
+$ stern --context kind-kind etcd |& sig
+Or the method to retry command by pressing ctrl+r:
+$ sig --cmd \"stern --context kind-kind etcd\"
+
+Archived mode:
+$ cat README.md |& sig -a
+Or
+$ sig -a --cmd \"cat README.md\"
+
+Options:
+{options}
+"
+)]
 pub struct Args {
     #[arg(
         long = "retrieval-timeout",
@@ -71,6 +102,14 @@ pub struct Args {
         help = "Case insensitive search."
     )]
     pub case_insensitive: bool,
+
+    #[arg(
+        long = "cmd",
+        help = "Command to execute on initial and retries.",
+        long_help = "This command is invoked initially and
+        whenever a retry is triggered according to key mappings."
+    )]
+    pub cmd: Option<String>,
 }
 
 impl Drop for Args {
@@ -92,14 +131,26 @@ async fn main() -> anyhow::Result<()> {
     if args.archived {
         let (tx, mut rx) = mpsc::channel(1);
 
-        tokio::spawn(async move {
-            stdin::streaming(
-                tx,
-                Duration::from_millis(args.retrieval_timeout_millis),
-                CancellationToken::new(),
-            )
-            .await
-        });
+        if let Some(cmd) = args.cmd.clone() {
+            tokio::spawn(async move {
+                cmd::execute(
+                    &cmd,
+                    tx,
+                    Duration::from_millis(args.retrieval_timeout_millis),
+                    CancellationToken::new(),
+                )
+                .await
+            });
+        } else {
+            tokio::spawn(async move {
+                stdin::streaming(
+                    tx,
+                    Duration::from_millis(args.retrieval_timeout_millis),
+                    CancellationToken::new(),
+                )
+                .await
+            });
+        }
 
         let mut queue = VecDeque::with_capacity(args.queue_capacity);
         loop {
@@ -149,9 +200,11 @@ async fn main() -> anyhow::Result<()> {
             },
             highlight_style,
             args.case_insensitive,
+            // In archived mode, command for retry is meaningless.
+            None,
         )?;
     } else {
-        let queue = sig::run(
+        while let Ok((signal, queue)) = sig::run(
             text_editor::State {
                 texteditor: Default::default(),
                 history: Default::default(),
@@ -169,39 +222,62 @@ async fn main() -> anyhow::Result<()> {
             Duration::from_millis(args.render_interval_millis),
             args.queue_capacity,
             args.case_insensitive,
+            args.cmd.clone(),
         )
-        .await?;
+        .await
+        {
+            crossterm::execute!(
+                io::stdout(),
+                crossterm::terminal::Clear(crossterm::terminal::ClearType::All),
+                crossterm::terminal::Clear(crossterm::terminal::ClearType::Purge),
+                cursor::MoveTo(0, 0),
+            )?;
 
-        crossterm::execute!(
-            io::stdout(),
-            crossterm::terminal::Clear(crossterm::terminal::ClearType::All),
-            crossterm::terminal::Clear(crossterm::terminal::ClearType::Purge),
-            cursor::MoveTo(0, 0),
-        )?;
+            match signal {
+                Signal::GotoArchived => {
+                    archived::run(
+                        text_editor::State {
+                            texteditor: Default::default(),
+                            history: Default::default(),
+                            prefix: String::from("❯❯❯ "),
+                            mask: Default::default(),
+                            prefix_style: StyleBuilder::new().fgc(Color::DarkBlue).build(),
+                            active_char_style: StyleBuilder::new().bgc(Color::DarkCyan).build(),
+                            inactive_char_style: StyleBuilder::new().build(),
+                            edit_mode: Default::default(),
+                            word_break_chars: Default::default(),
+                            lines: Default::default(),
+                        },
+                        listbox::State {
+                            listbox: listbox::Listbox::from_iter(queue),
+                            cursor: String::from("❯ "),
+                            active_item_style: None,
+                            inactive_item_style: None,
+                            lines: Default::default(),
+                        },
+                        highlight_style,
+                        args.case_insensitive,
+                        args.cmd.clone(),
+                    )?;
 
-        archived::run(
-            text_editor::State {
-                texteditor: Default::default(),
-                history: Default::default(),
-                prefix: String::from("❯❯❯ "),
-                mask: Default::default(),
-                prefix_style: StyleBuilder::new().fgc(Color::DarkBlue).build(),
-                active_char_style: StyleBuilder::new().bgc(Color::DarkCyan).build(),
-                inactive_char_style: StyleBuilder::new().build(),
-                edit_mode: Default::default(),
-                word_break_chars: Default::default(),
-                lines: Default::default(),
-            },
-            listbox::State {
-                listbox: listbox::Listbox::from_iter(queue),
-                cursor: String::from("❯ "),
-                active_item_style: None,
-                inactive_item_style: None,
-                lines: Default::default(),
-            },
-            highlight_style,
-            args.case_insensitive,
-        )?;
+                    // Re-enable raw mode and hide the cursor again here
+                    // because they are disabled and shown, respectively, by promkit.
+                    enable_raw_mode()?;
+                    execute!(io::stdout(), cursor::Hide)?;
+
+                    crossterm::execute!(
+                        io::stdout(),
+                        crossterm::terminal::Clear(crossterm::terminal::ClearType::All),
+                        crossterm::terminal::Clear(crossterm::terminal::ClearType::Purge),
+                        cursor::MoveTo(0, 0),
+                    )?;
+                }
+                Signal::GotoStreaming => {
+                    continue;
+                }
+                _ => {}
+            }
+        }
     }
 
     Ok(())

src/main.rs

@@ -15,11 +15,11 @@ use promkit::{
     crossterm::{self, event, style::ContentStyle},
     grapheme::StyledGraphemes,
     switch::ActiveKeySwitcher,
-    text_editor, PaneFactory, PromptSignal,
+    text_editor, PaneFactory,
 };
 
 mod keymap;
-use crate::{stdin, terminal::Terminal};
+use crate::{cmd, stdin, terminal::Terminal, Signal};
 
 fn matched(queries: &[&str], line: &str, case_insensitive: bool) -> anyhow::Result<Vec<Match>> {
     let mut matched = Vec::new();
@@ -78,7 +78,8 @@ pub async fn run(
     render_interval: Duration,
     queue_capacity: usize,
     case_insensitive: bool,
-) -> anyhow::Result<VecDeque<String>> {
+    cmd: Option<String>,
+) -> anyhow::Result<(Signal, VecDeque<String>)> {
     let keymap = ActiveKeySwitcher::new("default", keymap::default);
     let size = crossterm::terminal::size()?;
 
@@ -95,8 +96,11 @@ pub async fn run(
     let canceler = CancellationToken::new();
 
     let canceled = canceler.clone();
-    let streaming =
-        tokio::spawn(async move { stdin::streaming(tx, retrieval_timeout, canceled).await });
+    let streaming = if let Some(cmd) = cmd.clone() {
+        tokio::spawn(async move { cmd::execute(&cmd, tx, retrieval_timeout, canceled).await })
+    } else {
+        tokio::spawn(async move { stdin::streaming(tx, retrieval_timeout, canceled).await })
+    };
 
     let keeping: JoinHandle<anyhow::Result<VecDeque<String>>> = tokio::spawn(async move {
         let mut queue = VecDeque::with_capacity(queue_capacity);
@@ -135,11 +139,12 @@ pub async fn run(
         Ok(queue)
     });
 
+    let mut signal: Signal;
     loop {
         let event = event::read()?;
         let mut text_editor = shared_text_editor.write().await;
-        let signal = keymap.get()(&event, &mut text_editor)?;
-        if signal == PromptSignal::Quit {
+        signal = keymap.get()(&event, &mut text_editor, cmd.clone())?;
+        if signal == Signal::GotoArchived || signal == Signal::GotoStreaming {
             break;
         }
 
@@ -152,5 +157,5 @@ pub async fn run(
     canceler.cancel();
     let _: anyhow::Result<(), anyhow::Error> = streaming.await?;
 
-    keeping.await?
+    Ok((signal, keeping.await??))
 }

src/sig.rs

@@ -1,16 +1,33 @@
 use promkit::{
     crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers},
-    text_editor, PromptSignal,
+    text_editor,
 };
 
-pub fn default(event: &Event, state: &mut text_editor::State) -> anyhow::Result<PromptSignal> {
+use crate::Signal;
+
+pub fn default(
+    event: &Event,
+    state: &mut text_editor::State,
+    cmd: Option<String>,
+) -> anyhow::Result<Signal> {
     match event {
         Event::Key(KeyEvent {
             code: KeyCode::Char('f'),
             modifiers: KeyModifiers::CONTROL,
             kind: KeyEventKind::Press,
             state: KeyEventState::NONE,
-        }) => return Ok(PromptSignal::Quit),
+        }) => return Ok(Signal::GotoArchived),
+
+        Event::Key(KeyEvent {
+            code: KeyCode::Char('r'),
+            modifiers: KeyModifiers::CONTROL,
+            kind: KeyEventKind::Press,
+            state: KeyEventState::NONE,
+        }) => {
+            if cmd.is_some() {
+                return Ok(Signal::GotoStreaming);
+            }
+        }
 
         Event::Key(KeyEvent {
             code: KeyCode::Char('c'),
@@ -82,5 +99,5 @@ pub fn default(event: &Event, state: &mut text_editor::State) -> anyhow::Result<
 
         _ => (),
     }
-    Ok(PromptSignal::Continue)
+    Ok(Signal::Continue)
 }