ratatui_ruby 0.2.0 → 0.3.1

data/ext/ratatui_ruby/src/events.rs

@@ -1,112 +1,113 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use magnus::{Error, IntoValue, Symbol, TryConvert, Value};
+use magnus::{Error, IntoValue, TryConvert, Value};
 use std::sync::Mutex;
 
 lazy_static::lazy_static! {
-    static ref EVENT_QUEUE: Mutex<Vec<crossterm::event::Event>> = Mutex::new(Vec::new());
+    static ref EVENT_QUEUE: Mutex<Vec<ratatui::crossterm::event::Event>> = Mutex::new(Vec::new());
 }
 
 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(Symbol::new("code")).ok_or_else(|| {
+            let code_val: Value = data.get(ruby.to_symbol("code")).ok_or_else(|| {
                 Error::new(
-                    magnus::exception::arg_error(),
+                    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" => crossterm::event::KeyCode::Up,
-                "down" => crossterm::event::KeyCode::Down,
-                "left" => crossterm::event::KeyCode::Left,
-                "right" => crossterm::event::KeyCode::Right,
-                "enter" => crossterm::event::KeyCode::Enter,
-                "esc" => crossterm::event::KeyCode::Esc,
-                "backspace" => crossterm::event::KeyCode::Backspace,
-                "tab" => crossterm::event::KeyCode::Tab,
-                c if c.len() == 1 => crossterm::event::KeyCode::Char(c.chars().next().unwrap()),
-                _ => crossterm::event::KeyCode::Null,
+                "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,
             };
 
-            let mut modifiers = crossterm::event::KeyModifiers::empty();
-            if let Some(mods_val) = data.get(Symbol::new("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 |= crossterm::event::KeyModifiers::CONTROL,
-                        "alt" => modifiers |= crossterm::event::KeyModifiers::ALT,
-                        "shift" => modifiers |= crossterm::event::KeyModifiers::SHIFT,
+                        "ctrl" => modifiers |= ratatui::crossterm::event::KeyModifiers::CONTROL,
+                        "alt" => modifiers |= ratatui::crossterm::event::KeyModifiers::ALT,
+                        "shift" => modifiers |= ratatui::crossterm::event::KeyModifiers::SHIFT,
                         _ => {}
                     }
                 }
             }
 
-            crossterm::event::Event::Key(crossterm::event::KeyEvent::new(code, modifiers))
+            ratatui::crossterm::event::Event::Key(ratatui::crossterm::event::KeyEvent::new(code, modifiers))
         }
         "mouse" => {
-            let kind_val: Value = data.get(Symbol::new("kind")).ok_or_else(|| {
+            let kind_val: Value = data.get(ruby.to_symbol("kind")).ok_or_else(|| {
                 Error::new(
-                    magnus::exception::arg_error(),
+                    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(Symbol::new("button")) {
+            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" => crossterm::event::MouseButton::Right,
-                    "middle" => crossterm::event::MouseButton::Middle,
-                    _ => crossterm::event::MouseButton::Left,
+                    "right" => ratatui::crossterm::event::MouseButton::Right,
+                    "middle" => ratatui::crossterm::event::MouseButton::Middle,
+                    _ => ratatui::crossterm::event::MouseButton::Left,
                 }
             } else {
-                crossterm::event::MouseButton::Left
+                ratatui::crossterm::event::MouseButton::Left
             };
 
-            let x_val: Value = data.get(Symbol::new("x")).ok_or_else(|| {
-                Error::new(magnus::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(Symbol::new("y")).ok_or_else(|| {
-                Error::new(magnus::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() {
-                "down" => crossterm::event::MouseEventKind::Down(button),
-                "up" => crossterm::event::MouseEventKind::Up(button),
-                "drag" => crossterm::event::MouseEventKind::Drag(button),
-                "moved" => crossterm::event::MouseEventKind::Moved,
-                "scroll_down" => crossterm::event::MouseEventKind::ScrollDown,
-                "scroll_up" => crossterm::event::MouseEventKind::ScrollUp,
-                "scroll_left" => crossterm::event::MouseEventKind::ScrollLeft,
-                "scroll_right" => crossterm::event::MouseEventKind::ScrollRight,
+                "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(
-                        magnus::exception::arg_error(),
+                        ruby.exception_arg_error(),
                         format!("Unknown mouse kind: {}", kind_str),
                     ))
                 }
             };
 
-            let mut modifiers = crossterm::event::KeyModifiers::empty();
-            if let Some(mods_val) = data.get(Symbol::new("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 |= crossterm::event::KeyModifiers::CONTROL,
-                        "alt" => modifiers |= crossterm::event::KeyModifiers::ALT,
-                        "shift" => modifiers |= crossterm::event::KeyModifiers::SHIFT,
+                        "ctrl" => modifiers |= ratatui::crossterm::event::KeyModifiers::CONTROL,
+                        "alt" => modifiers |= ratatui::crossterm::event::KeyModifiers::ALT,
+                        "shift" => modifiers |= ratatui::crossterm::event::KeyModifiers::SHIFT,
                         _ => {}
                     }
                 }
             }
 
-            crossterm::event::Event::Mouse(crossterm::event::MouseEvent {
+            ratatui::crossterm::event::Event::Mouse(ratatui::crossterm::event::MouseEvent {
                 kind,
                 column: x,
                 row: y,
@@ -115,7 +116,7 @@ pub fn inject_test_event(event_type: String, data: magnus::RHash) -> Result<(),
         }
         _ => {
             return Err(Error::new(
-                magnus::exception::arg_error(),
+                ruby.exception_arg_error(),
                 format!("Unknown event type: {}", event_type),
             ))
         }
@@ -126,6 +127,7 @@ pub fn inject_test_event(event_type: String, data: magnus::RHash) -> Result<(),
 }
 
 pub fn poll_event() -> Result<Value, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let event = {
         let mut queue = EVENT_QUEUE.lock().unwrap();
         if !queue.is_empty() {
@@ -149,134 +151,137 @@ pub fn poll_event() -> Result<Value, Error> {
     };
 
     if is_test_mode {
-        return Ok(magnus::value::qnil().into_value());
+        return Ok(ruby.qnil().into_value_with(&magnus::Ruby::get().unwrap()));
     }
 
-    if crossterm::event::poll(std::time::Duration::from_millis(16))
-        .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?
+    if ratatui::crossterm::event::poll(std::time::Duration::from_millis(16))
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?
     {
-        let event = crossterm::event::read()
-            .map_err(|e| Error::new(magnus::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(magnus::value::qnil().into_value())
+        Ok(ruby.qnil().into_value_with(&magnus::Ruby::get().unwrap()))
     }
 }
 
-fn handle_event(event: crossterm::event::Event) -> Result<Value, Error> {
+fn handle_event(event: ratatui::crossterm::event::Event) -> Result<Value, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     match event {
-        crossterm::event::Event::Key(key) => {
-            if key.kind == crossterm::event::KeyEventKind::Press {
-                let hash = magnus::RHash::new();
-                hash.aset(Symbol::new("type"), Symbol::new("key"))?;
+        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 {
-                    crossterm::event::KeyCode::Char(c) => c.to_string(),
-                    crossterm::event::KeyCode::Up => "up".to_string(),
-                    crossterm::event::KeyCode::Down => "down".to_string(),
-                    crossterm::event::KeyCode::Left => "left".to_string(),
-                    crossterm::event::KeyCode::Right => "right".to_string(),
-                    crossterm::event::KeyCode::Enter => "enter".to_string(),
-                    crossterm::event::KeyCode::Esc => "esc".to_string(),
-                    crossterm::event::KeyCode::Backspace => "backspace".to_string(),
-                    crossterm::event::KeyCode::Tab => "tab".to_string(),
+                    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(Symbol::new("code"), code)?;
+                hash.aset(ruby.to_symbol("code"), code)?;
 
                 let mut modifiers = Vec::new();
                 if key
                     .modifiers
-                    .contains(crossterm::event::KeyModifiers::CONTROL)
+                    .contains(ratatui::crossterm::event::KeyModifiers::CONTROL)
                 {
                     modifiers.push("ctrl");
                 }
-                if key.modifiers.contains(crossterm::event::KeyModifiers::ALT) {
+                if key.modifiers.contains(ratatui::crossterm::event::KeyModifiers::ALT) {
                     modifiers.push("alt");
                 }
                 if key
                     .modifiers
-                    .contains(crossterm::event::KeyModifiers::SHIFT)
+                    .contains(ratatui::crossterm::event::KeyModifiers::SHIFT)
                 {
                     modifiers.push("shift");
                 }
                 if !modifiers.is_empty() {
-                    hash.aset(Symbol::new("modifiers"), modifiers)?;
+                    hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
                 }
 
-                return Ok(hash.into_value());
+            return Ok(hash.into_value_with(&ruby));
             }
         }
-        crossterm::event::Event::Mouse(event) => {
-            let hash = magnus::RHash::new();
-            hash.aset(Symbol::new("type"), Symbol::new("mouse"))?;
+        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 {
-                crossterm::event::MouseEventKind::Down(btn) => ("down", btn),
-                crossterm::event::MouseEventKind::Up(btn) => ("up", btn),
-                crossterm::event::MouseEventKind::Drag(btn) => ("drag", btn),
-                crossterm::event::MouseEventKind::Moved => {
-                    ("moved", crossterm::event::MouseButton::Left)
+                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
-                crossterm::event::MouseEventKind::ScrollDown => {
-                    ("scroll_down", crossterm::event::MouseButton::Left)
+                ratatui::crossterm::event::MouseEventKind::ScrollDown => {
+                    ("scroll_down", ratatui::crossterm::event::MouseButton::Left)
                 } // button is ignored for scroll
-                crossterm::event::MouseEventKind::ScrollUp => {
-                    ("scroll_up", crossterm::event::MouseButton::Left)
+                ratatui::crossterm::event::MouseEventKind::ScrollUp => {
+                    ("scroll_up", ratatui::crossterm::event::MouseButton::Left)
                 } // button is ignored for scroll
-                crossterm::event::MouseEventKind::ScrollLeft => {
-                    ("scroll_left", crossterm::event::MouseButton::Left)
+                ratatui::crossterm::event::MouseEventKind::ScrollLeft => {
+                    ("scroll_left", ratatui::crossterm::event::MouseButton::Left)
                 } // button is ignored for scroll
-                crossterm::event::MouseEventKind::ScrollRight => {
-                    ("scroll_right", crossterm::event::MouseButton::Left)
+                ratatui::crossterm::event::MouseEventKind::ScrollRight => {
+                    ("scroll_right", ratatui::crossterm::event::MouseButton::Left)
                 } // button is ignored for scroll
             };
 
-            hash.aset(Symbol::new("kind"), Symbol::new(kind))?;
+            hash.aset(ruby.to_symbol("kind"), ruby.to_symbol(kind))?;
 
             if matches!(
                 event.kind,
-                crossterm::event::MouseEventKind::Down(_)
-                    | crossterm::event::MouseEventKind::Up(_)
-                    | crossterm::event::MouseEventKind::Drag(_)
+                ratatui::crossterm::event::MouseEventKind::Down(_)
+                    | ratatui::crossterm::event::MouseEventKind::Up(_)
+                    | ratatui::crossterm::event::MouseEventKind::Drag(_)
             ) {
                 let btn_sym = match button {
-                    crossterm::event::MouseButton::Left => "left",
-                    crossterm::event::MouseButton::Right => "right",
-                    crossterm::event::MouseButton::Middle => "middle",
+                    ratatui::crossterm::event::MouseButton::Left => "left",
+                    ratatui::crossterm::event::MouseButton::Right => "right",
+                    ratatui::crossterm::event::MouseButton::Middle => "middle",
                 };
-                hash.aset(Symbol::new("button"), Symbol::new(btn_sym))?;
+                hash.aset(ruby.to_symbol("button"), ruby.to_symbol(btn_sym))?;
             } else {
-                hash.aset(Symbol::new("button"), Symbol::new("none"))?;
+                hash.aset(ruby.to_symbol("button"), ruby.to_symbol("none"))?;
             }
 
-            hash.aset(Symbol::new("x"), event.column)?;
-            hash.aset(Symbol::new("y"), event.row)?;
+            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(crossterm::event::KeyModifiers::CONTROL)
+                .contains(ratatui::crossterm::event::KeyModifiers::CONTROL)
             {
                 modifiers.push("ctrl");
             }
             if event
                 .modifiers
-                .contains(crossterm::event::KeyModifiers::ALT)
+                .contains(ratatui::crossterm::event::KeyModifiers::ALT)
             {
                 modifiers.push("alt");
             }
             if event
                 .modifiers
-                .contains(crossterm::event::KeyModifiers::SHIFT)
+                .contains(ratatui::crossterm::event::KeyModifiers::SHIFT)
             {
                 modifiers.push("shift");
             }
-            hash.aset(Symbol::new("modifiers"), modifiers)?;
+            hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
 
-            return Ok(hash.into_value());
+            return Ok(hash.into_value_with(&ruby));
         }
         _ => {}
     }
-    Ok(magnus::value::qnil().into_value())
+    Ok(ruby.qnil().into_value_with(&magnus::Ruby::get().unwrap()))
 }

data/ext/ratatui_ruby/src/lib.rs

@@ -1,34 +1,36 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+mod buffer;
 mod events;
 mod rendering;
 mod style;
 mod terminal;
 mod widgets;
 
-use magnus::{define_module, function, Error, Value};
+use magnus::{function, Class, Error, Module, 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();
     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.size(), tree) {
+                    if let Err(e) = rendering::render_node(f, f.area(), tree) {
                         eprintln!("Render error: {:?}", e);
                     }
                 })
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
             }
             terminal::TerminalWrapper::Test(term) => {
                 term.draw(|f| {
-                    if let Err(e) = rendering::render_node(f, f.size(), tree) {
+                    if let Err(e) = rendering::render_node(f, f.area(), tree) {
                         eprintln!("Render error: {:?}", e);
                     }
                 })
-                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
             }
         }
     } else {
@@ -39,7 +41,14 @@ fn draw(tree: Value) -> Result<(), Error> {
 
 #[magnus::init]
 fn init() -> Result<(), Error> {
-    let m = define_module("RatatuiRuby")?;
+    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("restore_terminal", function!(restore_terminal, 0))?;
     m.define_module_function("draw", function!(draw, 1))?;

data/ext/ratatui_ruby/src/rendering.rs

@@ -1,16 +1,31 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use crate::buffer::BufferWrapper;
 use crate::widgets;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, Frame};
 
 pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    if node.respond_to("render", true)? {
+        let wrapper = BufferWrapper::new(frame.buffer_mut());
+        let ruby = magnus::Ruby::get().unwrap();
+        let ruby_area = {
+            let module = ruby.define_module("RatatuiRuby")?;
+            let class = module.const_get::<_, magnus::RClass>("Rect")?;
+            class.funcall::<_, _, Value>("new", (area.x, area.y, area.width, area.height))?
+        };
+        let wrapper_obj = ruby.obj_wrap(wrapper);
+        node.funcall::<_, _, Value>("render", (ruby_area, wrapper_obj))?;
+        return Ok(());
+    }
+
     let class = node.class();
     let class_name = unsafe { class.name() };
 
     match class_name.as_ref() {
         "RatatuiRuby::Paragraph" => widgets::paragraph::render(frame, area, node)?,
+        "RatatuiRuby::Clear" => widgets::clear::render(frame, area, node)?,
         "RatatuiRuby::Cursor" => widgets::cursor::render(frame, area, node)?,
         "RatatuiRuby::Overlay" => widgets::overlay::render(frame, area, node)?,
         "RatatuiRuby::Center" => widgets::center::render(frame, area, node)?,

data/ext/ratatui_ruby/src/style.rs

@@ -12,6 +12,7 @@ pub fn parse_color(color_str: &str) -> Option<Color> {
 }
 
 pub fn parse_style(style_val: Value) -> Result<Style, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     if style_val.is_nil() {
         return Ok(Style::default());
     }
@@ -38,7 +39,7 @@ pub fn parse_style(style_val: Value) -> Result<Style, Error> {
     if !modifiers_val.is_nil() {
         let modifiers_array = magnus::RArray::from_value(modifiers_val).ok_or_else(|| {
             Error::new(
-                magnus::exception::type_error(),
+                ruby.exception_type_error(),
                 "expected array for modifiers",
             )
         })?;

data/ext/ratatui_ruby/src/terminal.rs

@@ -19,30 +19,32 @@ lazy_static::lazy_static! {
 }
 
 pub fn init_terminal() -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let mut term_lock = TERMINAL.lock().unwrap();
     if term_lock.is_none() {
-        crossterm::terminal::enable_raw_mode()
-            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        ratatui::crossterm::terminal::enable_raw_mode()
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
         let mut stdout = io::stdout();
-        crossterm::execute!(
+        ratatui::crossterm::execute!(
             stdout,
-            crossterm::terminal::EnterAlternateScreen,
-            crossterm::event::EnableMouseCapture
+            ratatui::crossterm::terminal::EnterAlternateScreen,
+            ratatui::crossterm::event::EnableMouseCapture
         )
-        .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
         let backend = CrosstermBackend::new(stdout);
         let terminal = Terminal::new(backend)
-            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
         *term_lock = Some(TerminalWrapper::Crossterm(terminal));
     }
     Ok(())
 }
 
 pub fn init_test_terminal(width: u16, height: u16) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let mut term_lock = TERMINAL.lock().unwrap();
     let backend = TestBackend::new(width, height);
     let terminal = Terminal::new(backend)
-        .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
     *term_lock = Some(TerminalWrapper::Test(terminal));
     Ok(())
 }
@@ -50,17 +52,18 @@ pub fn init_test_terminal(width: u16, height: u16) -> Result<(), Error> {
 pub fn restore_terminal() -> Result<(), Error> {
     let mut term_lock = TERMINAL.lock().unwrap();
     if let Some(TerminalWrapper::Crossterm(mut terminal)) = term_lock.take() {
-        let _ = crossterm::terminal::disable_raw_mode();
-        let _ = crossterm::execute!(
+        let _ = ratatui::crossterm::terminal::disable_raw_mode();
+        let _ = ratatui::crossterm::execute!(
             terminal.backend_mut(),
-            crossterm::terminal::LeaveAlternateScreen,
-            crossterm::event::DisableMouseCapture
+            ratatui::crossterm::terminal::LeaveAlternateScreen,
+            ratatui::crossterm::event::DisableMouseCapture
         );
     }
     Ok(())
 }
 
 pub fn get_buffer_content() -> Result<String, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let term_lock = TERMINAL.lock().unwrap();
     if let Some(TerminalWrapper::Test(terminal)) = term_lock.as_ref() {
         // We need to access the buffer.
@@ -74,7 +77,7 @@ pub fn get_buffer_content() -> Result<String, Error> {
         let mut result = String::new();
         for y in 0..area.height {
             for x in 0..area.width {
-                let cell = buffer.get(x, y);
+                let cell = buffer.cell((x, y)).unwrap();
                 result.push_str(cell.symbol());
             }
             result.push('\n');
@@ -82,28 +85,30 @@ pub fn get_buffer_content() -> Result<String, Error> {
         Ok(result)
     } else {
         Err(Error::new(
-            magnus::exception::runtime_error(),
+            ruby.exception_runtime_error(),
             "Terminal is not initialized as TestBackend",
         ))
     }
 }
 
 pub fn get_cursor_position() -> Result<Option<(u16, u16)>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let mut term_lock = TERMINAL.lock().unwrap();
     if let Some(TerminalWrapper::Test(terminal)) = term_lock.as_mut() {
         let pos = terminal
-            .get_cursor()
-            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
-        Ok(Some(pos))
+            .get_cursor_position()
+            .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+        Ok(Some(pos.into()))
     } else {
         Err(Error::new(
-            magnus::exception::runtime_error(),
+            ruby.exception_runtime_error(),
             "Terminal is not initialized as TestBackend",
         ))
     }
 }
 
 pub fn resize_terminal(width: u16, height: u16) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let mut term_lock = TERMINAL.lock().unwrap();
     if let Some(wrapper) = term_lock.as_mut() {
         match wrapper {
@@ -118,7 +123,7 @@ pub fn resize_terminal(width: u16, height: u16) -> Result<(), Error> {
                 // We might need to call terminal.resize() too if Ratatui caches the size.
                 if let Err(e) = terminal.resize(ratatui::layout::Rect::new(0, 0, width, height)) {
                     return Err(Error::new(
-                        magnus::exception::runtime_error(),
+                        ruby.exception_runtime_error(),
                         e.to_string(),
                     ));
                 }

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

@@ -12,6 +12,7 @@ use std::convert::TryFrom;
 use time::{Date, Month};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let year: i32 = node.funcall("year", ())?;
     let month_u8: u8 = node.funcall("month", ())?;
     let day_style_val: Value = node.funcall("day_style", ())?;
@@ -19,10 +20,10 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let block_val: Value = node.funcall("block", ())?;
 
     let month = Month::try_from(month_u8)
-        .map_err(|e| Error::new(magnus::exception::arg_error(), e.to_string()))?;
+        .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
 
     let date = Date::from_calendar_date(year, month, 1)
-        .map_err(|e| Error::new(magnus::exception::arg_error(), e.to_string()))?;
+        .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
 
     let mut calendar = Monthly::new(date, CalendarEventStore::default());
 
@@ -63,7 +64,7 @@ mod tests {
         let mut content = String::new();
         for y in 0..20 {
             for x in 0..40 {
-                content.push_str(buf.get(x, y).symbol());
+                content.push_str(buf.cell((x, y)).unwrap().symbol());
             }
             content.push('\n');
         }

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

@@ -36,8 +36,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
     }
 
     let canvas = canvas.paint(|ctx| {
-        for shape_val in shapes_val.each() {
-            let shape_val = shape_val.unwrap();
+        for shape_val in shapes_val {
             let class = shape_val.class();
             let class_name = unsafe { class.name() };