`50fd38a`

fix multiline paste handling

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 50fd38a63ef99bc305dad7e7e840939ffb622a62
Parents: a275a53
Tree: 9c16b25

3 changed files

Status	File	+	-
M	`src/editor/state.rs`	97	22
M	`src/input/key.rs`	40	0
M	`src/render/screen.rs`	15	3

src/editor/state.rsmodified

                      Event::Key(key_event) if key_event.kind != KeyEventKind::Release => {
                          self.process_key(key_event)?
+                     }
++                    Event::Paste(text) => self.process_paste(&text)?,
                      Event::Mouse(mouse_event) => self.process_mouse(mouse_event)?,
                      Event::Resize(cols, rows) => {
                          self.screen.cols = cols;
                          Event::Key(key_event) if key_event.kind != KeyEventKind::Release => {
                              self.process_key(key_event)?
+                         }
++                        Event::Paste(text) => self.process_paste(&text)?,
                          Event::Mouse(mouse_event) => self.process_mouse(mouse_event)?,
                          Event::Resize(cols, rows) => {
                              self.screen.cols = cols;
              let timeout = Duration::from_millis(self.escape_time);
              if event::poll(timeout)? {
--                if let Event::Key(next_event) = event::read()? {
++                match event::read()? {
--                    // Check for CSI sequences (ESC [ ...) which are arrow keys etc.
++                    Event::Key(next_event) => {
--                    if next_event.code == KeyCode::Char('[') {
++                        // Check for CSI sequences (ESC [ ...) which are arrow keys etc.
--                        // CSI sequence - read the rest
++                        if next_event.code == KeyCode::Char('[') {
--                        if event::poll(timeout)? {
++                            // CSI sequence - read the rest
--                            if let Event::Key(csi_event) = event::read()? {
++                            if event::poll(timeout)? {
--                                let mods = Modifiers { alt: true, ..Default::default() };
++                                if let Event::Key(csi_event) = event::read()? {
--                                return match csi_event.code {
++                                    let mods = Modifiers { alt: true, ..Default::default() };
--                                    KeyCode::Char('A') => self.handle_key_with_mods(Key::Up, mods),
++                                    return match csi_event.code {
--                                    KeyCode::Char('B') => self.handle_key_with_mods(Key::Down, mods),
++                                        KeyCode::Char('A') => self.handle_key_with_mods(Key::Up, mods),
--                                    KeyCode::Char('C') => self.handle_key_with_mods(Key::Right, mods),
++                                        KeyCode::Char('B') => self.handle_key_with_mods(Key::Down, mods),
--                                    KeyCode::Char('D') => self.handle_key_with_mods(Key::Left, mods),
++                                        KeyCode::Char('C') => self.handle_key_with_mods(Key::Right, mods),
--                                    _ => Ok(()), // Unknown CSI sequence
++                                        KeyCode::Char('D') => self.handle_key_with_mods(Key::Left, mods),
--                                };
++                                        _ => Ok(()), // Unknown CSI sequence
++                                    };
++                                }
+                             }
++                            return Ok(()); // Incomplete CSI
+                         }
--                        return Ok(()); // Incomplete CSI
--                    }
--                    // Regular Alt+key (ESC followed by a normal key)
++                        // Regular Alt+key (ESC followed by a normal key)
--                    let (key, mut mods) = Key::from_crossterm(next_event);
++                        let (key, mut mods) = Key::from_crossterm(next_event);
--                    mods.alt = true;
++                        mods.alt = true;
--                    return self.handle_key_with_mods(key, mods);
++                        return self.handle_key_with_mods(key, mods);
++                    }
++                    Event::Paste(text) => return self.process_paste(&text),
++                    _ => {}
+                 }
+             }
              // No key followed - it's a real Escape
          self.handle_key_with_mods(key, mods)
+     }
++    /// Process a paste event from the terminal.
++    /// Handles multiline text and normalizes CRLF/CR line endings.
++    fn process_paste(&mut self, text: &str) -> Result<()> {
++        let text = Self::normalize_line_endings(text);
++        if text.is_empty() {
++            return Ok(());
++        }
++
++        // Route paste to terminal when terminal has focus.
++        if self.focus == Focus::Terminal && self.terminal.visible {
++            self.terminal.send_input(text.as_bytes())?;
++            return Ok(());
++        }
++
++        // Fast path for editor: insert as one operation to preserve undo grouping.
++        if self.prompt == PromptState::None && self.focus == Focus::Editor {
++            self.history_mut().maybe_break_group();
++            self.insert_text(&text);
++            self.dismiss_ghost_text();
++            self.message = Some("Pasted".to_string());
++            self.history_mut().maybe_break_group();
++            self.on_buffer_edit();
++            self.scroll_to_cursor();
++            return Ok(());
++        }
++
++        // For prompts, server manager, or fuss mode, replay as plain key input.
++        for c in text.chars() {
++            let key = match c {
++                '\n' => Key::Enter,
++                '\t' => Key::Tab,
++                _ => Key::Char(c),
++            };
++            self.handle_key_with_mods(key, Modifiers::default())?;
++        }
++
++        Ok(())
++    }
++
      /// Process a mouse event
      fn process_mouse(&mut self, mouse_event: MouseEvent) -> Result<()> {
          if let Some(mouse) = Mouse::from_crossterm(mouse_event) {
+     }
      fn insert_text(&mut self, text: &str) {
--        self.insert_text_multi(text);
++        if text.contains('\r') || text.contains('\u{2028}') || text.contains('\u{2029}') {
++            let normalized = Self::normalize_line_endings(text);
++            self.insert_text_multi(&normalized);
++        } else {
++            self.insert_text_multi(text);
++        }
+     }
      fn insert_char(&mut self, c: char) {
          self.internal_clipboard = text;
+     }
++    /// Normalize CRLF/CR to LF for internal editing operations.
++    fn normalize_line_endings(text: &str) -> String {
++        if !text.contains('\r') && !text.contains('\u{2028}') && !text.contains('\u{2029}') {
++            return text.to_string();
++        }
++
++        let mut out = String::with_capacity(text.len());
++        let mut chars = text.chars().peekable();
++        while let Some(ch) = chars.next() {
++            match ch {
++                '\r' => {
++                    // Collapse CRLF into a single LF.
++                    if chars.peek() == Some(&'\n') {
++                        chars.next();
++                    }
++                    out.push('\n');
++                }
++                // Unicode line and paragraph separators
++                '\u{2028}' | '\u{2029}' => out.push('\n'),
++                _ => out.push(ch),
++            }
++        }
++        out
++    }
++
      /// Get clipboard text (system if available, internal fallback)
      fn get_clipboard(&mut self) -> String {
          if let Some(ref mut cb) = self.clipboard {
+     }
      fn paste(&mut self) {
--        let text = self.get_clipboard();
++        let text = Self::normalize_line_endings(&self.get_clipboard());
          if !text.is_empty() {
              self.insert_text(&text);
              self.message = Some("Pasted".to_string());

src/input/key.rsmodified

          let modifiers = Modifiers::from(event.modifiers);
          let key = match event.code {
              KeyCode::Char(c) => {
++                // Some terminals report Enter/newline as Char('\r') or Char('\n')
++                // during paste or raw key input. Normalize those to Enter so
++                // multiline paste preserves line breaks.
++                if c == '\r' || c == '\n' {
++                    return (Key::Enter, modifiers);
++                }
++
                  // If shift is pressed and character is lowercase alphabetic,
                  // uppercase it. This handles terminals that don't support
                  // REPORT_ALTERNATE_KEYS properly (which would report 'A' directly).
          (key, modifiers)
+     }
+ }
++
++#[cfg(test)]
++mod tests {
++    use super::*;
++    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
++
++    #[test]
++    fn char_carriage_return_maps_to_enter() {
++        let (key, mods) = Key::from_crossterm(KeyEvent::new(
++            KeyCode::Char('\r'),
++            KeyModifiers::NONE,
++        ));
++        assert_eq!(key, Key::Enter);
++        assert_eq!(mods, Modifiers::default());
++    }
++
++    #[test]
++    fn char_newline_maps_to_enter() {
++        let (key, mods) = Key::from_crossterm(KeyEvent::new(
++            KeyCode::Char('\n'),
++            KeyModifiers::SHIFT,
++        ));
++        assert_eq!(key, Key::Enter);
++        assert_eq!(
++            mods,
++            Modifiers {
++                ctrl: false,
++                alt: false,
++                shift: true,
++            }
++        );
++    }
++}

src/render/screen.rsmodified

  use crossterm::{
      cursor::{Hide, MoveTo, Show},
      event::{
--        DisableMouseCapture, EnableMouseCapture,
++        DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
          KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
      },
      execute, queue,
      pub fn enter_raw_mode(&mut self) -> Result<()> {
          terminal::enable_raw_mode()?;
--        execute!(self.stdout, EnterAlternateScreen, Hide, EnableMouseCapture)?;
++        execute!(
++            self.stdout,
++            EnterAlternateScreen,
++            Hide,
++            EnableMouseCapture,
++            EnableBracketedPaste
++        )?;
          // Try to enable keyboard enhancement for better modifier key detection
          // This enables the kitty keyboard protocol on supporting terminals.
          if self.keyboard_enhanced {
              let _ = execute!(self.stdout, PopKeyboardEnhancementFlags);
+         }
--        execute!(self.stdout, Show, DisableMouseCapture, LeaveAlternateScreen)?;
++        execute!(
++            self.stdout,
++            Show,
++            DisableMouseCapture,
++            DisableBracketedPaste,
++            LeaveAlternateScreen
++        )?;
          terminal::disable_raw_mode()?;
          Ok(())
+     }