ratatui_ruby 0.9.1 → 0.10.1

data/ext/ratatui_ruby/src/widgets/table_state.rs

@@ -69,6 +69,40 @@ impl RubyTableState {
         self.inner.borrow_mut().scroll_up_by(amount);
     }
 
+    /// Returns the currently selected cell as (row, column) tuple.
+    /// Returns None if either row or column is not selected.
+    pub fn selected_cell(&self) -> Option<(usize, usize)> {
+        self.inner.borrow().selected_cell()
+    }
+
+    /// Selects the next column or the first one if no column is selected.
+    pub fn select_next_column(&self) {
+        self.inner.borrow_mut().select_next_column();
+    }
+
+    /// Selects the previous column or the last one if no column is selected.
+    pub fn select_previous_column(&self) {
+        self.inner.borrow_mut().select_previous_column();
+    }
+
+    /// Selects the first column.
+    pub fn select_first_column(&self) {
+        self.inner.borrow_mut().select_first_column();
+    }
+
+    /// Selects the last column.
+    pub fn select_last_column(&self) {
+        self.inner.borrow_mut().select_last_column();
+    }
+
+    /// Creates a new `RubyTableState` with a selected cell (row, column).
+    pub fn with_selected_cell(cell: Option<(usize, usize)>) -> Self {
+        let state = TableState::default().with_selected_cell(cell);
+        Self {
+            inner: RefCell::new(state),
+        }
+    }
+
     /// Borrows the inner `TableState` mutably for rendering.
     pub fn borrow_mut(&self) -> std::cell::RefMut<'_, TableState> {
         self.inner.borrow_mut()
@@ -79,6 +113,10 @@ impl RubyTableState {
 pub fn register(ruby: &Ruby, module: magnus::RModule) -> Result<(), Error> {
     let class = module.define_class("TableState", ruby.class_object())?;
     class.define_singleton_method("new", function!(RubyTableState::new, 1))?;
+    class.define_singleton_method(
+        "with_selected_cell",
+        function!(RubyTableState::with_selected_cell, 1),
+    )?;
     class.define_method("select", method!(RubyTableState::select, 1))?;
     class.define_method("selected", method!(RubyTableState::selected, 0))?;
     class.define_method("select_column", method!(RubyTableState::select_column, 1))?;
@@ -86,6 +124,23 @@ pub fn register(ruby: &Ruby, module: magnus::RModule) -> Result<(), Error> {
         "selected_column",
         method!(RubyTableState::selected_column, 0),
     )?;
+    class.define_method("selected_cell", method!(RubyTableState::selected_cell, 0))?;
+    class.define_method(
+        "select_next_column",
+        method!(RubyTableState::select_next_column, 0),
+    )?;
+    class.define_method(
+        "select_previous_column",
+        method!(RubyTableState::select_previous_column, 0),
+    )?;
+    class.define_method(
+        "select_first_column",
+        method!(RubyTableState::select_first_column, 0),
+    )?;
+    class.define_method(
+        "select_last_column",
+        method!(RubyTableState::select_last_column, 0),
+    )?;
     class.define_method("offset", method!(RubyTableState::offset, 0))?;
     class.define_method("scroll_down_by", method!(RubyTableState::scroll_down_by, 1))?;
     class.define_method("scroll_up_by", method!(RubyTableState::scroll_up_by, 1))?;

data/ext/ratatui_ruby/src/widgets/tabs.rs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use crate::errors::type_error_with_context;
 use crate::style::parse_block;
 use crate::text::{parse_line, parse_span};
 use bumpalo::Bump;
@@ -59,7 +60,7 @@ fn create_tabs(node: Value, bump: &Bump) -> Result<Tabs<'_>, Error> {
     let padding_right_val: Value = node.funcall("padding_right", ())?;
 
     let titles_array = magnus::RArray::from_value(titles_val)
-        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for titles"))?;
+        .ok_or_else(|| type_error_with_context(&ruby, "expected array for titles", titles_val))?;
 
     let mut titles = Vec::new();
     for i in 0..titles_array.len() {
@@ -117,7 +118,7 @@ pub fn width(node: Value) -> Result<usize, Error> {
     let padding_right: usize = node.funcall("padding_right", ())?;
 
     let titles_array = magnus::RArray::from_value(titles_val)
-        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for titles"))?;
+        .ok_or_else(|| type_error_with_context(&ruby, "expected array for titles", titles_val))?;
 
     let mut total_width = padding_left + padding_right;
 

data/lib/ratatui_ruby/buffer/cell.rb

@@ -46,6 +46,11 @@ module RatatuiRuby
       # The background color of the cell (e.g., :black, nil).
       attr_reader :bg
 
+      # The underline color of the cell.
+      #
+      # Distinct from foreground color. Some terminals support colored underlines.
+      attr_reader :underline_color
+
       # The list of active modifiers (e.g., ["bold", "italic"]).
       attr_reader :modifiers
 
@@ -64,7 +69,7 @@ module RatatuiRuby
       # SPDX-SnippetEnd
       #++
       def self.empty
-        new(symbol: " ", fg: nil, bg: nil, modifiers: [])
+        new(symbol: " ", fg: nil, bg: nil, underline_color: nil, modifiers: [])
       end
 
       # Returns a default cell (alias for empty).
@@ -102,7 +107,7 @@ module RatatuiRuby
       # SPDX-SnippetEnd
       #++
       def self.symbol(symbol)
-        new(symbol:, fg: nil, bg: nil, modifiers: [])
+        new(symbol:, fg: nil, bg: nil, underline_color: nil, modifiers: [])
       end
 
       # Alias for Rubyists who prefer a shorter name.
@@ -115,58 +120,61 @@ module RatatuiRuby
       # [symbol] String (single character). Aliased as <tt>char:</tt>.
       # [fg] Symbol or String (nullable).
       # [bg] Symbol or String (nullable).
-      # [modifiers] Array of Strings.
-      def initialize(symbol: nil, char: nil, fg: nil, bg: nil, modifiers: [])
+      # [underline_color] Symbol or String (nullable).
+      # [modifiers] Array of Strings, Symbols, or any object responding to to_sym or to_s.
+      #             Normalized to Symbols for consistent output.
+      def initialize(symbol: nil, char: nil, fg: nil, bg: nil, underline_color: nil, modifiers: [])
         @symbol = (symbol || char || " ").freeze
         @fg = fg&.freeze
         @bg = bg&.freeze
-        @modifiers = modifiers.map(&:freeze).freeze
+        @underline_color = underline_color&.freeze
+        @modifiers = modifiers.map { |m| m.respond_to?(:to_sym) ? m.to_sym : m.to_s.to_sym }.freeze
         freeze
       end
 
       # Returns true if the cell has the bold modifier.
       def bold?
-        modifiers.include?("bold")
+        modifiers.include?(:bold)
       end
 
       # Returns true if the cell has the dim modifier.
       def dim?
-        modifiers.include?("dim")
+        modifiers.include?(:dim)
       end
 
       # Returns true if the cell has the italic modifier.
       def italic?
-        modifiers.include?("italic")
+        modifiers.include?(:italic)
       end
 
       # Returns true if the cell has the underlined modifier.
       def underlined?
-        modifiers.include?("underlined")
+        modifiers.include?(:underlined)
       end
 
       # Returns true if the cell has the slow_blink modifier.
       def slow_blink?
-        modifiers.include?("slow_blink")
+        modifiers.include?(:slow_blink)
       end
 
       # Returns true if the cell has the rapid_blink modifier.
       def rapid_blink?
-        modifiers.include?("rapid_blink")
+        modifiers.include?(:rapid_blink)
       end
 
       # Returns true if the cell has the reversed modifier.
       def reversed?
-        modifiers.include?("reversed")
+        modifiers.include?(:reversed)
       end
 
       # Returns true if the cell has the hidden modifier.
       def hidden?
-        modifiers.include?("hidden")
+        modifiers.include?(:hidden)
       end
 
       # Returns true if the cell has the crossed_out modifier.
       def crossed_out?
-        modifiers.include?("crossed_out")
+        modifiers.include?(:crossed_out)
       end
 
       # Checks equality with another Cell.
@@ -175,6 +183,7 @@ module RatatuiRuby
           char == other.char &&
           fg == other.fg &&
           bg == other.bg &&
+          underline_color == other.underline_color &&
           modifiers == other.modifiers
       end
 
@@ -183,6 +192,7 @@ module RatatuiRuby
         parts = ["symbol=#{symbol.inspect}"]
         parts << "fg=#{fg.inspect}" if fg
         parts << "bg=#{bg.inspect}" if bg
+        parts << "underline_color=#{underline_color.inspect}" if underline_color
         parts << "modifiers=#{modifiers.inspect}" unless modifiers.empty?
         "#<#{self.class} #{parts.join(' ')}>"
       end
@@ -195,7 +205,7 @@ module RatatuiRuby
       # Support for pattern matching.
       # Supports both <tt>:symbol</tt> and <tt>:char</tt> keys.
       def deconstruct_keys(keys)
-        { symbol:, char: symbol, fg:, bg:, modifiers: }
+        { symbol:, char: symbol, fg:, bg:, underline_color:, modifiers: }
       end
     end
   end

data/lib/ratatui_ruby/buffer.rb

@@ -8,9 +8,141 @@
 module RatatuiRuby
   # Buffer primitives for terminal cell inspection.
   #
-  # This module mirrors +ratatui::buffer+ and contains:
-  # - {Cell} — Single terminal cell (for inspection)
+  # Widgets render to an intermediate buffer, not directly to the terminal.
+  # Testing and debugging require access to buffer state.
+  #
+  # This module mirrors +ratatui::buffer+ and provides query methods
+  # for inspecting buffer contents, converting between coordinates and indices,
+  # and retrieving individual cells.
+  #
+  # Use it in tests to verify rendered output or in debugging to inspect state.
   module Buffer
+    class << self
+      # Converts a position to a linear buffer index.
+      #
+      # Buffers store cells in a flat array, row by row. Widget code
+      # works with (x, y) coordinates. Bridging these representations
+      # requires index translation.
+      #
+      # The index is calculated as <tt>y * width + x</tt>.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   # In a 10-wide buffer, position (3, 2) maps to index 23
+      #   Buffer.index_of(3, 2) # => 23
+      #--
+      # SPDX-SnippetEnd
+      #++
+      #
+      # [x] Column (0-indexed from left).
+      # [y] Row (0-indexed from top).
+      #
+      # Returns the linear index (Integer).
+      def index_of(x, y)
+        area = RatatuiRuby._get_terminal_area
+        (y * area["width"]) + x
+      end
+
+      # Converts a linear buffer index to position coordinates.
+      #
+      # Inverse of +index_of+. When iterating over buffer content
+      # by index, use this to recover the original coordinates.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   # In a 10-wide buffer, index 23 maps to position (3, 2)
+      #   Buffer.pos_of(23) # => [3, 2]
+      #--
+      # SPDX-SnippetEnd
+      #++
+      #
+      # [index] Linear buffer index (Integer).
+      #
+      # Returns <tt>[x, y]</tt> coordinates.
+      def pos_of(index)
+        area = RatatuiRuby._get_terminal_area
+        width = area["width"]
+        x = index % width
+        y = index / width
+        [x, y]
+      end
+
+      # Returns the Cell at the specified position.
+      #
+      # Tests assert on cell contents. This method provides direct
+      # access without iterating the entire buffer.
+      #
+      # Delegates to +RatatuiRuby.get_cell_at+.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   cell = Buffer.get(0, 0)
+      #   assert_equal "H", cell.char
+      #--
+      # SPDX-SnippetEnd
+      #++
+      #
+      # [x] Column (0-indexed from left).
+      # [y] Row (0-indexed from top).
+      #
+      # Returns a Buffer::Cell containing the character and style at that position.
+      def get(x, y)
+        RatatuiRuby.get_cell_at(x, y)
+      end
+
+      # Returns all cells in the buffer as a flat array.
+      #
+      # Snapshot testing compares entire buffer states. Manually
+      # iterating coordinates is verbose and error-prone.
+      #
+      # This method returns every cell, ordered row by row
+      # (top to bottom, left to right).
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   cells = Buffer.content
+      #   cells.each { |cell| puts cell.char }
+      #--
+      # SPDX-SnippetEnd
+      #++
+      #
+      # Returns an Array of Buffer::Cell objects.
+      def content
+        area = RatatuiRuby._get_terminal_area
+        width = area["width"]
+        height = area["height"]
+        cells = [] #: Array[Buffer::Cell]
+        (0...height).each do |y|
+          (0...width).each do |x|
+            cells << RatatuiRuby.get_cell_at(x, y)
+          end
+        end
+        cells
+      end
+
+      # Ruby-idiomatic alias (TIMTOWTDI)
+      alias [] get
+    end
   end
 end
 

data/lib/ratatui_ruby/cell.rb

@@ -45,8 +45,12 @@ module RatatuiRuby
     # The background color of the cell (e.g., :black, nil).
     attr_reader :bg
 
+    # The underline color of the cell.
+    #
+    # Distinct from foreground color. Some terminals support colored underlines.
+    attr_reader :underline_color
+
     # The list of active modifiers (e.g., ["bold", "italic"]).
-    attr_reader :modifiers
 
     # Returns an empty cell (space character, no styles).
     #
@@ -63,7 +67,7 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     def self.empty
-      new(symbol: " ", fg: nil, bg: nil, modifiers: [])
+      new(symbol: " ", fg: nil, bg: nil, underline_color: nil, modifiers: [])
     end
 
     # Returns a default cell (alias for empty).
@@ -101,7 +105,7 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     def self.symbol(symbol)
-      new(symbol:, fg: nil, bg: nil, modifiers: [])
+      new(symbol:, fg: nil, bg: nil, underline_color: nil, modifiers: [])
     end
 
     # Alias for Rubyists who prefer a shorter name.
@@ -114,11 +118,13 @@ module RatatuiRuby
     # [symbol] String (single character). Aliased as <tt>char:</tt>.
     # [fg] Symbol or String (nullable).
     # [bg] Symbol or String (nullable).
+    # [underline_color] Symbol or String (nullable).
     # [modifiers] Array of Strings.
-    def initialize(symbol: nil, char: nil, fg: nil, bg: nil, modifiers: [])
+    def initialize(symbol: nil, char: nil, fg: nil, bg: nil, underline_color: nil, modifiers: [])
       @symbol = (symbol || char || " ").freeze
       @fg = fg&.freeze
       @bg = bg&.freeze
+      @underline_color = underline_color&.freeze
       @modifiers = modifiers.map(&:freeze).freeze
       freeze
     end
@@ -174,6 +180,7 @@ module RatatuiRuby
         char == other.char &&
         fg == other.fg &&
         bg == other.bg &&
+        underline_color == other.underline_color &&
         modifiers == other.modifiers
     end
 
@@ -182,6 +189,7 @@ module RatatuiRuby
       parts = ["symbol=#{symbol.inspect}"]
       parts << "fg=#{fg.inspect}" if fg
       parts << "bg=#{bg.inspect}" if bg
+      parts << "underline_color=#{underline_color.inspect}" if underline_color
       parts << "modifiers=#{modifiers.inspect}" unless modifiers.empty?
       "#<#{self.class} #{parts.join(' ')}>"
     end
@@ -194,7 +202,7 @@ module RatatuiRuby
     # Support for pattern matching.
     # Supports both <tt>:symbol</tt> and <tt>:char</tt> keys.
     def deconstruct_keys(keys)
-      { symbol:, char: symbol, fg:, bg:, modifiers: }
+      { symbol:, char: symbol, fg:, bg:, underline_color:, modifiers: }
     end
   end
 end

data/lib/ratatui_ruby/debug.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module RatatuiRuby
+  ##
+  # Debug mode control for RatatuiRuby.
+  #
+  # TUI applications are hard to debug. Rust panics show cryptic stack traces.
+  # Ruby exceptions lack Rust context.
+  #
+  # This module controls debug visibility. Enable Rust backtraces only, or
+  # enable full debug mode for both Rust and Ruby-side features.
+  #
+  # == Activation Methods
+  #
+  # Three ways to enable debug features:
+  #
+  # [<tt>RUST_BACKTRACE=1</tt>] Rust backtraces only (no Ruby-side debug).
+  # [<tt>RR_DEBUG=1</tt>] Full debug mode (backtraces + Ruby features).
+  # [<tt>include RatatuiRuby::TestHelper</tt>] Auto-enables debug mode.
+  #
+  # === Example
+  #
+  #--
+  # SPDX-SnippetBegin
+  # SPDX-FileCopyrightText: 2026 Kerrick Long
+  # SPDX-License-Identifier: MIT-0
+  #++
+  #   # Programmatic activation
+  #   RatatuiRuby::Debug.enable!
+  #
+  #   # Or use the convenience alias
+  #   RatatuiRuby.debug_mode!
+  #
+  #--
+  # SPDX-SnippetEnd
+  #++
+  module Debug
+    @rust_backtrace_enabled = false
+    @debug_mode_enabled = false
+
+    class << self
+      ##
+      # Enables Rust backtraces only.
+      #
+      # Call this to get meaningful stack traces when Rust panics.
+      # Does not enable Ruby-side debug features.
+      #
+      # Safe to call multiple times; subsequent calls are no-ops.
+      def enable_rust_backtrace!
+        return if @rust_backtrace_enabled
+
+        @rust_backtrace_enabled = true
+        RatatuiRuby.__send__(:_enable_rust_backtrace)
+      end
+
+      ##
+      # Enables full debug mode.
+      #
+      # Activates Rust backtraces plus any Ruby-side debug features.
+      # Optionally enables remote debugging via the debug gem.
+      #
+      # Safe to call multiple times; subsequent calls are no-ops.
+      #
+      # [source] <tt>:env</tt> if called from RR_DEBUG env var,
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #          <tt>:test</tt> from TestHelper (skips remote debugging),
+      #          <tt>:programmatic</tt> otherwise.
+      #--
+      # SPDX-SnippetEnd
+      #++
+      def enable!(source: :programmatic)
+        return @socket_path if @debug_mode_enabled
+
+        @debug_mode_enabled = true
+        enable_rust_backtrace!
+
+        # Tests don't need remote debugging — it would cause hangs
+        return if source == :test
+
+        @remote_debugging_mode = (source == :env) ? :open : :open_nonstop
+        @socket_path = enable_remote_debugging!
+      end
+
+      # rubocop:disable Lint/Debugger -- intentional debug gem integration
+      private def enable_remote_debugging!
+        # Suppress the "Debugger can attach via..." message that corrupts TUI displays
+        # Only suppress for programmatic activation; RR_DEBUG=1 users need to see it
+        old_log_level = ENV["RUBY_DEBUG_LOG_LEVEL"]
+        ENV["RUBY_DEBUG_LOG_LEVEL"] = "ERROR" if @remote_debugging_mode == :open_nonstop
+
+        case @remote_debugging_mode
+        when :open
+          # Stop at load so user can read socket path before TUI enters raw mode
+          ENV["RUBY_DEBUG_STOP_AT_LOAD"] = "1"
+          require "debug/open"
+        when :open_nonstop
+          require "debug/open_nonstop"
+        end
+
+        # Restore log level after require (the require is what prints the message)
+        ENV["RUBY_DEBUG_LOG_LEVEL"] = old_log_level if @remote_debugging_mode == :open_nonstop
+
+        # Return the socket path so apps can display it
+        ::DEBUGGER__.create_unix_domain_socket_name
+      rescue NameError
+        # Windows uses TCP/IP, not Unix sockets — DEBUGGER__ might not have this method
+        nil
+      # rubocop:enable Lint/Debugger
+      rescue LoadError
+        return unless @remote_debugging_mode == :open
+
+        raise LoadError,
+          "RR_DEBUG=1 requires the 'debug' gem for remote debugging. " \
+            "Add `gem 'debug'` to your Gemfile or install it with `gem install debug`."
+      end
+
+      ##
+      # Returns whether full debug mode is enabled.
+      public def enabled?
+        @debug_mode_enabled
+      end
+
+      ##
+      # Returns whether Rust backtraces are enabled.
+      public def rust_backtrace_enabled?
+        @rust_backtrace_enabled
+      end
+
+      ##
+      # Returns the remote debugging mode for debug gem integration.
+      #
+      # TUI apps run in raw terminal mode, making interactive debugging
+      # impossible. The debug gem's remote debugging feature lets you
+      # attach from another terminal via UNIX socket.
+      #
+      # Returns one of:
+      # <tt>:open</tt> Stop at program start, wait for debugger attach.
+      #                   Activated when <tt>RR_DEBUG=1</tt> is set at startup.
+      # <tt>:open_nonstop</tt> Continue running, attach whenever ready.
+      #                           Activated when <tt>enable!</tt> is called programmatically.
+      # <tt>nil</tt> No remote debugging configured.
+      public def remote_debugging_mode
+        @remote_debugging_mode
+      end
+
+      ##
+      # Triggers a Rust panic for backtrace verification.
+      #
+      # Debugging TUI apps is hard. Rust errors lack context. You want to
+      # confirm <tt>RUST_BACKTRACE=1</tt> actually shows stack traces before
+      # hitting a real bug.
+      #
+      # This method deliberately panics. The panic hook catches it and prints
+      # the Rust backtrace to stderr. If you see stack frames, your setup works.
+      #
+      # <b>WARNING</b>: Crashes your process. Use only for debugging.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   RUST_BACKTRACE=1 ruby -e 'require "ratatui_ruby"; RatatuiRuby::Debug.test_panic!'
+      #--
+      # SPDX-SnippetEnd
+      #++
+      public def test_panic!
+        RatatuiRuby.__send__(:_test_panic)
+      end
+
+      ##
+      # Temporarily suppresses Ruby-side debug mode checks.
+      #
+      # Rust backtraces remain enabled if previously activated; only
+      # Ruby-side features (like unknown-key errors) are suppressed
+      # within the block.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   RatatuiRuby::Debug.suppress_debug_mode do
+      #     tui.table({ unknown_key: 1 }) # Does not raise
+      #   end
+      #--
+      # SPDX-SnippetEnd
+      #++
+      public def suppress_debug_mode
+        old_value = @debug_mode_enabled
+        @debug_mode_enabled = false
+        yield
+      ensure
+        @debug_mode_enabled = old_value
+      end
+    end
+  end
+end
+
+# Auto-enable based on environment variables
+RatatuiRuby::Debug.enable_rust_backtrace! if ENV["RUST_BACKTRACE"]
+RatatuiRuby::Debug.enable!(source: :env) if ENV["RR_DEBUG"]

data/lib/ratatui_ruby/event/key.rb

@@ -330,9 +330,10 @@ module RatatuiRuby
       #--
       # SPDX-SnippetEnd
       #++
-      def method_missing(name, *args, &block)
+      def method_missing(name, *args, **kwargs, &block)
         if name.to_s.end_with?("?")
-          key_name = name.to_s[0...-1]
+          name_str = name.to_s
+          key_name = name_str.chop # Returns String, never nil for non-empty string
           key_sym = key_name.to_sym
 
           # Fast path: Exact match (e.g., media_pause? for media_pause)

data/lib/ratatui_ruby/event.rb

@@ -118,7 +118,7 @@ module RatatuiRuby
 
     # Responds to dynamic predicate methods for key checks.
     # All non-Key events return false for any key predicate.
-    def method_missing(name, *args, &block)
+    def method_missing(name, *args, **kwargs, &block)
       if name.to_s.end_with?("?")
         false
       else