23318037125

Committed 19 Mar 2026 09:35PM UTC coverage: 73.681% (-0.02%) from 73.704%

Build # 23318037125

Build Type

push

github

Committed by

web-flow

Commit Message

Adds lua typedefintions file (#1387)

Coverage Stats

9706 of 13173 relevant lines covered (73.68%)

408.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.43

/src/ui/command.rs

use crate::event::QuitMethod;
use crate::model::{Completions, Line, PromptMask, Servers};
use crate::{event::Event, tts::TTSController};
use crate::{lua::LuaScript, lua::UiEvent, session::Session, SaveData};
use log::debug;
use rs_complete::CompletionTree;
use std::collections::HashSet;
use std::{
    io::stdin,
    sync::{mpsc::Sender, Arc, Mutex},
};
use std::{mem, thread};
use termion::{event::Key, input::TermRead};

#[derive(Default)]
struct CompletionStepData {
    options: Vec<String>,
    index: usize,
    base: String,
}

impl CompletionStepData {
    fn is_empty(&self) -> bool {
        self.options.is_empty()
    }

    fn set_options(&mut self, base: &str, options: Vec<String>) {
        self.options = options;
        self.base = base.to_string();
    }

    fn clear(&mut self) {
        self.options.clear();
        self.index = 0;
    }

    fn next(&mut self) -> Option<&String> {
        if !self.is_empty() {
            let last_index = self.index;
            self.index = (self.index + 1) % (self.options.len() + 1);
            self.options.get(last_index).or(Some(&self.base))
        } else {
            None
        }
    }
}

pub struct CommandBuffer {
    buffer: Vec<char>,
    last_buffer: Vec<char>,
    last_command_enabled: bool,
    cursor_pos: usize,
    completion_tree: CompletionTree,
    completion: CompletionStepData,
    prompt_mask: PromptMask,
    script: Arc<Mutex<LuaScript>>,
    tts_ctrl: Arc<Mutex<TTSController>>,
}

impl CommandBuffer {
    pub fn new(
        tts_ctrl: Arc<Mutex<TTSController>>,
        script: Arc<Mutex<LuaScript>>,
        last_command_enabled: bool,
    ) -> Self {
        let mut completion = CompletionTree::with_inclusions(&['/', '_']);
        completion.set_min_word_len(3);

        Self {
            buffer: vec![],
            last_buffer: vec![],
            last_command_enabled,
            cursor_pos: 0,
            completion_tree: completion,
            completion: CompletionStepData::default(),
            prompt_mask: PromptMask::new(),
            script,
            tts_ctrl,
        }
    }

    pub fn get_buffer(&mut self) -> String {
        self.buffer.iter().collect::<String>()
    }

    pub fn get_masked_buffer(&self) -> String {
        self.prompt_mask.mask_buffer(&self.buffer)
    }

    pub fn get_mask(&self) -> &PromptMask {
        &self.prompt_mask
    }

    pub fn get_last_command_mask(&self) -> PromptMask {
        let mut mask = PromptMask::new();
        mask.insert(0, "\x1b[44m".to_string()); // BG blue
        mask.insert(self.last_buffer.len() as i32, "\x1b[0m".to_string());
        mask
    }

    pub fn enable_last_command(&mut self, enabled: bool) {
        self.last_command_enabled = enabled;
        if !enabled {
            self.last_buffer.clear();
        }
    }

    pub fn get_pos(&self) -> usize {
        self.cursor_pos
    }

    fn submit(&mut self) -> String {
        // If we have no buffer then swap in the last buffer
        if self.last_command_enabled && self.buffer.is_empty() {
            mem::swap(&mut self.last_buffer, &mut self.buffer);
        }

        // Insert history
        let cmd = if !self.buffer.is_empty() {
            let command = self.get_buffer();
            self.completion_tree.insert(&command);
            command
        } else {
            String::new()
        };

        if self.last_command_enabled {
            // Clear the last buffer and swap them
            self.last_buffer.clear();
            mem::swap(&mut self.last_buffer, &mut self.buffer);
        } else {
            self.buffer.clear();
        }

        self.clear_mask();
        self.cursor_pos = 0;

        cmd
    }

    fn step_left(&mut self) {
        if self.cursor_pos > 0 {
            self.cursor_pos -= 1;
        }
    }

    fn step_right(&mut self) {
        // Actualize the last buffer if the current is empty
        if self.buffer.is_empty() {
            mem::swap(&mut self.last_buffer, &mut self.buffer);
            self.cursor_pos = self.buffer.len();
        } else if self.cursor_pos < self.buffer.len() {
            self.cursor_pos += 1;
        }
    }

    fn move_to_start(&mut self) {
        self.cursor_pos = 0;
    }

    fn move_to_end(&mut self) {
        self.cursor_pos = self.buffer.len();
    }

    fn step_word_right(&mut self) {
        let origin = (self.cursor_pos + 1).min(self.buffer.len());
        self.cursor_pos = if let Some(pos) = self.buffer[origin..].iter().position(|c| *c == ' ') {
            origin + pos
        } else {
            self.buffer.len()
        }
    }

    fn step_word_left(&mut self) {
        let origin = self.cursor_pos.max(1) - 1;
        self.cursor_pos = if let Some(pos) = self.buffer[0..origin].iter().rposition(|c| *c == ' ')
        {
            pos + 1
        } else {
            0
        }
    }

    fn delete_to_end(&mut self) {
        self.buffer.drain(self.cursor_pos..self.buffer.len());
        self.clear_mask();
    }

    fn delete_from_start(&mut self) {
        self.buffer.drain(0..self.cursor_pos);
        self.cursor_pos = 0;
    }

    fn delete_right(&mut self) {
        if self.cursor_pos < self.buffer.len() {
            self.buffer.remove(self.cursor_pos);
            self.clear_mask();
        }
    }

    fn delete_word_right(&mut self) {
        let origin = self.cursor_pos;
        self.step_word_right();
        if origin != self.cursor_pos {
            self.buffer.drain(origin..self.cursor_pos);
            self.clear_mask();
            self.cursor_pos = origin;
        }
    }

    fn delete_word_left(&mut self) {
        let origin = self.cursor_pos;
        self.step_word_left();
        if origin != self.cursor_pos {
            self.buffer.drain(self.cursor_pos..origin);
            self.clear_mask();
        }
    }

    fn remove(&mut self) -> Option<char> {
        if self.cursor_pos > 0 {
            let removed = if self.cursor_pos < self.buffer.len() {
                Some(self.buffer.remove(self.cursor_pos - 1))
            } else {
                self.buffer.pop()
            };
            self.clear_mask();
            self.step_left();
            removed
        } else {
            None
        }
    }

    fn push_key(&mut self, c: char) {
        if self.cursor_pos >= self.buffer.len() {
            self.buffer.push(c);
        } else {
            self.buffer.insert(self.cursor_pos, c);
        }
        self.clear_mask();
        self.completion.clear();
        self.step_right();
    }

    fn tab_complete(&mut self) {
        if self.buffer.is_empty() {
            // Actualize the last buffer if the current is empty
            mem::swap(&mut self.last_buffer, &mut self.buffer);
            self.cursor_pos = self.buffer.len();
        } else if self.buffer.len() > 1 {
            // Otherwise attempt a tab-complete
            if self.completion.is_empty() {
                let mut completions = Completions::default();
                let strbuf = self.get_buffer();
                completions.merge(self.script.lock().unwrap().tab_complete(&strbuf));
                if let Some(mut options) = self.completion_tree.complete(&strbuf) {
                    completions.add_all(&mut options);
                }

                // Remove duplicates but preserve order of occurence
                let mut occurences: HashSet<&String> = HashSet::new();
                let completions = completions.iter().fold(vec![], |mut acc, word| {
                    if !occurences.contains(word) {
                        acc.push(word.clone());
                    }
                    occurences.insert(word);
                    acc
                });

                self.completion.set_options(&strbuf, completions);
            }
            if let Some(comp) = self.completion.next() {
                self.tts_ctrl.lock().unwrap().speak(comp, true);
                self.buffer = comp.chars().collect();
                self.clear_mask();
                self.cursor_pos = self.buffer.len();
            }
        }
    }

    pub fn clear(&mut self) {
        self.buffer.clear();
        self.clear_mask();
        self.cursor_pos = self.buffer.len();
    }

    pub fn set(&mut self, line: String) {
        self.buffer = line.chars().collect();
        self.clear_mask();
        self.cursor_pos = self.buffer.len();
    }

    pub fn set_pos(&mut self, pos: usize) {
        self.cursor_pos = pos.min(self.buffer.len());
    }

    pub fn set_mask(&mut self, mask: PromptMask) -> &PromptMask {
        self.prompt_mask += mask;
        &self.prompt_mask
    }

    pub fn clear_mask(&mut self) {
        self.prompt_mask.clear();
    }
}

fn parse_mouse_event(event: termion::event::MouseEvent, writer: &Sender<Event>) {
    use termion::event::{MouseButton, MouseEvent};
    match event {
        MouseEvent::Press(MouseButton::WheelUp, ..) => writer.send(Event::ScrollUp).unwrap(),
        MouseEvent::Press(MouseButton::WheelDown, ..) => writer.send(Event::ScrollDown).unwrap(),
        _ => {}
    }
}

fn parse_key_event(
    key: termion::event::Key,
    buffer: &mut CommandBuffer,
    writer: &Sender<Event>,
    tts_ctrl: &mut Arc<Mutex<TTSController>>,
    script: &mut Arc<Mutex<LuaScript>>,
) {
    match key {
        Key::Char('\n') => {
            let mut line = Line::from(buffer.submit());
            line.flags.source = Some("user".to_string());
            writer.send(Event::ServerInput(line)).unwrap();
            if let Ok(mut script) = script.lock() {
                script.set_prompt_content(String::new(), 0);
            }
        }
        Key::Char('\t') => buffer.tab_complete(),
        Key::Char(c) => {
            tts_ctrl.lock().unwrap().key_press(c);
            buffer.push_key(c);
            if let Ok(mut script) = script.lock() {
                script.set_prompt_content(buffer.get_buffer(), buffer.get_pos());
            }
            buffer.last_buffer.clear();
        }
        Key::Ctrl('l') => writer.send(Event::Redraw).unwrap(),
        Key::Ctrl('c') => {
            writer.send(Event::Quit(QuitMethod::CtrlC)).unwrap();
        }

        // Input navigation
        Key::Left => buffer.step_left(),
        Key::Right => buffer.step_right(),
        Key::Backspace => {
            if let Some(c) = buffer.remove() {
                if let Ok(mut tts_ctrl) = tts_ctrl.lock() {
                    tts_ctrl.key_press(c);
                }
            }
            if let Ok(mut script) = script.lock() {
                script.set_prompt_content(buffer.get_buffer(), buffer.get_pos());
            }
            buffer.last_buffer.clear();
        }
        Key::Delete => buffer.delete_right(),
        _ => {}
    };
}

fn check_command_binds(
    cmd: termion::event::Key,
    buffer: &mut CommandBuffer,
    script: &Arc<Mutex<LuaScript>>,
    writer: &Sender<Event>,
) -> bool {
    let mut ran = false;
    if let Ok(mut script) = script.lock() {
        ran = match cmd {
            Key::Ctrl(c) => script.check_bindings(&human_key("ctrl-", c)),
            Key::CtrlUp => script.check_bindings("ctrl-up"),
            Key::CtrlDown => script.check_bindings("ctrl-down"),
            Key::CtrlLeft => script.check_bindings("ctrl-left"),
            Key::CtrlRight => script.check_bindings("ctrl-right"),
            Key::AltUp => script.check_bindings("alt-up"),
            Key::AltDown => script.check_bindings("alt-down"),
            Key::AltLeft => script.check_bindings("alt-left"),
            Key::AltRight => script.check_bindings("alt-right"),
            Key::ShiftUp => script.check_bindings("shift-up"),
            Key::ShiftDown => script.check_bindings("shift-down"),
            Key::ShiftLeft => script.check_bindings("shift-left"),
            Key::ShiftRight => script.check_bindings("shift-right"),
            Key::Alt(c) => script.check_bindings(&human_key("alt-", c)),
            Key::F(n) => script.check_bindings(&format!("f{n}")),
            Key::PageUp => script.check_bindings("pageup") || script.check_bindings("page up"),
            Key::PageDown => {
                script.check_bindings("pagedown") || script.check_bindings("page down")
            }
            Key::Home => script.check_bindings("home"),
            Key::End => script.check_bindings("end"),
            Key::Up => script.check_bindings("up"),
            Key::Down => script.check_bindings("down"),
            _ => false,
        }
    }
    handle_script_ui_io(buffer, script, writer);
    ran
}

/// Convert a key combination to a human-readable form.
fn human_key(prefix: &str, c: char) -> String {
    let mut out = prefix.to_owned();
    match c {
        '\u{7f}' => out.push_str("backspace"),
        '\u{1b}' => out.push_str("escape"),
        _ => out.push(c),
    }
    out
}

fn check_escape_bindings(
    escape: &str,
    buffer: &mut CommandBuffer,
    script: &Arc<Mutex<LuaScript>>,
    writer: &Sender<Event>,
) {
    if let Ok(mut script) = script.lock() {
        if !script.check_bindings(&escape.to_lowercase()) {
            writer
                .send(Event::Info(format!("Unknown command: {escape:?}")))
                .unwrap();
        }
    }
    handle_script_ui_io(buffer, script, writer);
    writer
        .send(Event::UserInputBuffer(
            buffer.get_buffer(),
            buffer.get_pos(),
        ))
        .unwrap();
}

fn handle_script_ui_io(
    buffer: &mut CommandBuffer,
    script: &Arc<Mutex<LuaScript>>,
    writer: &Sender<Event>,
) {
    if let Ok(mut script) = script.lock() {
        script.get_ui_events().iter().for_each(|event| match event {
            UiEvent::StepLeft => buffer.step_left(),
            UiEvent::StepRight => buffer.step_right(),
            UiEvent::StepToStart => buffer.move_to_start(),
            UiEvent::StepToEnd => buffer.move_to_end(),
            UiEvent::StepWordLeft => buffer.step_word_left(),
            UiEvent::StepWordRight => buffer.step_word_right(),
            UiEvent::Remove => {
                buffer.remove();
            }
            UiEvent::DeleteToEnd => buffer.delete_to_end(),
            UiEvent::DeleteFromStart => buffer.delete_from_start(),
            UiEvent::DeleteWordLeft => buffer.delete_word_left(),
            UiEvent::DeleteWordRight => buffer.delete_word_right(),
            UiEvent::DeleteRight => buffer.delete_right(),
            UiEvent::ScrollDown => writer.send(Event::ScrollDown).unwrap(),
            UiEvent::ScrollUp => writer.send(Event::ScrollUp).unwrap(),
            UiEvent::ScrollTop => writer.send(Event::ScrollTop).unwrap(),
            UiEvent::ScrollBottom => writer.send(Event::ScrollBottom).unwrap(),
            UiEvent::Complete => buffer.tab_complete(),
            UiEvent::Unknown(_) => {}
        });
        script.set_prompt_content(buffer.get_buffer(), buffer.get_pos());
        script.get_output_lines().iter().for_each(|l| {
            writer.send(Event::Output(Line::from(l))).unwrap();
        });
    }
}

pub fn spawn_input_thread(session: Session) -> thread::JoinHandle<()> {
    thread::Builder::new()
        .name("input-thread".to_string())
        .spawn(move || {
            debug!("Input stream spawned");
            let writer = session.main_writer.clone();
            let mut script = session.lua_script.clone();
            let stdin = stdin();
            let buffer = session.command_buffer.clone();
            let mut tts_ctrl = session.tts_ctrl;

            if let Ok(mut buffer) = buffer.lock() {
                for server in Servers::load().keys() {
                    buffer.completion_tree.insert(server);
                }
                buffer
                    .completion_tree
                    .insert(include_str!("../../resources/completions.txt"));
            }

            for e in stdin.events() {
                match e.unwrap() {
                    termion::event::Event::Key(key) => {
                        if let Ok(mut buffer) = buffer.lock() {
                            let orig_pos = buffer.get_pos();
                            let orig_len = buffer.buffer.len();
                            let bind_ran = check_command_binds(key, &mut buffer, &script, &writer);
                            if !bind_ran {
                                parse_key_event(
                                    key,
                                    &mut buffer,
                                    &writer,
                                    &mut tts_ctrl,
                                    &mut script,
                                );
                            }
                            if orig_len == buffer.buffer.len() && orig_pos != buffer.get_pos() {
                                writer
                                    .send(Event::UserInputCursor(buffer.get_pos()))
                                    .unwrap();
                            } else if !bind_ran || orig_len != buffer.buffer.len() {
                                if let Ok(mut luascript) = script.lock() {
                                    luascript.set_prompt_mask_content(&buffer.prompt_mask);
                                    luascript
                                        .set_prompt_content(buffer.get_buffer(), buffer.get_pos());
                                }

                                // If 'last command' is applicable then render it.
                                if buffer.buffer.is_empty() && !buffer.last_buffer.is_empty() {
                                    let mask = buffer.get_last_command_mask();
                                    writer
                                        .send(Event::UserInputBuffer(
                                            mask.mask_buffer(&buffer.last_buffer),
                                            0,
                                        ))
                                        .unwrap();
                                } else {
                                    writer
                                        .send(Event::UserInputBuffer(
                                            buffer.get_buffer(),
                                            buffer.get_pos(),
                                        ))
                                        .unwrap();
                                }
                            }
                        }
                    }
                    termion::event::Event::Mouse(event) => parse_mouse_event(event, &writer),
                    termion::event::Event::Unsupported(bytes) => {
                        if let Ok(escape) = String::from_utf8(bytes.clone()) {
                            if let Ok(mut buffer) = buffer.lock() {
                                check_escape_bindings(
                                    &escape.to_lowercase(),
                                    &mut buffer,
                                    &script,
                                    &writer,
                                );
                            }
                        } else {
                            writer
                                .send(Event::Info(format!("Unknown command: {bytes:?}")))
                                .unwrap();
                        }
                    }
                }
            }
            debug!("Input stream closing");
        })
        .unwrap()
}

#[cfg(test)]
mod command_test {

    use std::sync::mpsc::{channel, Receiver, Sender};
    use std::sync::{Arc, Mutex};

    use termion::event::Key;

    use super::check_command_binds;
    use super::CommandBuffer;
    use crate::lua::LuaScriptBuilder;
    use crate::tts::TTSController;
    use crate::Event;

    fn push_string(buffer: &mut CommandBuffer, msg: &str) {
        msg.chars().for_each(|c| buffer.push_key(c));
    }

    fn get_command() -> (CommandBuffer, Receiver<Event>) {
        let (tx, rx): (Sender<Event>, Receiver<Event>) = channel();
        let buffer = CommandBuffer::new(
            Arc::new(Mutex::new(TTSController::new(false, true))),
            Arc::new(Mutex::new(
                LuaScriptBuilder::new(tx).dimensions((100, 100)).build(),
            )),
            false,
        );
        (buffer, rx)
    }

    #[test]
    fn test_editing() {
        let mut buffer = get_command().0;

        push_string(&mut buffer, "test is test");
        assert_eq!(buffer.get_buffer(), "test is test");
        assert_eq!(buffer.get_pos(), 12);
        buffer.step_left();
        buffer.step_left();
        buffer.step_left();
        buffer.step_left();
        buffer.remove();
        buffer.remove();
        buffer.remove();
        buffer.remove();
        assert_eq!(buffer.get_buffer(), "testtest");
        assert_eq!(buffer.get_pos(), 4);
        push_string(&mut buffer, " confirm ");
        assert_eq!(buffer.get_buffer(), "test confirm test");
        assert_eq!(buffer.get_pos(), 13);
    }

    #[test]
    fn test_no_zero_index_remove_crash() {
        let mut buffer = get_command().0;
        buffer.push_key('t');
        buffer.step_left();
        assert_eq!(buffer.get_pos(), 0);
        buffer.remove();
        assert_eq!(buffer.get_pos(), 0);
    }

    #[test]
    fn test_input_navigation() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "some random words");
        buffer.step_word_left();
        assert_eq!(buffer.cursor_pos, 12);
        buffer.step_word_left();
        assert_eq!(buffer.cursor_pos, 5);
        buffer.step_word_left();
        assert_eq!(buffer.cursor_pos, 0);
        buffer.step_word_left();
        assert_eq!(buffer.cursor_pos, 0);
        buffer.step_word_right();
        assert_eq!(buffer.cursor_pos, 4);
        buffer.step_word_right();
        assert_eq!(buffer.cursor_pos, 11);
        buffer.step_word_right();
        assert_eq!(buffer.cursor_pos, 17);
        buffer.step_word_right();
        assert_eq!(buffer.cursor_pos, 17);
    }

    #[test]
    fn test_end_start_navigation() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "some random words");
        buffer.move_to_start();
        assert_eq!(buffer.cursor_pos, 0);
        buffer.move_to_start();
        assert_eq!(buffer.cursor_pos, 0);
        buffer.move_to_end();
        assert_eq!(buffer.cursor_pos, 17);
        buffer.move_to_end();
        assert_eq!(buffer.cursor_pos, 17);
    }

    #[test]
    fn test_delete_rest_of_line() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "some random words");
        buffer.move_to_start();
        buffer.step_word_right();
        buffer.delete_from_start();
        assert_eq!(buffer.get_buffer(), " random words");
    }

    #[test]
    fn test_delete_from_start_of_line() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "some random words");
        buffer.move_to_start();
        buffer.step_word_right();
        buffer.step_word_right();
        buffer.delete_to_end();
        assert_eq!(buffer.get_buffer(), "some random");
    }

    #[test]
    fn test_delete_right() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "some random words");
        buffer.move_to_start();
        buffer.step_word_right();
        buffer.delete_right();
        assert_eq!(buffer.get_buffer(), "somerandom words");
        buffer.delete_right();
        assert_eq!(buffer.get_buffer(), "someandom words");
        buffer.move_to_end();
        buffer.delete_right();
        assert_eq!(buffer.get_buffer(), "someandom words");
    }

    #[test]
    fn test_delete_word_left() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "some random words");
        buffer.move_to_end();
        buffer.delete_word_left();
        assert_eq!(buffer.get_buffer(), "some random ");
        buffer.move_to_start();
        buffer.step_word_right();
        buffer.delete_word_left();
        assert_eq!(buffer.get_buffer(), " random ");
    }

    #[test]
    fn test_delete_word_right() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "some random words");
        buffer.move_to_start();
        buffer.delete_word_right();
        assert_eq!(buffer.get_buffer(), " random words");
        buffer.delete_word_right();
        assert_eq!(buffer.get_buffer(), " words");
    }

    #[test]
    fn test_fancy_chars() {
        let mut buffer = get_command().0;
        let input = "some weird chars: ÅÖÄø æĸœ→ €ßðßª“";
        push_string(&mut buffer, input);
        assert_eq!(input.chars().count(), buffer.buffer.len());
        assert_ne!(input.len(), buffer.buffer.len());
        assert_eq!(buffer.get_buffer().len(), input.len());
    }

    #[test]
    fn test_human_key() {
        use super::human_key;

        assert_eq!(human_key("alt-", '\u{7f}'), "alt-backspace");
        assert_eq!(human_key("ctrl-", '\u{7f}'), "ctrl-backspace");
        assert_eq!(human_key("alt-", '\u{1b}'), "alt-escape");
        assert_eq!(human_key("ctrl-", '\u{1b}'), "ctrl-escape");
        assert_eq!(human_key("ctrl-", 'd'), "ctrl-d");
        assert_eq!(human_key("f", 'x'), "fx");
    }

    #[test]
    fn test_completions() {
        let mut buffer = get_command().0;
        push_string(&mut buffer, "batman");
        buffer.submit();
        push_string(&mut buffer, "bat");
        buffer.tab_complete();
        assert_eq!(buffer.completion.options, vec!["batman".to_string()]);
    }

    #[test]
    fn test_completion_with_big_chars() {
        // Issue #522
        let mut buffer = get_command().0;
        push_string(&mut buffer, "fend");
        buffer.completion.options = vec!["fender🎸".to_string()];
        buffer.tab_complete();
        assert_eq!(buffer.completion.options, vec!["fender🎸".to_string()]);
        assert_eq!(buffer.buffer, vec!['f', 'e', 'n', 'd', 'e', 'r', '🎸']);
        assert_eq!(buffer.cursor_pos, 7);
    }

    #[test]
    fn test_pos_cursor() {
        let mut buffer = get_command().0;
        let input = "Gibson Les Paul";
        push_string(&mut buffer, input);
        assert_eq!(buffer.get_pos(), input.len());
        buffer.set_pos(1000);
        assert_eq!(buffer.get_pos(), input.len());
        buffer.set_pos(0);
        assert_eq!(buffer.get_pos(), 0);
        buffer.set_pos(2);
        assert_eq!(buffer.get_pos(), 2);
        buffer.clear();
        assert_eq!(buffer.get_pos(), 0);
        push_string(&mut buffer, input);
        assert_eq!(buffer.get_pos(), input.len());
    }

    #[test]
    fn test_lua_key_binds() {
        let tts = Arc::new(Mutex::new(TTSController::new(false, false)));

        let (tx, _rx): (Sender<Event>, Receiver<Event>) = channel();
        let script = Arc::new(Mutex::new(
            LuaScriptBuilder::new(tx.clone())
                .dimensions((100, 100))
                .build(),
        ));
        let mut buffer = CommandBuffer::new(tts, script.clone(), false);

        assert!(check_command_binds(
            Key::Alt('b'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Alt('f'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Alt('d'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Alt('\u{7f}'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('a'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('b'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('e'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('f'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('d'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('h'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('k'),
            &mut buffer,
            &script,
            &tx
        ));
        assert!(check_command_binds(
            Key::Ctrl('u'),
            &mut buffer,
            &script,
            &tx
        ));

        assert!(check_command_binds(Key::Home, &mut buffer, &script, &tx));
        assert!(check_command_binds(Key::End, &mut buffer, &script, &tx));
        assert!(check_command_binds(Key::PageUp, &mut buffer, &script, &tx));
        assert!(check_command_binds(
            Key::PageDown,
            &mut buffer,
            &script,
            &tx
        ));
    }

    fn get_command_with_last() -> (CommandBuffer, Receiver<Event>) {
        let (tx, rx): (Sender<Event>, Receiver<Event>) = channel();
        let buffer = CommandBuffer::new(
            Arc::new(Mutex::new(TTSController::new(false, true))),
            Arc::new(Mutex::new(
                LuaScriptBuilder::new(tx).dimensions((100, 100)).build(),
            )),
            true,
        );
        (buffer, rx)
    }

    #[test]
    fn test_last_command_stored_after_submit() {
        let mut buffer = get_command_with_last().0;
        push_string(&mut buffer, "hello");
        buffer.submit();
        // buffer should be empty, last_buffer should hold the command
        assert!(buffer.buffer.is_empty());
        assert_eq!(buffer.last_buffer.iter().collect::<String>(), "hello");
    }

    #[test]
    fn test_last_command_replayed_on_empty_submit() {
        let mut buffer = get_command_with_last().0;
        push_string(&mut buffer, "hello");
        buffer.submit();
        // submit again with empty buffer — should replay last command
        let replayed = buffer.submit();
        assert_eq!(replayed, "hello");
    }

    #[test]
    fn test_last_command_updates_on_new_submit() {
        let mut buffer = get_command_with_last().0;
        push_string(&mut buffer, "first");
        buffer.submit();
        push_string(&mut buffer, "second");
        buffer.submit();
        assert_eq!(buffer.last_buffer.iter().collect::<String>(), "second");
    }

    #[test]
    fn test_last_command_disabled_clears_last_buffer() {
        let mut buffer = get_command_with_last().0;
        push_string(&mut buffer, "hello");
        buffer.submit();
        assert!(!buffer.last_buffer.is_empty());
        buffer.enable_last_command(false);
        assert!(buffer.last_buffer.is_empty());
        assert!(!buffer.last_command_enabled);
    }

    #[test]
    fn test_last_command_enabled_sets_flag() {
        let mut buffer = get_command().0;
        assert!(!buffer.last_command_enabled);
        buffer.enable_last_command(true);
        assert!(buffer.last_command_enabled);
    }

    #[test]
    fn test_step_right_expands_last_command() {
        let mut buffer = get_command_with_last().0;
        push_string(&mut buffer, "hello");
        buffer.submit();
        assert!(buffer.buffer.is_empty());
        // step_right on empty buffer should swap in last_buffer
        buffer.step_right();
        assert_eq!(buffer.get_buffer(), "hello");
        assert_eq!(buffer.cursor_pos, "hello".len());
    }

    #[test]
    fn test_last_command_mask_covers_full_buffer() {
        let mut buffer = get_command_with_last().0;
        push_string(&mut buffer, "hello");
        buffer.submit();
        let mask = buffer.get_last_command_mask();
        // mask should have entries at 0 (open) and len of last_buffer (close)
        assert!(mask.contains_key(&0));
        assert!(mask.contains_key(&(buffer.last_buffer.len() as i32)));
    }

    #[test]
    fn test_last_command_not_stored_when_disabled() {
        let mut buffer = get_command().0; // last_command_enabled = false
        push_string(&mut buffer, "hello");
        buffer.submit();
        assert!(buffer.last_buffer.is_empty());
        assert!(buffer.buffer.is_empty());
    }

    #[test]
    fn test_last_command_empty_submit_when_disabled() {
        let mut buffer = get_command().0; // last_command_enabled = false
        push_string(&mut buffer, "hello");
        buffer.submit();
        // empty submit should return empty string, not replay last
        let result = buffer.submit();
        assert_eq!(result, String::new());
    }
}

Blightmud / Blightmud / 23318037125

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous