feat: add support for saving commands and output to files

- Added `SaveToFileWidget` for saving commands and outputs.
- Introduced `CompletableInput` for improved completion handling.

Author: tlipinski

src/app.rs

@@ -0,0 +1,164 @@
+use crate::completion::FileOnlyShCompleter;
+use crate::completion::ShCompleter;
+use crate::completion::{Completer, CompletionResult};
+use crossterm::event::Event;
+use tui_input::backend::crossterm::to_input_request;
+use tui_input::{Input, InputRequest, InputResponse, StateChanged};
+
+pub struct CompletableInput {
+    input: Input,
+    completions: Option<(CompletionResult, usize)>,
+    completer: Box<dyn Completer>,
+}
+
+impl From<String> for CompletableInput {
+    fn from(value: String) -> Self {
+        Self {
+            input: Input::new(value),
+            completions: None,
+            completer: Box::new(ShCompleter {}),
+        }
+    }
+}
+
+impl From<&str> for CompletableInput {
+    fn from(value: &str) -> Self {
+        Self {
+            input: Input::new(value.to_string()),
+            completions: None,
+            completer: Box::new(ShCompleter {}),
+        }
+    }
+}
+
+impl CompletableInput {
+    pub fn file_only(str: &str) -> Self {
+        Self {
+            input: Input::new(str.to_string()),
+            completions: None,
+            completer: Box::new(FileOnlyShCompleter {}),
+        }
+    }
+
+    pub fn cursor(&self) -> usize {
+        self.input.cursor()
+    }
+
+    pub fn handle(&mut self, req: InputRequest) -> InputResponse {
+        self.input.handle(req)
+    }
+
+    pub fn handle_event(&mut self, evt: &Event) -> Option<StateChanged> {
+        self.completions = None;
+        to_input_request(evt).and_then(|req| self.input.handle(req))
+    }
+
+    pub fn value(&self) -> &str {
+        self.input.value()
+    }
+
+    pub fn visual_cursor(&self) -> usize {
+        self.input.visual_cursor()
+    }
+
+    pub fn clear_completions(&mut self) {
+        self.completions = None;
+    }
+
+    pub fn complete(&mut self, next: bool) {
+        let current_value = self.input.value().to_string();
+        let cursor_pos = self.input.visual_cursor();
+
+        if let Some((res, index)) = self.completions.as_mut() {
+            if next {
+                *index = (*index + 1) % res.completions.len();
+            } else {
+                *index = if *index == 0 {
+                    res.completions.len() - 1
+                } else {
+                    *index - 1
+                };
+            }
+            let completion = &res.completions[*index];
+            let new_value = format!(
+                "{}{}{}",
+                &current_value[..res.word_start],
+                completion,
+                &current_value[cursor_pos..]
+            );
+            self.input = Input::from(new_value);
+            self.input
+                .handle(InputRequest::SetCursor(res.word_start + completion.len()));
+        } else if let Some(res) = self.completer.completions(&current_value, cursor_pos) {
+            let index = if next { 0 } else { res.completions.len() - 1 };
+            let word_start = res.word_start;
+            let completion = res.completions[index].clone();
+            let new_value = format!(
+                "{}{}{}",
+                &current_value[..word_start],
+                completion,
+                &current_value[cursor_pos..]
+            );
+            self.completions = Some((res, index));
+            self.input = Input::from(new_value);
+            self.input
+                .handle(InputRequest::SetCursor(word_start + completion.len()));
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crossterm::event::KeyCode::Char;
+    use crossterm::event::{Event, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers};
+    use tui_input::Input;
+
+    struct TestCompleter;
+
+    impl Completer for TestCompleter {
+        fn completions(&self, _input: &str, _cursor_pos: usize) -> Option<CompletionResult> {
+            Some(CompletionResult {
+                completions: vec!["command".to_string(), "command_other".to_string()],
+                word_start: 0,
+            })
+        }
+    }
+
+    impl Default for CompletableInput {
+        fn default() -> Self {
+            CompletableInput {
+                input: Input::from(""),
+                completions: None,
+                completer: Box::new(TestCompleter {}),
+            }
+        }
+    }
+
+    #[test]
+    fn completer() {
+        let mut input = CompletableInput::default();
+
+        input_text(&mut input, "co");
+
+        input.complete(true);
+        assert_eq!(input.value(), "command");
+
+        input.complete(true);
+        assert_eq!(input.value(), "command_other");
+
+        input.complete(false);
+        assert_eq!(input.value(), "command");
+    }
+
+    fn input_text(app: &mut CompletableInput, text: &str) {
+        for c in text.chars() {
+            app.handle_event(&Event::Key(KeyEvent {
+                code: Char(c),
+                modifiers: KeyModifiers::NONE,
+                kind: KeyEventKind::Press,
+                state: KeyEventState::NONE,
+            }));
+        }
+    }
+}

src/completable_input.rs

@@ -91,6 +91,71 @@ impl ShCompleter {
     }
 }
 
+pub struct FileOnlyShCompleter;
+
+impl Completer for FileOnlyShCompleter {
+    fn completions(&self, input: &str, cursor_pos: usize) -> Option<CompletionResult> {
+        let (prefix, completion_type, word_start) = {
+            let input_up_to_cursor = &input[..cursor_pos];
+
+            let word_start = input_up_to_cursor
+                .rfind(|c: char| c.is_whitespace())
+                .map(|i| i + 1)
+                .unwrap_or(0);
+            let prefix = &input_up_to_cursor[word_start..];
+
+            (prefix.to_string(), CompletionType::File, word_start)
+        };
+
+        debug!(
+            "Completion prefix for '{}' @ {}: '{}', type: {:?}, word start: {}",
+            input, cursor_pos, prefix, completion_type, word_start
+        );
+
+        let comp_type_str = match completion_type {
+            CompletionType::Command => "-c",
+            CompletionType::File => "-f",
+        };
+
+        let output = Command::new("sh")
+            .arg("-c")
+            .arg(format!("compgen {} -- \"{}\"", comp_type_str, prefix))
+            .output();
+
+        match output {
+            Ok(output) => {
+                let stdout = String::from_utf8_lossy(&output.stdout);
+                let completions: Vec<String> = stdout
+                    .lines()
+                    .map(|s| s.to_string())
+                    .unique()
+                    .sorted_by(|a, b| a.len().cmp(&b.len()))
+                    .sorted()
+                    .collect();
+
+                debug!(
+                    "completion results [{}]: {:?}",
+                    completions.len(),
+                    completions
+                );
+
+                if completions.is_empty() {
+                    None
+                } else {
+                    Some(CompletionResult {
+                        completions,
+                        word_start,
+                    })
+                }
+            }
+            Err(e) => {
+                error!("Failed fetching completions {}", e);
+                None
+            }
+        }
+    }
+}
+
 #[derive(Debug, PartialEq)]
 enum CompletionType {
     Command,

src/completion.rs

@@ -97,6 +97,8 @@ pub struct KeyBindingsConfig {
     pub complete_prev: Vec<String>,
     pub search_next: Vec<String>,
     pub search_prev: Vec<String>,
+    pub save_output: Vec<String>,
+    pub save_command: Vec<String>,
 }
 
 impl Default for KeyBindingsConfig {
@@ -132,6 +134,8 @@ impl Default for KeyBindingsConfig {
             complete_prev: vec!["shift+tab".into(), "alt+tab".into()],
             search_next: vec!["f3".into(), "ctrl+f".into()],
             search_prev: vec!["f4".into(), "ctrl+b".into()],
+            save_output: vec!["ctrl+s".into()],
+            save_command: vec!["ctrl+alt+s".into()],
         }
     }
 }

src/config.rs

@@ -1,5 +1,6 @@
 mod app;
 mod cmd_runner;
+mod completable_input;
 mod completion;
 mod config;
 mod debouncer;
@@ -8,6 +9,7 @@ mod output_widget;
 mod props;
 mod rura;
 mod rura_widget;
+mod save_to_file_widget;
 mod search_widget;
 mod theme;
 mod uicmd;

src/main.rs

@@ -24,7 +24,7 @@ struct Viewport {
 }
 
 pub struct OutputWidget {
-    output: Output,
+    pub output: Output,
     error_output_opt: Option<Output>,
     offset: Position,
     wrap: bool,