`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()? {
 -                    // Check for CSI sequences (ESC [ ...) which are arrow keys etc.
 -                    if next_event.code == KeyCode::Char('[') {
 -                        // CSI sequence - read the rest
 -                        if event::poll(timeout)? {
 -                            if let Event::Key(csi_event) = event::read()? {
 -                                let mods = Modifiers { alt: true, ..Default::default() };
 -                                return match csi_event.code {
 -                                    KeyCode::Char('A') => self.handle_key_with_mods(Key::Up, mods),
 -                                    KeyCode::Char('B') => self.handle_key_with_mods(Key::Down, mods),
 -                                    KeyCode::Char('C') => self.handle_key_with_mods(Key::Right, mods),
 -                                    KeyCode::Char('D') => self.handle_key_with_mods(Key::Left, mods),
 -                                    _ => Ok(()), // Unknown CSI sequence
 -                                };
 +                match event::read()? {
 +                    Event::Key(next_event) => {
 +                        // Check for CSI sequences (ESC [ ...) which are arrow keys etc.
 +                        if next_event.code == KeyCode::Char('[') {
 +                            // CSI sequence - read the rest
 +                            if event::poll(timeout)? {
 +                                if let Event::Key(csi_event) = event::read()? {
 +                                    let mods = Modifiers { alt: true, ..Default::default() };
 +                                    return match csi_event.code {
 +                                        KeyCode::Char('A') => self.handle_key_with_mods(Key::Up, mods),
 +                                        KeyCode::Char('B') => self.handle_key_with_mods(Key::Down, mods),
 +                                        KeyCode::Char('C') => self.handle_key_with_mods(Key::Right, mods),
 +                                        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)
 -                    let (key, mut mods) = Key::from_crossterm(next_event);
 -                    mods.alt = true;
 -                    return self.handle_key_with_mods(key, mods);
 +                        // Regular Alt+key (ESC followed by a normal key)
 +                        let (key, mut mods) = Key::from_crossterm(next_event);
 +                        mods.alt = true;
 +                        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(())
+     }