xacli_components/components/

input.rs

use std::io::{stdout, Write};

use crossterm::{
    cursor,
    event::{Event, KeyCode, KeyModifiers},
    queue,
    style::Print,
    terminal::{self, ClearType},
};

use super::read_event;
use crate::{ComponentError, Result};

pub struct Input {
    prompt: String,
    default: Option<String>,
}

impl Input {
    pub fn new(prompt: impl Into<String>) -> Self {
        Self {
            prompt: prompt.into(),
            default: None,
        }
    }

    pub fn default(mut self, default: impl Into<String>) -> Self {
        self.default = Some(default.into());
        self
    }

    pub fn run(self) -> Result<String> {
        let mut stdout = stdout();
        terminal::enable_raw_mode()?;

        let result = self.run_inner(&mut stdout);

        terminal::disable_raw_mode()?;
        println!(); // 换行

        result
    }

    /// Run with custom output writer (for testing)
    #[cfg(test)]
    pub fn run_with_output(self, output: &mut impl Write) -> Result<String> {
        self.run_inner(output)
    }

    fn run_inner(&self, stdout: &mut impl Write) -> Result<String> {
        let mut input = self.default.clone().unwrap_or_default();
        let mut cursor_pos = input.len();

        // 显示提示
        self.render(stdout, &input, cursor_pos)?;

        loop {
            if let Event::Key(key) = read_event()? {
                match key.code {
                    KeyCode::Enter => {
                        return Ok(input);
                    }
                    KeyCode::Esc => {
                        return Err(ComponentError::Interrupted);
                    }
                    KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => {
                        return Err(ComponentError::Interrupted);
                    }
                    KeyCode::Char(c) => {
                        input.insert(cursor_pos, c);
                        cursor_pos += 1;
                    }
                    KeyCode::Backspace => {
                        if cursor_pos > 0 {
                            cursor_pos -= 1;
                            input.remove(cursor_pos);
                        }
                    }
                    KeyCode::Delete => {
                        if cursor_pos < input.len() {
                            input.remove(cursor_pos);
                        }
                    }
                    KeyCode::Left => {
                        cursor_pos = cursor_pos.saturating_sub(1);
                    }
                    KeyCode::Right => {
                        if cursor_pos < input.len() {
                            cursor_pos += 1;
                        }
                    }
                    KeyCode::Home => {
                        cursor_pos = 0;
                    }
                    KeyCode::End => {
                        cursor_pos = input.len();
                    }
                    _ => {}
                }

                self.render(stdout, &input, cursor_pos)?;
            }
        }
    }

    fn render(&self, stdout: &mut impl Write, input: &str, cursor_pos: usize) -> Result<()> {
        queue!(
            stdout,
            cursor::MoveToColumn(0),
            terminal::Clear(ClearType::CurrentLine),
            Print(&self.prompt),
            Print(" "),
            Print(input),
        )?;

        let col = (self.prompt.len() + 1 + cursor_pos) as u16;
        queue!(stdout, cursor::MoveToColumn(col))?;

        stdout.flush()?;
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use std::sync::mpsc;

    use xacli_testing::{backspaces, type_string, EventBuilder, OutputCapture};

    use super::*;
    use crate::components::{clear_test_event_source, set_test_event_source};

    fn setup_events(events: Vec<Event>) -> mpsc::Sender<Event> {
        let (tx, rx) = mpsc::channel();
        set_test_event_source(rx);
        for event in events {
            tx.send(event).unwrap();
        }
        tx
    }

    #[test]
    fn test_input_basic() {
        let mut events = type_string("Hello");
        events.push(EventBuilder::enter());
        let _tx = setup_events(events);

        let mut output = OutputCapture::new();
        let result = Input::new("Name:").run_with_output(&mut output).unwrap();

        assert_eq!(result, "Hello");
        clear_test_event_source();
    }

    #[test]
    fn test_input_with_default() {
        let _tx = setup_events(vec![EventBuilder::enter()]);

        let mut output = OutputCapture::new();
        let result = Input::new("Name:")
            .default("Alice")
            .run_with_output(&mut output)
            .unwrap();

        assert_eq!(result, "Alice");
        clear_test_event_source();
    }

    #[test]
    fn test_input_replace_default() {
        let mut events = backspaces(5); // Delete "Alice"
        events.extend(type_string("Bob"));
        events.push(EventBuilder::enter());
        let _tx = setup_events(events);

        let mut output = OutputCapture::new();
        let result = Input::new("Name:")
            .default("Alice")
            .run_with_output(&mut output)
            .unwrap();

        assert_eq!(result, "Bob");
        clear_test_event_source();
    }

    #[test]
    fn test_input_cursor_movement() {
        let mut events = type_string("Hllo");
        events.push(EventBuilder::home()); // Go to start
        events.push(EventBuilder::right()); // Move to position 1
        events.extend(type_string("e")); // Insert 'e' -> "Hello"
        events.push(EventBuilder::end()); // Go to end
        events.push(EventBuilder::enter());
        let _tx = setup_events(events);

        let mut output = OutputCapture::new();
        let result = Input::new("Text:").run_with_output(&mut output).unwrap();

        assert_eq!(result, "Hello");
        clear_test_event_source();
    }

    #[test]
    fn test_input_delete() {
        let mut events = type_string("Helllo");
        events.push(EventBuilder::left()); // Move before last 'l'
        events.push(EventBuilder::left());
        events.push(EventBuilder::delete()); // Delete extra 'l'
        events.push(EventBuilder::enter());
        let _tx = setup_events(events);

        let mut output = OutputCapture::new();
        let result = Input::new("Text:").run_with_output(&mut output).unwrap();

        assert_eq!(result, "Hello");
        clear_test_event_source();
    }

    #[test]
    fn test_input_escape_interrupts() {
        let _tx = setup_events(vec![EventBuilder::escape()]);

        let mut output = OutputCapture::new();
        let result = Input::new("Name:").run_with_output(&mut output);

        assert!(matches!(result, Err(ComponentError::Interrupted)));
        clear_test_event_source();
    }

    #[test]
    fn test_input_ctrl_c_interrupts() {
        let _tx = setup_events(vec![EventBuilder::ctrl('c')]);

        let mut output = OutputCapture::new();
        let result = Input::new("Name:").run_with_output(&mut output);

        assert!(matches!(result, Err(ComponentError::Interrupted)));
        clear_test_event_source();
    }
}