ratatui_ruby 0.3.1 → 0.4.0

data/ext/ratatui_ruby/Cargo.toml

@@ -3,15 +3,16 @@
 
 [package]
 name = "ratatui_ruby"
-version = "0.3.1"
+version = "0.4.0"
 edition = "2021"
 
 [lib]
-crate-type = ["cdylib"]
+crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
 magnus = "0.8.2"
-ratatui = { version = "0.29", features = ["widget-calendar"] }
+ratatui = { version = "0.30", features = ["widget-calendar", "layout-cache", "unstable-rendered-line-info"] }
 
+bumpalo = "3.16"
 lazy_static = "1.4"
 time = { version = "0.3", features = ["macros"] }

data/ext/ratatui_ruby/clippy.toml

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+disallowed-methods = [
+    { path = "std::boxed::Box::leak", reason = "Use bumpalo arena allocation instead." },
+    { path = "std::vec::Vec::leak", reason = "Use bumpalo arena allocation instead." },
+]

data/ext/ratatui_ruby/extconf.rb

@@ -9,4 +9,11 @@ require "rb_sys/mkmf"
 create_rust_makefile("ratatui_ruby/ratatui_ruby") do |r|
   # Optional: Force release profile if needed
   # r.profile = ENV.fetch("RB_SYS_CARGO_PROFILE", :release).to_sym
+
+  # Force static linking on musl to avoid "cdylib" issues
+  if RbConfig::CONFIG["target_os"].include?("linux-musl") || RbConfig::CONFIG["host_os"].include?("linux-musl")
+    r.extra_rustc_args = ["--crate-type", "staticlib"]
+  else
+    r.extra_rustc_args = ["--crate-type", "cdylib"]
+  end
 end

data/ext/ratatui_ruby/src/events.rs

@@ -4,136 +4,152 @@
 use magnus::{Error, IntoValue, TryConvert, Value};
 use std::sync::Mutex;
 
-lazy_static::lazy_static! {
-    static ref EVENT_QUEUE: Mutex<Vec<ratatui::crossterm::event::Event>> = Mutex::new(Vec::new());
-}
+static EVENT_QUEUE: Mutex<Vec<ratatui::crossterm::event::Event>> = Mutex::new(Vec::new());
 
+#[allow(clippy::needless_pass_by_value)]
 pub fn inject_test_event(event_type: String, data: magnus::RHash) -> Result<(), Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let event = match event_type.as_str() {
-        "key" => {
-            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,
-            };
+        "key" => parse_key_event(data, &ruby)?,
+        "mouse" => parse_mouse_event(data, &ruby)?,
+        "resize" => parse_resize_event(data, &ruby)?,
+        "paste" => parse_paste_event(data, &ruby)?,
+        "focus_gained" => ratatui::crossterm::event::Event::FocusGained,
+        "focus_lost" => ratatui::crossterm::event::Event::FocusLost,
+        _ => {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("Unknown event type: {event_type}"),
+            ))
+        }
+    };
 
-            let mut modifiers = ratatui::crossterm::event::KeyModifiers::empty();
-            if let Some(mods_val) = data.get(ruby.to_symbol("modifiers")) {
-                let mods: Vec<String> = Vec::try_convert(mods_val)?;
-                for m in mods {
-                    match m.as_str() {
-                        "ctrl" => modifiers |= ratatui::crossterm::event::KeyModifiers::CONTROL,
-                        "alt" => modifiers |= ratatui::crossterm::event::KeyModifiers::ALT,
-                        "shift" => modifiers |= ratatui::crossterm::event::KeyModifiers::SHIFT,
-                        _ => {}
-                    }
-                }
-            }
+    EVENT_QUEUE.lock().unwrap().push(event);
+    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")
+    })?;
+    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,
+    };
 
-            ratatui::crossterm::event::Event::Key(ratatui::crossterm::event::KeyEvent::new(code, modifiers))
+    let mut modifiers = ratatui::crossterm::event::KeyModifiers::empty();
+    if let Some(mods_val) = data.get(ruby.to_symbol("modifiers")) {
+        let mods: Vec<String> = Vec::try_convert(mods_val)?;
+        for m in mods {
+            match m.as_str() {
+                "ctrl" => modifiers |= ratatui::crossterm::event::KeyModifiers::CONTROL,
+                "alt" => modifiers |= ratatui::crossterm::event::KeyModifiers::ALT,
+                "shift" => modifiers |= ratatui::crossterm::event::KeyModifiers::SHIFT,
+                _ => {}
+            }
         }
-        "mouse" => {
-            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")) {
-                let button_str: String = String::try_convert(btn_val)?;
-                match button_str.as_str() {
-                    "right" => ratatui::crossterm::event::MouseButton::Right,
-                    "middle" => ratatui::crossterm::event::MouseButton::Middle,
-                    _ => ratatui::crossterm::event::MouseButton::Left,
-                }
-            } else {
-                ratatui::crossterm::event::MouseButton::Left
-            };
+    Ok(ratatui::crossterm::event::Event::Key(ratatui::crossterm::event::KeyEvent::new(code, modifiers)))
+}
 
-            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)?;
+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 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 button = if let Some(btn_val) = data.get(ruby.to_symbol("button")) {
+        let button_str: String = String::try_convert(btn_val)?;
+        match button_str.as_str() {
+            "right" => ratatui::crossterm::event::MouseButton::Right,
+            "middle" => ratatui::crossterm::event::MouseButton::Middle,
+            _ => ratatui::crossterm::event::MouseButton::Left,
+        }
+    } else {
+        ratatui::crossterm::event::MouseButton::Left
+    };
 
-            let kind = match kind_str.as_str() {
-                "down" => ratatui::crossterm::event::MouseEventKind::Down(button),
-                "up" => ratatui::crossterm::event::MouseEventKind::Up(button),
-                "drag" => ratatui::crossterm::event::MouseEventKind::Drag(button),
-                "moved" => ratatui::crossterm::event::MouseEventKind::Moved,
-                "scroll_down" => ratatui::crossterm::event::MouseEventKind::ScrollDown,
-                "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),
-                    ))
-                }
-            };
+    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 mut modifiers = ratatui::crossterm::event::KeyModifiers::empty();
-            if let Some(mods_val) = data.get(ruby.to_symbol("modifiers")) {
-                let mods: Vec<String> = Vec::try_convert(mods_val)?;
-                for m in mods {
-                    match m.as_str() {
-                        "ctrl" => modifiers |= ratatui::crossterm::event::KeyModifiers::CONTROL,
-                        "alt" => modifiers |= ratatui::crossterm::event::KeyModifiers::ALT,
-                        "shift" => modifiers |= ratatui::crossterm::event::KeyModifiers::SHIFT,
-                        _ => {}
-                    }
-                }
-            }
+    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)?;
 
-            ratatui::crossterm::event::Event::Mouse(ratatui::crossterm::event::MouseEvent {
-                kind,
-                column: x,
-                row: y,
-                modifiers,
-            })
-        }
-        _ => {
-            return Err(Error::new(
-                ruby.exception_arg_error(),
-                format!("Unknown event type: {}", event_type),
-            ))
-        }
+    let kind = match kind_str.as_str() {
+        "down" => ratatui::crossterm::event::MouseEventKind::Down(button),
+        "up" => ratatui::crossterm::event::MouseEventKind::Up(button),
+        "drag" => ratatui::crossterm::event::MouseEventKind::Drag(button),
+        "moved" => ratatui::crossterm::event::MouseEventKind::Moved,
+        "scroll_down" => ratatui::crossterm::event::MouseEventKind::ScrollDown,
+        "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}"))),
     };
 
-    EVENT_QUEUE.lock().unwrap().push(event);
-    Ok(())
+    let mut modifiers = ratatui::crossterm::event::KeyModifiers::empty();
+    if let Some(mods_val) = data.get(ruby.to_symbol("modifiers")) {
+        let mods: Vec<String> = Vec::try_convert(mods_val)?;
+        for m in mods {
+            match m.as_str() {
+                "ctrl" => modifiers |= ratatui::crossterm::event::KeyModifiers::CONTROL,
+                "alt" => modifiers |= ratatui::crossterm::event::KeyModifiers::ALT,
+                "shift" => modifiers |= ratatui::crossterm::event::KeyModifiers::SHIFT,
+                _ => {}
+            }
+        }
+    }
+
+    Ok(ratatui::crossterm::event::Event::Mouse(ratatui::crossterm::event::MouseEvent { kind, column: x, row: y, modifiers }))
 }
 
-pub fn poll_event() -> Result<Value, Error> {
-    let ruby = magnus::Ruby::get().unwrap();
+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")
+    })?;
+    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")
+    })?;
+    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> {
+    let content_val: Value = data.get(ruby.to_symbol("content")).ok_or_else(|| {
+        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))
+}
+
+pub fn clear_events() {
+    EVENT_QUEUE.lock().unwrap().clear();
+}
+
+pub fn poll_event(ruby: &magnus::Ruby) -> Result<Value, Error> {
     let event = {
         let mut queue = EVENT_QUEUE.lock().unwrap();
-        if !queue.is_empty() {
-            Some(queue.remove(0))
-        } else {
+        if queue.is_empty() {
             None
+        } else {
+            Some(queue.remove(0))
         }
     };
 
@@ -141,17 +157,13 @@ pub fn poll_event() -> Result<Value, Error> {
         return handle_event(e);
     }
 
-    // Check if we are in test mode. If so, don't poll crossterm.
     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(&magnus::Ruby::get().unwrap()));
+        return Ok(ruby.qnil().into_value_with(ruby));
     }
 
     if ratatui::crossterm::event::poll(std::time::Duration::from_millis(16))
@@ -161,127 +173,104 @@ pub fn poll_event() -> Result<Value, Error> {
             .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
         handle_event(event)
     } else {
-        Ok(ruby.qnil().into_value_with(&magnus::Ruby::get().unwrap()))
+        Ok(ruby.qnil().into_value_with(ruby))
     }
 }
 
 fn handle_event(event: ratatui::crossterm::event::Event) -> Result<Value, Error> {
-    let ruby = magnus::Ruby::get().unwrap();
     match event {
-        ratatui::crossterm::event::Event::Key(key) => {
-            if key.kind == ratatui::crossterm::event::KeyEventKind::Press {
-                let ruby = magnus::Ruby::get().unwrap();
-                let hash = ruby.hash_new();
-                hash.aset(ruby.to_symbol("type"), ruby.to_symbol("key"))?;
-
-                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(),
-                };
-                hash.aset(ruby.to_symbol("code"), code)?;
-
-                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)?;
-                }
-
-            return Ok(hash.into_value_with(&ruby));
-            }
-        }
-        ratatui::crossterm::event::Event::Mouse(event) => {
-            let ruby = magnus::Ruby::get().unwrap();
-            let hash = ruby.hash_new();
-            hash.aset(ruby.to_symbol("type"), ruby.to_symbol("mouse"))?;
-
-            let (kind, button) = match event.kind {
-                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)
-                } // button is ignored for moved
-                ratatui::crossterm::event::MouseEventKind::ScrollDown => {
-                    ("scroll_down", ratatui::crossterm::event::MouseButton::Left)
-                } // button is ignored for scroll
-                ratatui::crossterm::event::MouseEventKind::ScrollUp => {
-                    ("scroll_up", ratatui::crossterm::event::MouseButton::Left)
-                } // button is ignored for scroll
-                ratatui::crossterm::event::MouseEventKind::ScrollLeft => {
-                    ("scroll_left", ratatui::crossterm::event::MouseButton::Left)
-                } // button is ignored for scroll
-                ratatui::crossterm::event::MouseEventKind::ScrollRight => {
-                    ("scroll_right", ratatui::crossterm::event::MouseButton::Left)
-                } // button is ignored for scroll
-            };
+        ratatui::crossterm::event::Event::Key(key) => handle_key_event(key),
+        ratatui::crossterm::event::Event::Mouse(event) => handle_mouse_event(event),
+        ratatui::crossterm::event::Event::Resize(w, h) => handle_resize_event(w, h),
+        ratatui::crossterm::event::Event::Paste(content) => handle_paste_event(content),
+        ratatui::crossterm::event::Event::FocusGained => handle_focus_event("focus_gained"),
+        ratatui::crossterm::event::Event::FocusLost => handle_focus_event("focus_lost"),
+    }
+}
 
-            hash.aset(ruby.to_symbol("kind"), ruby.to_symbol(kind))?;
+fn handle_key_event(key: ratatui::crossterm::event::KeyEvent) -> Result<Value, Error> {
+    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"))?;
+    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(),
+    };
+    hash.aset(ruby.to_symbol("code"), code)?;
+    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)?; }
+    Ok(hash.into_value_with(&ruby))
+}
 
-            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",
-                    ratatui::crossterm::event::MouseButton::Middle => "middle",
-                };
-                hash.aset(ruby.to_symbol("button"), ruby.to_symbol(btn_sym))?;
-            } else {
-                hash.aset(ruby.to_symbol("button"), ruby.to_symbol("none"))?;
-            }
+fn handle_mouse_event(event: ratatui::crossterm::event::MouseEvent) -> Result<Value, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let hash = ruby.hash_new();
+    hash.aset(ruby.to_symbol("type"), ruby.to_symbol("mouse"))?;
+    let (kind, button) = match event.kind {
+        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),
+    };
+    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(_)) {
+        let btn_sym = match button {
+            ratatui::crossterm::event::MouseButton::Left => "left",
+            ratatui::crossterm::event::MouseButton::Right => "right",
+            ratatui::crossterm::event::MouseButton::Middle => "middle",
+        };
+        hash.aset(ruby.to_symbol("button"), ruby.to_symbol(btn_sym))?;
+    } else {
+        hash.aset(ruby.to_symbol("button"), ruby.to_symbol("none"))?;
+    }
+    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"); }
+    hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
+    Ok(hash.into_value_with(&ruby))
+}
 
-            hash.aset(ruby.to_symbol("x"), event.column)?;
-            hash.aset(ruby.to_symbol("y"), event.row)?;
+fn handle_resize_event(w: u16, h: u16) -> Result<Value, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let hash = ruby.hash_new();
+    hash.aset(ruby.to_symbol("type"), ruby.to_symbol("resize"))?;
+    hash.aset(ruby.to_symbol("width"), w)?;
+    hash.aset(ruby.to_symbol("height"), h)?;
+    Ok(hash.into_value_with(&ruby))
+}
 
-            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");
-            }
-            hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
+fn handle_paste_event(content: String) -> Result<Value, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let hash = ruby.hash_new();
+    hash.aset(ruby.to_symbol("type"), ruby.to_symbol("paste"))?;
+    hash.aset(ruby.to_symbol("content"), content)?;
+    Ok(hash.into_value_with(&ruby))
+}
 
-            return Ok(hash.into_value_with(&ruby));
-        }
-        _ => {}
-    }
-    Ok(ruby.qnil().into_value_with(&magnus::Ruby::get().unwrap()))
+fn handle_focus_event(event_type: &str) -> Result<Value, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let hash = ruby.hash_new();
+    hash.aset(ruby.to_symbol("type"), ruby.to_symbol(event_type))?;
+    Ok(hash.into_value_with(&ruby))
 }

data/ext/ratatui_ruby/src/lib.rs

@@ -1,25 +1,35 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-mod buffer;
+// Require SAFETY comments on all unsafe blocks
+#![warn(clippy::undocumented_unsafe_blocks)]
+// Enable pedantic lints for stricter code quality
+#![warn(clippy::pedantic)]
+// Allow certain pedantic lints that are too noisy for FFI code
+#![allow(clippy::missing_errors_doc)]
+#![allow(clippy::missing_panics_doc)]
+#![allow(clippy::module_name_repetitions)]
+
 mod events;
 mod rendering;
 mod style;
 mod terminal;
+mod text;
 mod widgets;
 
-use magnus::{function, Class, Error, Module, Value};
+use magnus::{function, Error, Module, Object, Value};
 use terminal::{init_terminal, restore_terminal, TERMINAL};
 
 fn draw(tree: Value) -> Result<(), Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let mut term_lock = TERMINAL.lock().unwrap();
+    let mut render_error = None;
     if let Some(wrapper) = term_lock.as_mut() {
         match wrapper {
             terminal::TerminalWrapper::Crossterm(term) => {
                 term.draw(|f| {
                     if let Err(e) = rendering::render_node(f, f.area(), tree) {
-                        eprintln!("Render error: {:?}", e);
+                        render_error = Some(e);
                     }
                 })
                 .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
@@ -27,7 +37,7 @@ fn draw(tree: Value) -> Result<(), Error> {
             terminal::TerminalWrapper::Test(term) => {
                 term.draw(|f| {
                     if let Err(e) = rendering::render_node(f, f.area(), tree) {
-                        eprintln!("Render error: {:?}", e);
+                        render_error = Some(e);
                     }
                 })
                 .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
@@ -36,6 +46,11 @@ fn draw(tree: Value) -> Result<(), Error> {
     } else {
         eprintln!("Terminal is None!");
     }
+
+    if let Some(e) = render_error {
+        return Err(e);
+    }
+
     Ok(())
 }
 
@@ -44,16 +59,14 @@ fn init() -> Result<(), Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let m = ruby.define_module("RatatuiRuby")?;
 
-    let buffer_class = m.define_class("Buffer", ruby.class_object())?;
-    buffer_class.undef_default_alloc_func();
-    buffer_class.define_method("set_string", magnus::method!(buffer::BufferWrapper::set_string, 4))?;
-    buffer_class.define_method("area", magnus::method!(buffer::BufferWrapper::area, 0))?;
 
-    m.define_module_function("init_terminal", function!(init_terminal, 0))?;
+
+    m.define_module_function("_init_terminal", function!(init_terminal, 2))?;
     m.define_module_function("restore_terminal", function!(restore_terminal, 0))?;
     m.define_module_function("draw", function!(draw, 1))?;
-    m.define_module_function("poll_event", function!(events::poll_event, 0))?;
+    m.define_module_function("_poll_event", function!(events::poll_event, 0))?;
     m.define_module_function("inject_test_event", function!(events::inject_test_event, 2))?;
+    m.define_module_function("clear_events", function!(events::clear_events, 0))?;
 
     // Test backend helpers
     m.define_module_function(
@@ -68,8 +81,23 @@ fn init() -> Result<(), Error> {
         "get_cursor_position",
         function!(terminal::get_cursor_position, 0),
     )?;
+    m.define_module_function(
+        "_get_cell_at",
+        function!(terminal::get_cell_at, 2),
+    )?;
     m.define_module_function("resize_terminal", function!(terminal::resize_terminal, 2))?;
 
+    // Register Layout.split on the Layout class
+    let layout_class = m.const_get::<_, magnus::RClass>("Layout")?;
+    layout_class.define_singleton_method("_split", function!(widgets::layout::split_layout, 4))?;
+    
+    // Paragraph metrics
+    m.define_module_function("_paragraph_line_count", function!(widgets::paragraph::line_count, 2))?;
+    m.define_module_function("_paragraph_line_width", function!(widgets::paragraph::line_width, 1))?;
+
+    // Tabs metrics
+    m.define_module_function("_tabs_width", function!(widgets::tabs::width, 1))?;
+
     Ok(())
 }