ratatui_ruby 0.4.0 → 0.6.0

data/ext/ratatui_ruby/src/events.rs

@@ -28,22 +28,120 @@ pub fn inject_test_event(event_type: String, data: magnus::RHash) -> Result<(),
     Ok(())
 }
 
-fn parse_key_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
-    let code_val: Value = data.get(ruby.to_symbol("code")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'code' in key event")
-    })?;
+/// Parses a `snake_case` string to `MediaKeyCode`.
+///
+/// Accepts both the new `media_`-prefixed codes (canonical) and the legacy
+/// unprefixed codes for backward compatibility with existing tests.
+fn parse_media_key(s: &str) -> Option<ratatui::crossterm::event::MediaKeyCode> {
+    use ratatui::crossterm::event::MediaKeyCode;
+    match s {
+        // New canonical codes (media_ prefix)
+        "media_play" | "play" => Some(MediaKeyCode::Play),
+        "media_pause" => Some(MediaKeyCode::Pause),
+        "media_play_pause" | "play_pause" => Some(MediaKeyCode::PlayPause),
+        "media_reverse" | "reverse" => Some(MediaKeyCode::Reverse),
+        "media_stop" | "stop" => Some(MediaKeyCode::Stop),
+        "media_fast_forward" | "fast_forward" => Some(MediaKeyCode::FastForward),
+        "media_rewind" | "rewind" => Some(MediaKeyCode::Rewind),
+        "media_track_next" | "track_next" => Some(MediaKeyCode::TrackNext),
+        "media_track_previous" | "track_previous" => Some(MediaKeyCode::TrackPrevious),
+        "media_record" | "record" => Some(MediaKeyCode::Record),
+        "media_lower_volume" | "lower_volume" => Some(MediaKeyCode::LowerVolume),
+        "media_raise_volume" | "raise_volume" => Some(MediaKeyCode::RaiseVolume),
+        "media_mute_volume" | "mute_volume" => Some(MediaKeyCode::MuteVolume),
+        _ => None,
+    }
+}
+
+/// Parses a `snake_case` string to `ModifierKeyCode`.
+fn parse_modifier_key(s: &str) -> Option<ratatui::crossterm::event::ModifierKeyCode> {
+    use ratatui::crossterm::event::ModifierKeyCode;
+    match s {
+        "left_shift" => Some(ModifierKeyCode::LeftShift),
+        "left_control" => Some(ModifierKeyCode::LeftControl),
+        "left_alt" => Some(ModifierKeyCode::LeftAlt),
+        "left_super" => Some(ModifierKeyCode::LeftSuper),
+        "left_hyper" => Some(ModifierKeyCode::LeftHyper),
+        "left_meta" => Some(ModifierKeyCode::LeftMeta),
+        "right_shift" => Some(ModifierKeyCode::RightShift),
+        "right_control" => Some(ModifierKeyCode::RightControl),
+        "right_alt" => Some(ModifierKeyCode::RightAlt),
+        "right_super" => Some(ModifierKeyCode::RightSuper),
+        "right_hyper" => Some(ModifierKeyCode::RightHyper),
+        "right_meta" => Some(ModifierKeyCode::RightMeta),
+        "iso_level3_shift" => Some(ModifierKeyCode::IsoLevel3Shift),
+        "iso_level5_shift" => Some(ModifierKeyCode::IsoLevel5Shift),
+        _ => None,
+    }
+}
+
+fn parse_key_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
+    use ratatui::crossterm::event::KeyCode;
+
+    let code_val: Value = data
+        .get(ruby.to_symbol("code"))
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "Missing 'code' in key event"))?;
     let code_str: String = String::try_convert(code_val)?;
     let code = match code_str.as_str() {
-        "up" => ratatui::crossterm::event::KeyCode::Up,
-        "down" => ratatui::crossterm::event::KeyCode::Down,
-        "left" => ratatui::crossterm::event::KeyCode::Left,
-        "right" => ratatui::crossterm::event::KeyCode::Right,
-        "enter" => ratatui::crossterm::event::KeyCode::Enter,
-        "esc" => ratatui::crossterm::event::KeyCode::Esc,
-        "backspace" => ratatui::crossterm::event::KeyCode::Backspace,
-        "tab" => ratatui::crossterm::event::KeyCode::Tab,
-        c if c.len() == 1 => ratatui::crossterm::event::KeyCode::Char(c.chars().next().unwrap()),
-        _ => ratatui::crossterm::event::KeyCode::Null,
+        // Arrow keys
+        "up" => KeyCode::Up,
+        "down" => KeyCode::Down,
+        "left" => KeyCode::Left,
+        "right" => KeyCode::Right,
+        // Common keys
+        "enter" => KeyCode::Enter,
+        "esc" => KeyCode::Esc,
+        "backspace" => KeyCode::Backspace,
+        "tab" => KeyCode::Tab,
+        "back_tab" => KeyCode::BackTab,
+        // Navigation keys
+        "home" => KeyCode::Home,
+        "end" => KeyCode::End,
+        "page_up" => KeyCode::PageUp,
+        "page_down" => KeyCode::PageDown,
+        "insert" => KeyCode::Insert,
+        "delete" => KeyCode::Delete,
+        // Lock keys
+        "caps_lock" => KeyCode::CapsLock,
+        "scroll_lock" => KeyCode::ScrollLock,
+        "num_lock" => KeyCode::NumLock,
+        // System keys
+        "print_screen" => KeyCode::PrintScreen,
+        "pause" => KeyCode::Pause,
+        "menu" => KeyCode::Menu,
+        "keypad_begin" => KeyCode::KeypadBegin,
+        "null" => KeyCode::Null,
+        // Dynamic parsing for media, modifiers, function keys, and characters
+        s => {
+            // Media keys (check first - "fast_forward" starts with 'f' but isn't F-key)
+            if let Some(m) = parse_media_key(s) {
+                KeyCode::Media(m)
+            }
+            // Modifier keys
+            else if let Some(m) = parse_modifier_key(s) {
+                KeyCode::Modifier(m)
+            }
+            // Function keys: f1, f2, ..., f12, etc.
+            else if let Some(num_str) = s.strip_prefix('f') {
+                if let Ok(n) = num_str.parse::<u8>() {
+                    KeyCode::F(n)
+                } else {
+                    // "f" alone or invalid suffix - treat as character
+                    KeyCode::Char(s.chars().next().unwrap_or('\0'))
+                }
+            }
+            // Single character
+            else if s.len() == 1 {
+                KeyCode::Char(s.chars().next().unwrap())
+            }
+            // Unknown - default to Null
+            else {
+                KeyCode::Null
+            }
+        }
     };
 
     let mut modifiers = ratatui::crossterm::event::KeyModifiers::empty();
@@ -59,13 +157,18 @@ fn parse_key_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::
         }
     }
 
-    Ok(ratatui::crossterm::event::Event::Key(ratatui::crossterm::event::KeyEvent::new(code, modifiers)))
+    Ok(ratatui::crossterm::event::Event::Key(
+        ratatui::crossterm::event::KeyEvent::new(code, modifiers),
+    ))
 }
 
-fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
-    let kind_val: Value = data.get(ruby.to_symbol("kind")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'kind' in mouse event")
-    })?;
+fn parse_mouse_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
+    let kind_val: Value = data
+        .get(ruby.to_symbol("kind"))
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "Missing 'kind' in mouse event"))?;
     let kind_str: String = String::try_convert(kind_val)?;
 
     let button = if let Some(btn_val) = data.get(ruby.to_symbol("button")) {
@@ -79,14 +182,14 @@ fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui
         ratatui::crossterm::event::MouseButton::Left
     };
 
-    let x_val: Value = data.get(ruby.to_symbol("x")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'x' in mouse event")
-    })?;
+    let x_val: Value = data
+        .get(ruby.to_symbol("x"))
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "Missing 'x' in mouse event"))?;
     let x: u16 = u16::try_convert(x_val)?;
 
-    let y_val: Value = data.get(ruby.to_symbol("y")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'y' in mouse event")
-    })?;
+    let y_val: Value = data
+        .get(ruby.to_symbol("y"))
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "Missing 'y' in mouse event"))?;
     let y: u16 = u16::try_convert(y_val)?;
 
     let kind = match kind_str.as_str() {
@@ -98,7 +201,12 @@ fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui
         "scroll_up" => ratatui::crossterm::event::MouseEventKind::ScrollUp,
         "scroll_left" => ratatui::crossterm::event::MouseEventKind::ScrollLeft,
         "scroll_right" => ratatui::crossterm::event::MouseEventKind::ScrollRight,
-        _ => return Err(Error::new(ruby.exception_arg_error(), format!("Unknown mouse kind: {kind_str}"))),
+        _ => {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("Unknown mouse kind: {kind_str}"),
+            ))
+        }
     };
 
     let mut modifiers = ratatui::crossterm::event::KeyModifiers::empty();
@@ -114,26 +222,48 @@ fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui
         }
     }
 
-    Ok(ratatui::crossterm::event::Event::Mouse(ratatui::crossterm::event::MouseEvent { kind, column: x, row: y, modifiers }))
+    Ok(ratatui::crossterm::event::Event::Mouse(
+        ratatui::crossterm::event::MouseEvent {
+            kind,
+            column: x,
+            row: y,
+            modifiers,
+        },
+    ))
 }
 
-fn parse_resize_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
+fn parse_resize_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
     let width_val: Value = data.get(ruby.to_symbol("width")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'width' in resize event")
+        Error::new(
+            ruby.exception_arg_error(),
+            "Missing 'width' in resize event",
+        )
     })?;
     let width: u16 = u16::try_convert(width_val)?;
 
     let height_val: Value = data.get(ruby.to_symbol("height")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'height' in resize event")
+        Error::new(
+            ruby.exception_arg_error(),
+            "Missing 'height' in resize event",
+        )
     })?;
     let height: u16 = u16::try_convert(height_val)?;
 
     Ok(ratatui::crossterm::event::Event::Resize(width, height))
 }
 
-fn parse_paste_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
+fn parse_paste_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
     let content_val: Value = data.get(ruby.to_symbol("content")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'content' in paste event")
+        Error::new(
+            ruby.exception_arg_error(),
+            "Missing 'content' in paste event",
+        )
     })?;
     let content: String = String::try_convert(content_val)?;
     Ok(ratatui::crossterm::event::Event::Paste(content))
@@ -143,7 +273,7 @@ pub fn clear_events() {
     EVENT_QUEUE.lock().unwrap().clear();
 }
 
-pub fn poll_event(ruby: &magnus::Ruby) -> Result<Value, Error> {
+pub fn poll_event(ruby: &magnus::Ruby, timeout_val: Option<f64>) -> Result<Value, Error> {
     let event = {
         let mut queue = EVENT_QUEUE.lock().unwrap();
         if queue.is_empty() {
@@ -159,21 +289,33 @@ pub fn poll_event(ruby: &magnus::Ruby) -> Result<Value, Error> {
 
     let is_test_mode = {
         let term_lock = crate::terminal::TERMINAL.lock().unwrap();
-        matches!(term_lock.as_ref(), Some(crate::terminal::TerminalWrapper::Test(_)))
+        matches!(
+            term_lock.as_ref(),
+            Some(crate::terminal::TerminalWrapper::Test(_))
+        )
     };
 
     if is_test_mode {
         return Ok(ruby.qnil().into_value_with(ruby));
     }
 
-    if ratatui::crossterm::event::poll(std::time::Duration::from_millis(16))
-        .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?
-    {
+    if let Some(secs) = timeout_val {
+        // Timed poll: wait up to the specified duration
+        let duration = std::time::Duration::from_secs_f64(secs);
+        if ratatui::crossterm::event::poll(duration)
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?
+        {
+            let event = ratatui::crossterm::event::read()
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+            handle_event(event)
+        } else {
+            Ok(ruby.qnil().into_value_with(ruby))
+        }
+    } else {
+        // Blocking: wait indefinitely for an event
         let event = ratatui::crossterm::event::read()
             .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
         handle_event(event)
-    } else {
-        Ok(ruby.qnil().into_value_with(ruby))
     }
 }
 
@@ -188,31 +330,156 @@ fn handle_event(event: ratatui::crossterm::event::Event) -> Result<Value, Error>
     }
 }
 
+/// Converts `MediaKeyCode` to `snake_case` string.
+///
+/// All media keys are consistently prefixed with `media_` to reflect that they
+/// belong to the `KeyCode::Media(_)` variant in Crossterm. This allows Ruby's
+/// "Smart Predicates" to provide DWIM behavior (e.g., `pause?` matching both
+/// system and media pause).
+fn media_key_to_string(m: ratatui::crossterm::event::MediaKeyCode) -> &'static str {
+    use ratatui::crossterm::event::MediaKeyCode;
+    match m {
+        MediaKeyCode::Play => "media_play",
+        MediaKeyCode::Pause => "media_pause",
+        MediaKeyCode::PlayPause => "media_play_pause",
+        MediaKeyCode::Reverse => "media_reverse",
+        MediaKeyCode::Stop => "media_stop",
+        MediaKeyCode::FastForward => "media_fast_forward",
+        MediaKeyCode::Rewind => "media_rewind",
+        MediaKeyCode::TrackNext => "media_track_next",
+        MediaKeyCode::TrackPrevious => "media_track_previous",
+        MediaKeyCode::Record => "media_record",
+        MediaKeyCode::LowerVolume => "media_lower_volume",
+        MediaKeyCode::RaiseVolume => "media_raise_volume",
+        MediaKeyCode::MuteVolume => "media_mute_volume",
+    }
+}
+
+/// Converts `ModifierKeyCode` to `snake_case` string.
+fn modifier_key_to_string(m: ratatui::crossterm::event::ModifierKeyCode) -> &'static str {
+    use ratatui::crossterm::event::ModifierKeyCode;
+    match m {
+        ModifierKeyCode::LeftShift => "left_shift",
+        ModifierKeyCode::LeftControl => "left_control",
+        ModifierKeyCode::LeftAlt => "left_alt",
+        ModifierKeyCode::LeftSuper => "left_super",
+        ModifierKeyCode::LeftHyper => "left_hyper",
+        ModifierKeyCode::LeftMeta => "left_meta",
+        ModifierKeyCode::RightShift => "right_shift",
+        ModifierKeyCode::RightControl => "right_control",
+        ModifierKeyCode::RightAlt => "right_alt",
+        ModifierKeyCode::RightSuper => "right_super",
+        ModifierKeyCode::RightHyper => "right_hyper",
+        ModifierKeyCode::RightMeta => "right_meta",
+        ModifierKeyCode::IsoLevel3Shift => "iso_level3_shift",
+        ModifierKeyCode::IsoLevel5Shift => "iso_level5_shift",
+    }
+}
+
 fn handle_key_event(key: ratatui::crossterm::event::KeyEvent) -> Result<Value, Error> {
+    use ratatui::crossterm::event::KeyCode;
+
     let ruby = magnus::Ruby::get().unwrap();
     if key.kind != ratatui::crossterm::event::KeyEventKind::Press {
         return Ok(ruby.qnil().into_value_with(&ruby));
     }
     let hash = ruby.hash_new();
     hash.aset(ruby.to_symbol("type"), ruby.to_symbol("key"))?;
+
+    // Determine the kind (category) of the key
+    let kind = match key.code {
+        KeyCode::Char(_)
+        | KeyCode::Enter
+        | KeyCode::Tab
+        | KeyCode::Backspace
+        | KeyCode::BackTab
+        | KeyCode::Up
+        | KeyCode::Down
+        | KeyCode::Left
+        | KeyCode::Right
+        | KeyCode::Home
+        | KeyCode::End
+        | KeyCode::PageUp
+        | KeyCode::PageDown
+        | KeyCode::Insert
+        | KeyCode::Delete
+        | KeyCode::Null => "standard",
+        KeyCode::F(_) => "function",
+        KeyCode::Media(_) => "media",
+        KeyCode::Modifier(_) => "modifier",
+        KeyCode::Esc
+        | KeyCode::CapsLock
+        | KeyCode::ScrollLock
+        | KeyCode::NumLock
+        | KeyCode::PrintScreen
+        | KeyCode::Pause
+        | KeyCode::Menu
+        | KeyCode::KeypadBegin => "system",
+    };
+
     let code = match key.code {
-        ratatui::crossterm::event::KeyCode::Char(c) => c.to_string(),
-        ratatui::crossterm::event::KeyCode::Up => "up".to_string(),
-        ratatui::crossterm::event::KeyCode::Down => "down".to_string(),
-        ratatui::crossterm::event::KeyCode::Left => "left".to_string(),
-        ratatui::crossterm::event::KeyCode::Right => "right".to_string(),
-        ratatui::crossterm::event::KeyCode::Enter => "enter".to_string(),
-        ratatui::crossterm::event::KeyCode::Esc => "esc".to_string(),
-        ratatui::crossterm::event::KeyCode::Backspace => "backspace".to_string(),
-        ratatui::crossterm::event::KeyCode::Tab => "tab".to_string(),
-        _ => "unknown".to_string(),
+        // Characters
+        KeyCode::Char(c) => c.to_string(),
+        // Arrow keys
+        KeyCode::Up => "up".to_string(),
+        KeyCode::Down => "down".to_string(),
+        KeyCode::Left => "left".to_string(),
+        KeyCode::Right => "right".to_string(),
+        // Common keys
+        KeyCode::Enter => "enter".to_string(),
+        KeyCode::Esc => "esc".to_string(),
+        KeyCode::Backspace => "backspace".to_string(),
+        KeyCode::Tab => "tab".to_string(),
+        KeyCode::BackTab => "back_tab".to_string(),
+        // Navigation keys
+        KeyCode::Home => "home".to_string(),
+        KeyCode::End => "end".to_string(),
+        KeyCode::PageUp => "page_up".to_string(),
+        KeyCode::PageDown => "page_down".to_string(),
+        KeyCode::Insert => "insert".to_string(),
+        KeyCode::Delete => "delete".to_string(),
+        // Function keys
+        KeyCode::F(n) => format!("f{n}"),
+        // Lock keys
+        KeyCode::CapsLock => "caps_lock".to_string(),
+        KeyCode::ScrollLock => "scroll_lock".to_string(),
+        KeyCode::NumLock => "num_lock".to_string(),
+        // System keys
+        KeyCode::PrintScreen => "print_screen".to_string(),
+        KeyCode::Pause => "pause".to_string(),
+        KeyCode::Menu => "menu".to_string(),
+        KeyCode::KeypadBegin => "keypad_begin".to_string(),
+        KeyCode::Null => "null".to_string(),
+        // Compound variants
+        KeyCode::Media(m) => media_key_to_string(m).to_string(),
+        KeyCode::Modifier(m) => modifier_key_to_string(m).to_string(),
     };
+
     hash.aset(ruby.to_symbol("code"), code)?;
+    hash.aset(ruby.to_symbol("kind"), ruby.to_symbol(kind))?;
+
     let mut modifiers = Vec::new();
-    if key.modifiers.contains(ratatui::crossterm::event::KeyModifiers::CONTROL) { modifiers.push("ctrl"); }
-    if key.modifiers.contains(ratatui::crossterm::event::KeyModifiers::ALT) { modifiers.push("alt"); }
-    if key.modifiers.contains(ratatui::crossterm::event::KeyModifiers::SHIFT) { modifiers.push("shift"); }
-    if !modifiers.is_empty() { hash.aset(ruby.to_symbol("modifiers"), modifiers)?; }
+    if key
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::CONTROL)
+    {
+        modifiers.push("ctrl");
+    }
+    if key
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::ALT)
+    {
+        modifiers.push("alt");
+    }
+    if key
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::SHIFT)
+    {
+        modifiers.push("shift");
+    }
+    if !modifiers.is_empty() {
+        hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
+    }
     Ok(hash.into_value_with(&ruby))
 }
 
@@ -224,14 +491,29 @@ fn handle_mouse_event(event: ratatui::crossterm::event::MouseEvent) -> Result<Va
         ratatui::crossterm::event::MouseEventKind::Down(btn) => ("down", btn),
         ratatui::crossterm::event::MouseEventKind::Up(btn) => ("up", btn),
         ratatui::crossterm::event::MouseEventKind::Drag(btn) => ("drag", btn),
-        ratatui::crossterm::event::MouseEventKind::Moved => ("moved", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollDown => ("scroll_down", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollUp => ("scroll_up", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollLeft => ("scroll_left", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollRight => ("scroll_right", ratatui::crossterm::event::MouseButton::Left),
+        ratatui::crossterm::event::MouseEventKind::Moved => {
+            ("moved", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollDown => {
+            ("scroll_down", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollUp => {
+            ("scroll_up", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollLeft => {
+            ("scroll_left", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollRight => {
+            ("scroll_right", ratatui::crossterm::event::MouseButton::Left)
+        }
     };
     hash.aset(ruby.to_symbol("kind"), ruby.to_symbol(kind))?;
-    if matches!(event.kind, ratatui::crossterm::event::MouseEventKind::Down(_) | ratatui::crossterm::event::MouseEventKind::Up(_) | ratatui::crossterm::event::MouseEventKind::Drag(_)) {
+    if matches!(
+        event.kind,
+        ratatui::crossterm::event::MouseEventKind::Down(_)
+            | ratatui::crossterm::event::MouseEventKind::Up(_)
+            | ratatui::crossterm::event::MouseEventKind::Drag(_)
+    ) {
         let btn_sym = match button {
             ratatui::crossterm::event::MouseButton::Left => "left",
             ratatui::crossterm::event::MouseButton::Right => "right",
@@ -244,9 +526,24 @@ fn handle_mouse_event(event: ratatui::crossterm::event::MouseEvent) -> Result<Va
     hash.aset(ruby.to_symbol("x"), event.column)?;
     hash.aset(ruby.to_symbol("y"), event.row)?;
     let mut modifiers = Vec::new();
-    if event.modifiers.contains(ratatui::crossterm::event::KeyModifiers::CONTROL) { modifiers.push("ctrl"); }
-    if event.modifiers.contains(ratatui::crossterm::event::KeyModifiers::ALT) { modifiers.push("alt"); }
-    if event.modifiers.contains(ratatui::crossterm::event::KeyModifiers::SHIFT) { modifiers.push("shift"); }
+    if event
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::CONTROL)
+    {
+        modifiers.push("ctrl");
+    }
+    if event
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::ALT)
+    {
+        modifiers.push("alt");
+    }
+    if event
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::SHIFT)
+    {
+        modifiers.push("shift");
+    }
     hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
     Ok(hash.into_value_with(&ruby))
 }