feat: support multiline cell editing

Author: uednd

src/main.rs

@@ -10,15 +10,92 @@ mod screen;
 mod theme;
 mod widget;
 
+fn keyboard_enhancement_flags() -> crossterm::event::KeyboardEnhancementFlags {
+    crossterm::event::KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+}
+
+fn enable_keyboard_enhancement() -> bool {
+    crossterm::execute!(
+        std::io::stdout(),
+        crossterm::event::PushKeyboardEnhancementFlags(keyboard_enhancement_flags())
+    )
+    .is_ok()
+}
+
+struct TerminalInputGuard {
+    keyboard_enhancement_enabled: bool,
+    mouse_capture_enabled: bool,
+}
+
+impl TerminalInputGuard {
+    fn enter() -> std::io::Result<Self> {
+        let mut guard = Self {
+            keyboard_enhancement_enabled: enable_keyboard_enhancement(),
+            mouse_capture_enabled: false,
+        };
+
+        crossterm::execute!(std::io::stdout(), crossterm::event::EnableMouseCapture)?;
+        guard.mouse_capture_enabled = true;
+
+        Ok(guard)
+    }
+
+    fn leave(mut self) -> std::io::Result<()> {
+        let mouse_cleanup = self.disable_mouse_capture();
+        let keyboard_cleanup = self.disable_keyboard_enhancement();
+
+        mouse_cleanup.and(keyboard_cleanup)
+    }
+
+    fn disable_mouse_capture(&mut self) -> std::io::Result<()> {
+        if !self.mouse_capture_enabled {
+            return Ok(());
+        }
+
+        self.mouse_capture_enabled = false;
+        crossterm::execute!(std::io::stdout(), crossterm::event::DisableMouseCapture)
+    }
+
+    fn disable_keyboard_enhancement(&mut self) -> std::io::Result<()> {
+        if !self.keyboard_enhancement_enabled {
+            return Ok(());
+        }
+
+        self.keyboard_enhancement_enabled = false;
+        crossterm::execute!(
+            std::io::stdout(),
+            crossterm::event::PopKeyboardEnhancementFlags
+        )
+    }
+}
+
+impl Drop for TerminalInputGuard {
+    fn drop(&mut self) {
+        let _ = self.disable_mouse_capture();
+        let _ = self.disable_keyboard_enhancement();
+    }
+}
+
 fn main() -> color_eyre::Result<()> {
     color_eyre::install()?;
     let initial_file = std::env::args().nth(1);
     let mut app = app::App::new(initial_file);
     ratatui::run(|terminal| {
-        crossterm::execute!(std::io::stdout(), crossterm::event::EnableMouseCapture)?;
+        let terminal_input = TerminalInputGuard::enter()?;
         let result = app.run(terminal);
-        crossterm::execute!(std::io::stdout(), crossterm::event::DisableMouseCapture)?;
-        result
+
+        result.and(terminal_input.leave())
     })?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn keyboard_enhancement_disambiguates_modified_enter() {
+        assert!(
+            super::keyboard_enhancement_flags()
+                .contains(crossterm::event::KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES)
+        );
+    }
+}

src/screen/editor/edit.rs

@@ -1,9 +1,9 @@
-use crossterm::event::{KeyCode, KeyEvent};
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 use ratatui::{
     Frame,
     layout::{Constraint, Layout, Rect},
     style::Style,
-    text::Line,
+    text::{Line, Span},
     widgets::Paragraph,
 };
 
@@ -19,6 +19,10 @@ pub struct EditMode {
     buffer: String,
 }
 
+const MIN_EDIT_AREA_HEIGHT: u16 = 1;
+const EDIT_LABEL: &str = "编辑: ";
+const EDIT_CONTINUATION_PREFIX: &str = "      ";
+
 impl EditMode {
     pub fn new(initial: String, initial_char: Option<char>) -> Self {
         let mut buffer = initial;
@@ -36,6 +40,10 @@ impl Mode for EditMode {
 
     fn handle_key(&mut self, _view: EditorView<'_>, key: KeyEvent) -> ModeResult {
         match key.code {
+            KeyCode::Enter if key.modifiers.contains(KeyModifiers::SHIFT) => {
+                self.buffer.push('\n');
+                EventResult::Handled
+            }
             KeyCode::Enter => EventResult::Command(EditorIntent::CommitEdit(self.buffer.clone())),
             KeyCode::Esc => {
                 EventResult::Command(EditorIntent::SwitchMode(Box::new(NavigationMode)))
@@ -53,33 +61,12 @@ impl Mode for EditMode {
     }
 
     fn render(&self, frame: &mut Frame, area: Rect, read: EditorReadModel<'_>) -> Rect {
-        use ratatui::text::Span;
-
+        let edit_area_height = self.edit_area_height(area.height);
         let [table_area, edit_area] =
-            Layout::vertical([Constraint::Fill(1), Constraint::Length(1)]).areas(area);
+            Layout::vertical([Constraint::Fill(1), Constraint::Length(edit_area_height)])
+                .areas(area);
 
-        let mut spans = vec![Span::styled(
-            "编辑: ",
-            Style::default().fg(read.theme.accent),
-        )];
-        if self.buffer.is_empty() {
-            spans.push(Span::styled(
-                "(空)",
-                Style::default().fg(read.theme.text_dim),
-            ));
-        } else {
-            spans.push(Span::styled(
-                self.buffer.as_str(),
-                Style::default().fg(read.theme.text),
-            ));
-            let cursor_char = if read.blink_visible { "█" } else { " " };
-            spans.push(Span::styled(
-                cursor_char,
-                Style::default().fg(read.theme.text),
-            ));
-        }
-
-        frame.render_widget(Paragraph::new(Line::from(spans)), edit_area);
+        frame.render_widget(Paragraph::new(self.render_lines(read)), edit_area);
         table_area
     }
 
@@ -94,6 +81,9 @@ impl Mode for EditMode {
                 Span::styled("Enter", Style::default().fg(read.theme.accent)),
                 Span::styled(" 确认", Style::default().fg(read.theme.text_dim)),
                 Span::styled("  ", Style::default().fg(read.theme.text_dim)),
+                Span::styled("Shift+Enter", Style::default().fg(read.theme.accent)),
+                Span::styled(" 换行", Style::default().fg(read.theme.text_dim)),
+                Span::styled("  ", Style::default().fg(read.theme.text_dim)),
                 Span::styled("Esc", Style::default().fg(read.theme.accent)),
                 Span::styled(" 取消", Style::default().fg(read.theme.text_dim)),
             ])),
@@ -109,3 +99,157 @@ impl Mode for EditMode {
         }
     }
 }
+
+impl EditMode {
+    fn edit_area_height(&self, available_height: u16) -> u16 {
+        let needed_height = self
+            .buffer
+            .split('\n')
+            .count()
+            .max(MIN_EDIT_AREA_HEIGHT as usize) as u16;
+        needed_height.min(available_height)
+    }
+
+    fn render_lines(&self, read: EditorReadModel<'_>) -> Vec<Line<'static>> {
+        if self.buffer.is_empty() {
+            return vec![Line::from(vec![
+                Span::styled(EDIT_LABEL, Style::default().fg(read.theme.accent)),
+                Span::styled("(空)", Style::default().fg(read.theme.text_dim)),
+            ])];
+        }
+
+        let cursor_char = if read.blink_visible { "█" } else { " " };
+        let mut lines = Vec::new();
+        let parts: Vec<&str> = self.buffer.split('\n').collect();
+        for (index, part) in parts.iter().enumerate() {
+            let is_first = index == 0;
+            let is_last = index + 1 == parts.len();
+            let mut spans = Vec::new();
+            if is_first {
+                spans.push(Span::styled(
+                    EDIT_LABEL,
+                    Style::default().fg(read.theme.accent),
+                ));
+            } else {
+                spans.push(Span::raw(EDIT_CONTINUATION_PREFIX));
+            }
+
+            spans.push(Span::styled(
+                (*part).to_string(),
+                Style::default().fg(read.theme.text),
+            ));
+            if is_last {
+                spans.push(Span::styled(
+                    cursor_char,
+                    Style::default().fg(read.theme.text),
+                ));
+            }
+
+            lines.push(Line::from(spans));
+        }
+
+        lines
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+    use ratatui::{Terminal, backend::TestBackend, layout::Rect};
+
+    use super::{EditMode, MIN_EDIT_AREA_HEIGHT};
+    use crate::{
+        screen::EventResult,
+        screen::editor::mode::{EditorIntent, EditorView},
+        screen::editor::mode::{EditorReadModel, Mode},
+        theme::Theme,
+    };
+
+    #[test]
+    fn edit_mode_reserves_a_single_line_edit_area_for_single_line_input() {
+        let backend = TestBackend::new(40, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+        let mode = EditMode::new(String::new(), None);
+        let theme = Theme::dark();
+        let viewport = super::super::viewport::Viewport::new();
+
+        terminal
+            .draw(|frame| {
+                let table_area = mode.render(
+                    frame,
+                    frame.area(),
+                    EditorReadModel {
+                        theme,
+                        viewport: &viewport,
+                        blink_visible: true,
+                        selection_stats: None,
+                    },
+                );
+
+                assert_eq!(table_area, Rect::new(0, 0, 40, 10 - MIN_EDIT_AREA_HEIGHT));
+            })
+            .unwrap();
+    }
+
+    #[test]
+    fn edit_mode_grows_for_multiline_input_and_renders_real_lines() {
+        let backend = TestBackend::new(40, 10);
+        let mut terminal = Terminal::new(backend).unwrap();
+        let mode = EditMode::new("a\nb".to_string(), None);
+        let theme = Theme::dark();
+        let viewport = super::super::viewport::Viewport::new();
+
+        let frame = terminal
+            .draw(|frame| {
+                let table_area = mode.render(
+                    frame,
+                    frame.area(),
+                    EditorReadModel {
+                        theme,
+                        viewport: &viewport,
+                        blink_visible: true,
+                        selection_stats: None,
+                    },
+                );
+
+                assert_eq!(table_area, Rect::new(0, 0, 40, 8));
+            })
+            .unwrap();
+
+        assert!(
+            frame
+                .buffer
+                .content()
+                .iter()
+                .all(|cell| cell.symbol() != "↵")
+        );
+        assert_eq!(frame.buffer[(6, 9)].symbol(), "b");
+        assert_eq!(frame.buffer[(7, 9)].symbol(), "█");
+    }
+
+    #[test]
+    fn shift_enter_inserts_newline_without_committing() {
+        let mut mode = EditMode::new("a".to_string(), None);
+        let result = mode.handle_key(
+            EditorView::new(None),
+            KeyEvent::new(KeyCode::Enter, KeyModifiers::SHIFT),
+        );
+
+        assert!(matches!(result, EventResult::Handled));
+        assert_eq!(mode.edit_buffer(), Some("a\n"));
+    }
+
+    #[test]
+    fn enter_commits_multiline_buffer() {
+        let mut mode = EditMode::new("a\nb".to_string(), None);
+        let result = mode.handle_key(
+            EditorView::new(None),
+            KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()),
+        );
+
+        assert!(matches!(
+            result,
+            EventResult::Command(EditorIntent::CommitEdit(raw)) if raw == "a\nb"
+        ));
+    }
+}