use crate::core::Extension;
use crate::extensions::keymap::Keymap;
use crate::extensions::keymap_registry::KeymapRegistry;
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
use runact::Runtime;
use std::any::Any;
#[allow(dead_code)]
pub struct ViInputExtension {
mode: EditorMode,
command_buffer: String,
last_command: Option<String>,
visual_mode: Option<VisualMode>,
selection_start: Option<(usize, usize)>,
clipboard: Option<String>,
normal_keymap: Keymap,
insert_keymap: Keymap,
visual_keymap: Keymap,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EditorMode {
Basic,
Normal,
Insert,
Command,
Search,
Terminal,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VisualMode {
Char,
Line,
}
impl Extension for ViInputExtension {
fn name(&self) -> &str {
"vi-input"
}
fn init(&mut self, _runtime: &mut Runtime) -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
fn shutdown(&mut self, _runtime: &mut Runtime) -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
fn on_key(&mut self, _ch: char) -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
fn on_render(&mut self, _runtime: &Runtime) -> Result<(), Box<dyn std::error::Error>> {
Ok(())
}
fn as_any(&self) -> &dyn Any {
self
}
fn as_any_mut(&mut self) -> &mut dyn Any {
self
}
}
#[allow(dead_code)]
impl ViInputExtension {
pub fn new() -> Self {
let mut normal_keymap = Keymap::new("normal");
normal_keymap.load_defaults();
let mut insert_keymap = Keymap::new("insert");
insert_keymap.load_defaults();
let mut visual_keymap = Keymap::new("visual");
visual_keymap.load_defaults();
Self {
mode: EditorMode::Basic,
command_buffer: String::new(),
last_command: None,
visual_mode: None,
selection_start: None,
clipboard: None,
normal_keymap,
insert_keymap,
visual_keymap,
}
}
pub fn mode(&self) -> EditorMode {
self.mode
}
pub fn command_buffer(&self) -> &str {
&self.command_buffer
}
pub fn visual_mode(&self) -> Option<VisualMode> {
self.visual_mode
}
pub fn selection_start(&self) -> Option<(usize, usize)> {
self.selection_start
}
pub fn is_in_visual_mode(&self) -> bool {
self.visual_mode.is_some()
}
pub fn register_layers(&self, reg: &mut KeymapRegistry) {
reg.register(self.normal_keymap.to_layer("vi-normal", 20, "normal"));
reg.register(self.insert_keymap.to_layer("vi-insert", 20, "insert"));
reg.register(self.visual_keymap.to_layer("vi-visual", 20, "visual"));
}
pub fn handle_char_key(&mut self, ch: char) -> Option<String> {
if let Some(_vm) = self.visual_mode {
return self.handle_visual_key(ch);
}
match self.mode {
EditorMode::Insert => {
if ch == '\x1b' {
self.mode = EditorMode::Normal;
return None;
}
let key = Self::char_to_key_event(ch);
if let Some(cmd) = self.insert_keymap.resolve(&key) {
return Some(cmd.to_string());
}
if ch.is_control() {
return None;
}
Some(format!("insert {}", ch))
}
EditorMode::Basic => match ch {
'i' => {
self.mode = EditorMode::Insert;
None
}
':' => {
self.mode = EditorMode::Command;
self.command_buffer.clear();
None
}
'/' => {
self.mode = EditorMode::Search;
self.command_buffer.clear();
None
}
_ => None,
},
EditorMode::Normal => self.handle_normal_mode_key(ch),
EditorMode::Command => {
if ch == '\r' || ch == '\n' {
let cmd = self.command_buffer.clone();
self.command_buffer.clear();
self.mode = EditorMode::Normal;
self.last_command = Some(cmd.clone());
Some(cmd)
} else if ch == '\x08' || ch == '\x7f' {
self.command_buffer.pop();
None
} else if ch == '\x1b' {
self.command_buffer.clear();
self.mode = EditorMode::Normal;
None
} else if ch.is_control() {
None
} else {
self.command_buffer.push(ch);
None
}
}
EditorMode::Search => {
if ch == '\r' || ch == '\n' {
let pattern = self.command_buffer.clone();
self.command_buffer.clear();
self.mode = EditorMode::Normal;
self.last_command = Some(pattern.clone());
Some(format!("search {}", pattern))
} else if ch == '\x08' || ch == '\x7f' {
self.command_buffer.pop();
None
} else if ch == '\x1b' {
self.command_buffer.clear();
self.mode = EditorMode::Normal;
None
} else if ch.is_control() {
None
} else {
self.command_buffer.push(ch);
None
}
}
EditorMode::Terminal => {
if ch == '\x1b' {
self.mode = EditorMode::Normal;
}
None
}
}
}
fn handle_normal_mode_key(&mut self, ch: char) -> Option<String> {
match ch {
'v' => {
self.visual_mode = Some(VisualMode::Char);
self.selection_start = None;
return None;
}
'V' => {
self.visual_mode = Some(VisualMode::Line);
self.selection_start = None;
return None;
}
_ => {}
}
match ch {
'i' => {
self.mode = EditorMode::Insert;
return None;
}
':' => {
self.mode = EditorMode::Command;
self.command_buffer.clear();
return None;
}
'/' => {
self.mode = EditorMode::Search;
self.command_buffer.clear();
return None;
}
_ => {}
}
let key = Self::char_to_key_event(ch);
if let Some(cmd) = self.normal_keymap.resolve(&key) {
return Some(cmd.to_string());
}
None
}
fn handle_visual_key(&mut self, ch: char) -> Option<String> {
if ch == '\x1b' {
self.visual_mode = None;
self.selection_start = None;
return Some("escape".to_string());
}
let key = Self::char_to_key_event(ch);
if let Some(cmd) = self.visual_keymap.resolve(&key) {
match cmd {
"delete-selection" => {
let _ = self.cut_selection();
self.visual_mode = None;
self.selection_start = None;
return Some("delete".to_string());
}
"yank-selection" => {
let _ = self.yank_selection();
self.visual_mode = None;
self.selection_start = None;
return Some("yank".to_string());
}
_ => return Some(cmd.to_string()),
}
}
None
}
fn yank_selection(&self) -> bool {
self.selection_start.is_some()
}
fn cut_selection(&self) -> bool {
self.selection_start.is_some()
}
fn char_to_key_event(ch: char) -> KeyEvent {
use KeyCode::*;
match ch {
'\x1b' => KeyEvent::new(Esc, KeyModifiers::NONE),
'\r' | '\n' => KeyEvent::new(Enter, KeyModifiers::NONE),
'\x08' | '\x7f' => KeyEvent::new(Backspace, KeyModifiers::NONE),
'\t' => KeyEvent::new(Tab, KeyModifiers::NONE),
c if c.is_ascii_uppercase() => KeyEvent::new(KeyCode::Char(c), KeyModifiers::SHIFT),
c if "!@#$%^&*()_+{}|:\"<>?~".contains(c) => {
KeyEvent::new(KeyCode::Char(c), KeyModifiers::SHIFT)
}
c => KeyEvent::new(KeyCode::Char(c), KeyModifiers::NONE),
}
}
pub fn set_selection_start(&mut self, row: usize, col: usize) {
self.selection_start = Some((row, col));
}
pub fn set_clipboard(&mut self, text: String) {
self.clipboard = Some(text);
}
pub fn take_clipboard(&mut self) -> Option<String> {
self.clipboard.take()
}
pub fn set_mode(&mut self, mode: EditorMode) {
self.mode = mode;
}
pub fn take_last_command(&mut self) -> Option<String> {
self.last_command.take()
}
}
#[allow(dead_code)]
pub fn search_forward(
lines: &[&str],
start_row: usize,
start_col: usize,
pattern: &str,
) -> Option<(usize, usize)> {
if pattern.is_empty() {
return None;
}
if let Some(line) = lines.get(start_row) {
if let Some(pos) = line[start_col..].find(pattern) {
return Some((start_row, start_col + pos));
}
}
for row in (start_row + 1)..lines.len() {
if let Some(pos) = lines.get(row).and_then(|l| l.find(pattern)) {
return Some((row, pos));
}
}
None
}
#[allow(dead_code)]
pub fn search_backward(
lines: &[&str],
start_row: usize,
start_col: usize,
pattern: &str,
) -> Option<(usize, usize)> {
if pattern.is_empty() {
return None;
}
if let Some(line) = lines.get(start_row) {
let prefix = &line[..start_col.min(line.len())];
if let Some(pos) = prefix.rfind(pattern) {
return Some((start_row, pos));
}
}
for row in (0..start_row).rev() {
if let Some(pos) = lines.get(row).and_then(|l| l.rfind(pattern)) {
return Some((row, pos));
}
}
None
}
impl Default for ViInputExtension {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_new_extension_starts_basic() {
let ext = ViInputExtension::new();
assert_eq!(ext.mode(), EditorMode::Basic);
assert!(!ext.is_in_visual_mode());
}
#[test]
fn test_enter_visual_char_mode() {
let mut ext = ViInputExtension::new();
ext.set_mode(EditorMode::Normal);
ext.handle_char_key('v');
assert!(ext.is_in_visual_mode());
assert_eq!(ext.visual_mode(), Some(VisualMode::Char));
}
#[test]
fn test_enter_visual_line_mode() {
let mut ext = ViInputExtension::new();
ext.set_mode(EditorMode::Normal);
ext.handle_char_key('V');
assert!(ext.is_in_visual_mode());
assert_eq!(ext.visual_mode(), Some(VisualMode::Line));
}
#[test]
fn test_visual_mode_escape_exits() {
let mut ext = ViInputExtension::new();
ext.set_mode(EditorMode::Normal);
ext.handle_char_key('v');
assert!(ext.is_in_visual_mode());
let cmd = ext.handle_char_key('\x1b');
assert!(!ext.is_in_visual_mode());
assert_eq!(cmd, Some("escape".to_string()));
}
#[test]
fn test_visual_mode_yank() {
let mut ext = ViInputExtension::new();
ext.set_mode(EditorMode::Normal);
ext.handle_char_key('v');
ext.set_selection_start(0, 0);
let cmd = ext.handle_char_key('y');
assert!(!ext.is_in_visual_mode());
assert_eq!(cmd, Some("yank".to_string()));
}
#[test]
fn test_visual_mode_delete() {
let mut ext = ViInputExtension::new();
ext.set_mode(EditorMode::Normal);
ext.handle_char_key('v');
ext.set_selection_start(0, 0);
let cmd = ext.handle_char_key('d');
assert!(!ext.is_in_visual_mode());
assert_eq!(cmd, Some("delete".to_string()));
}
#[test]
fn test_visual_mode_movement() {
let mut ext = ViInputExtension::new();
ext.set_mode(EditorMode::Normal);
ext.handle_char_key('v');
assert_eq!(ext.handle_char_key('h'), Some("left".to_string()));
assert_eq!(ext.handle_char_key('j'), Some("down".to_string()));
assert_eq!(ext.handle_char_key('k'), Some("up".to_string()));
assert_eq!(ext.handle_char_key('l'), Some("right".to_string()));
}
#[test]
fn test_normal_mode_hjkl_commands() {
let mut ext = ViInputExtension::new();
ext.handle_char_key('i');
ext.handle_char_key('\x1b');
assert_eq!(ext.mode(), EditorMode::Normal);
assert_eq!(ext.handle_char_key('h'), Some("left".to_string()));
assert_eq!(ext.handle_char_key('j'), Some("down".to_string()));
assert_eq!(ext.handle_char_key('k'), Some("up".to_string()));
assert_eq!(ext.handle_char_key('l'), Some("right".to_string()));
}
#[test]
fn test_insert_mode_escape_returns_normal() {
let mut ext = ViInputExtension::new();
ext.handle_char_key('i');
assert_eq!(ext.mode(), EditorMode::Insert);
let cmd = ext.handle_char_key('\x1b');
assert!(cmd.is_none());
assert_eq!(ext.mode(), EditorMode::Normal);
}
#[test]
fn test_insert_mode_characters() {
let mut ext = ViInputExtension::new();
ext.handle_char_key('i');
assert_eq!(ext.handle_char_key('a'), Some("insert a".to_string()));
assert_eq!(ext.handle_char_key('b'), Some("insert b".to_string()));
assert_eq!(ext.handle_char_key('x'), Some("insert x".to_string()));
}
#[test]
fn test_insert_mode_enter_newline() {
let mut ext = ViInputExtension::new();
ext.handle_char_key('i');
assert_eq!(ext.mode(), EditorMode::Insert);
assert_eq!(ext.handle_char_key('\r'), Some("newline".to_string()));
assert_eq!(ext.handle_char_key('\n'), Some("newline".to_string()));
}
#[test]
fn test_insert_mode_backspace_delete() {
let mut ext = ViInputExtension::new();
ext.handle_char_key('i');
assert_eq!(ext.handle_char_key('\x08'), Some("delete".to_string()));
assert_eq!(ext.handle_char_key('\x7f'), Some("delete".to_string()));
}
#[test]
fn test_insert_mode_tab_inserts() {
let mut ext = ViInputExtension::new();
ext.handle_char_key('i');
assert_eq!(ext.handle_char_key('\t'), Some("insert-tab".to_string()));
}
#[test]
fn test_insert_mode_other_control_chars_ignored() {
let mut ext = ViInputExtension::new();
ext.handle_char_key('i');
assert_eq!(ext.handle_char_key('\x01'), None);
assert_eq!(ext.handle_char_key('\x02'), None);
}
#[test]
fn test_command_mode() {
let mut ext = ViInputExtension::new();
ext.set_mode(EditorMode::Normal);
assert!(ext.handle_char_key(':').is_none());
assert_eq!(ext.mode(), EditorMode::Command);
ext.handle_char_key('w');
let cmd = ext.handle_char_key('\r');
assert_eq!(cmd, Some("w".to_string()));
assert_eq!(ext.mode(), EditorMode::Normal);
}
#[test]
fn test_visual_mode_paste() {
let mut ext = ViInputExtension::new();
ext.set_clipboard("test".to_string());
assert_eq!(ext.take_clipboard(), Some("test".to_string()));
assert_eq!(ext.take_clipboard(), None);
}
}