helix: add basic mode switching

Author: schlich

examples/helix.rs

@@ -11,7 +11,7 @@ fn main() -> io::Result<()> {
     println!("Helix edit mode demo:\nAbort with Ctrl-C");
 
     let prompt = DefaultPrompt::default();
-    let mut line_editor = Reedline::create().with_edit_mode(Box::new(Helix));
+    let mut line_editor = Reedline::create().with_edit_mode(Box::new(Helix::default()));
 
     loop {
         let sig = line_editor.read_line(&prompt)?;

src/edit_mode/helix.rs

@@ -1,64 +1,114 @@
 use crate::{
-    enums::{EventStatus, ReedlineEvent, ReedlineRawEvent},
+    edit_mode::EditMode,
+    enums::{ReedlineEvent, ReedlineRawEvent},
     PromptEditMode, PromptViMode,
 };
 use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
 
-use super::EditMode;
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+enum HelixMode {
+    #[default]
+    Insert,
+    Normal,
+}
 
 /// A minimal custom edit mode example for Helix-style integrations.
 #[derive(Default)]
-pub struct Helix;
+pub struct Helix {
+    mode: HelixMode,
+}
+
+impl Helix {
+    #[cfg(test)]
+    pub(crate) fn insert() -> Self {
+        Self {
+            mode: HelixMode::Insert,
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn normal() -> Self {
+        Self {
+            mode: HelixMode::Normal,
+        }
+    }
+}
 
 impl EditMode for Helix {
     fn parse_event(&mut self, event: ReedlineRawEvent) -> ReedlineEvent {
-        match Event::from(event) {
+        match event.into() {
             Event::Key(KeyEvent {
-                code: KeyCode::Char('c'),
-                modifiers: KeyModifiers::CONTROL,
-                ..
-            }) => ReedlineEvent::CtrlC,
+                code, modifiers, ..
+            }) => match (self.mode, modifiers, code) {
+                (_, KeyModifiers::CONTROL, KeyCode::Char('c')) => ReedlineEvent::CtrlC,
+                (HelixMode::Insert, _, KeyCode::Esc) => {
+                    self.mode = HelixMode::Normal;
+                    ReedlineEvent::Repaint
+                }
+                (HelixMode::Normal, _, KeyCode::Char('i')) => {
+                    self.mode = HelixMode::Insert;
+                    ReedlineEvent::Repaint
+                }
+                _ => ReedlineEvent::None,
+            },
             _ => ReedlineEvent::None,
         }
     }
 
     fn edit_mode(&self) -> PromptEditMode {
-        PromptEditMode::Vi(PromptViMode::Normal)
-    }
-
-    fn handle_mode_specific_event(&mut self, _event: ReedlineEvent) -> EventStatus {
-        EventStatus::Inapplicable
+        match self.mode {
+            HelixMode::Insert => PromptEditMode::Vi(PromptViMode::Insert),
+            HelixMode::Normal => PromptEditMode::Vi(PromptViMode::Normal),
+        }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::PromptViMode;
+    use crossterm::event::{KeyEventKind, KeyEventState};
 
-    #[test]
-    fn helix_edit_mode_defaults_to_normal_mode() {
-        let helix_mode = Helix;
+    fn key_press(code: KeyCode, modifiers: KeyModifiers) -> ReedlineRawEvent {
+        Event::Key(KeyEvent {
+            code,
+            modifiers,
+            kind: KeyEventKind::Press,
+            state: KeyEventState::NONE,
+        })
+        .try_into()
+        .unwrap()
+    }
 
-        let edit_mode = helix_mode.edit_mode();
+    #[test]
+    fn helix_editor_defaults_to_insert_mode() {
+        let helix_editor = Helix::default();
 
-        assert!(matches!(
-            edit_mode,
-            PromptEditMode::Vi(PromptViMode::Normal)
-        ));
+        assert_eq!(helix_editor.mode, HelixMode::Insert);
     }
 
     #[test]
-    fn helix_edit_mode_parses_ctrl_c_event() {
-        let mut helix_mode = Helix;
-        let ctrl_c_raw_event = ReedlineRawEvent::try_from(Event::Key(KeyEvent::new(
-            KeyCode::Char('c'),
-            KeyModifiers::CONTROL,
-        )));
+    fn normal_mode_parses_ctrl_c_event() {
+        let mut helix_mode = Helix::normal();
 
         assert_eq!(
-            helix_mode.parse_event(ctrl_c_raw_event.unwrap()),
+            helix_mode.parse_event(key_press(KeyCode::Char('c'), KeyModifiers::CONTROL)),
             ReedlineEvent::CtrlC
         );
     }
+
+    #[test]
+    fn pressing_esc_in_insert_mode_switches_to_normal() {
+        let mut helix_mode = Helix::insert();
+        helix_mode.parse_event(key_press(KeyCode::Esc, KeyModifiers::NONE));
+
+        assert_eq!(helix_mode.mode, HelixMode::Normal);
+    }
+
+    #[test]
+    fn pressing_i_in_normal_mode_switches_to_insert() {
+        let mut helix_mode = Helix::normal();
+        helix_mode.parse_event(key_press(KeyCode::Char('i'), KeyModifiers::NONE));
+
+        assert_eq!(helix_mode.mode, HelixMode::Insert);
+    }
 }

src/engine.rs

@@ -2320,11 +2320,11 @@ mod tests {
     fn with_edit_mode_builder_accepts_custom_helix_mode() {
         use crate::PromptViMode;
 
-        let reedline = Reedline::create().with_edit_mode(Box::new(crate::Helix));
+        let reedline = Reedline::create().with_edit_mode(Box::new(crate::Helix::insert()));
 
         assert!(matches!(
             reedline.prompt_edit_mode(),
-            PromptEditMode::Vi(PromptViMode::Normal)
+            PromptEditMode::Vi(PromptViMode::Insert)
         ));
     }