ratatui_ruby 0.10.1 → 0.10.2

data/ext/ratatui_ruby/src/terminal.rs.orig

@@ -0,0 +1,409 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::value::ReprValue;
+use magnus::{Error, Module};
+use ratatui::{
+    backend::{CrosstermBackend, TestBackend},
+    Terminal, TerminalOptions, Viewport,
+};
+use std::io;
+use std::sync::Mutex;
+
+pub enum TerminalWrapper {
+    Crossterm(Terminal<CrosstermBackend<io::Stdout>>),
+    Test(Terminal<TestBackend>),
+}
+
+pub static TERMINAL: Mutex<Option<TerminalWrapper>> = Mutex::new(None);
+
+pub fn init_terminal(
+    focus_events: bool,
+    bracketed_paste: bool,
+    viewport_type: String,
+    viewport_height: Option<u16>,
+) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if term_lock.is_none() {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+
+        // Parse viewport type
+        let viewport = match viewport_type.as_str() {
+            "inline" => {
+                let height = viewport_height.unwrap_or(8);
+                Viewport::Inline(height)
+            }
+            _ => Viewport::Fullscreen,
+        };
+
+        ratatui::crossterm::terminal::enable_raw_mode()
+            .map_err(|e| Error::new(error_class, e.to_string()))?;
+        let mut stdout = io::stdout();
+
+        // Only enter alternate screen for fullscreen viewports
+        if matches!(viewport, Viewport::Fullscreen) {
+            ratatui::crossterm::execute!(
+                stdout,
+                ratatui::crossterm::terminal::EnterAlternateScreen
+            )
+            .map_err(|e| Error::new(error_class, e.to_string()))?;
+        }
+
+        ratatui::crossterm::execute!(stdout, ratatui::crossterm::event::EnableMouseCapture)
+            .map_err(|e| Error::new(error_class, e.to_string()))?;
+
+        if focus_events {
+            ratatui::crossterm::execute!(stdout, ratatui::crossterm::event::EnableFocusChange)
+                .map_err(|e| Error::new(error_class, e.to_string()))?;
+        }
+        if bracketed_paste {
+            ratatui::crossterm::execute!(stdout, ratatui::crossterm::event::EnableBracketedPaste)
+                .map_err(|e| Error::new(error_class, e.to_string()))?;
+        }
+
+        let backend = CrosstermBackend::new(stdout);
+        let options = TerminalOptions { viewport };
+        let terminal = Terminal::with_options(backend, options)
+            .map_err(|e| Error::new(error_class, e.to_string()))?;
+        *term_lock = Some(TerminalWrapper::Crossterm(terminal));
+    }
+    Ok(())
+}
+
+pub fn init_test_terminal(
+    width: u16,
+    height: u16,
+    viewport_type: String,
+    viewport_height: Option<u16>,
+) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let mut term_lock = TERMINAL.lock().unwrap();
+    let backend = TestBackend::new(width, height);
+    let module = ruby.define_module("RatatuiRuby")?;
+    let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+    let error_class = error_base.const_get("Terminal")?;
+
+    // Parse viewport type (same as init_terminal)
+    let viewport = match viewport_type.as_str() {
+        "inline" => {
+            let vp_height = viewport_height.unwrap_or(height);
+            Viewport::Inline(vp_height)
+        }
+        _ => Viewport::Fullscreen,
+    };
+
+    let options = TerminalOptions { viewport };
+    let terminal = Terminal::with_options(backend, options)
+        .map_err(|e| Error::new(error_class, e.to_string()))?;
+    *term_lock = Some(TerminalWrapper::Test(terminal));
+    Ok(())
+}
+
+pub fn restore_terminal() {
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if let Some(wrapper) = term_lock.take() {
+        match wrapper {
+            TerminalWrapper::Crossterm(mut t) => {
+                let _ = ratatui::crossterm::terminal::disable_raw_mode();
+                let _ = ratatui::crossterm::execute!(
+                    t.backend_mut(),
+                    ratatui::crossterm::terminal::LeaveAlternateScreen,
+                    ratatui::crossterm::event::DisableMouseCapture,
+                    ratatui::crossterm::event::DisableFocusChange,
+                    ratatui::crossterm::event::DisableBracketedPaste
+                );
+            }
+            TerminalWrapper::Test(_) => {}
+        }
+    }
+}
+
+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() {
+        let buffer = terminal.backend().buffer();
+        let area = buffer.area;
+        let mut result = String::new();
+        for y in 0..area.height {
+            for x in 0..area.width {
+                let cell = buffer.cell((x, y)).unwrap();
+                result.push_str(cell.symbol());
+            }
+            result.push('\n');
+        }
+        Ok(result)
+    } else {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        Err(Error::new(
+            error_class,
+            "Terminal is not initialized as TestBackend",
+        ))
+    }
+}
+
+pub fn insert_before(height: u16, _widget: magnus::Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let mut term_lock = TERMINAL.lock().unwrap();
+    
+    if let Some(wrapper) = term_lock.as_mut() {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        
+        match wrapper {
+            TerminalWrapper::Crossterm(term) => {
+                term.insert_before(height, |_buf| {})
+                    .map_err(|e| Error::new(error_class, e.to_string()))?;
+            }
+            TerminalWrapper::Test(term) => {
+                term.insert_before(height, |_buf| {})
+                    .map_err(|e| Error::new(error_class, e.to_string()))?;
+            }
+        }
+        Ok(())
+    } else {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        Err(Error::new(error_class, "Terminal not initialized"))
+    }
+}
+
+pub fn get_terminal_area() -> Result<magnus::RHash, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if let Some(wrapper) = term_lock.as_mut() {
+        let hash = ruby.hash_new();
+        match wrapper {
+            TerminalWrapper::Crossterm(term) => {
+                // Call draw to capture the viewport area
+                // draw() closure must return (), so we capture area in a mutable variable
+                let mut captured_area = ratatui::layout::Rect::default();
+                term.draw(|f| {
+                    captured_area = f.area();
+                }).map_err(|e| {
+                    let module = ruby.define_module("RatatuiRuby").unwrap();
+                    let error_base = module.const_get::<_, magnus::RClass>("Error").unwrap();
+                    let error_class = error_base.const_get("Terminal").unwrap();
+                    Error::new(error_class, e.to_string())
+                })?;
+                hash.aset("x", captured_area.x)?;
+                hash.aset("y", captured_area.y)?;
+                hash.aset("width", captured_area.width)?;
+                hash.aset("height", captured_area.height)?;
+            }
+            TerminalWrapper::Test(term) => {
+                // Same for TestBackend
+                let mut captured_area = ratatui::layout::Rect::default();
+                term.draw(|f| {
+                    captured_area = f.area();
+                }).map_err(|e| {
+                    let module = ruby.define_module("RatatuiRuby").unwrap();
+                    let error_base = module.const_get::<_, magnus::RClass>("Error").unwrap();
+                    let error_class = error_base.const_get("Terminal").unwrap();
+                    Error::new(error_class, e.to_string())
+                })?;
+                hash.aset("x", captured_area.x)?;
+                hash.aset("y", captured_area.y)?;
+                hash.aset("width", captured_area.width)?;
+                hash.aset("height", captured_area.height)?;
+            }
+        }
+        Ok(hash)
+    } else {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        Err(Error::new(error_class, "Terminal is not initialized"))
+    }
+}
+
+pub fn get_viewport_type() -> Result<String, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let mut term_lock = TERMINAL.lock().unwrap();
+    
+    if let Some(wrapper) = term_lock.as_mut() {
+        match wrapper {
+            TerminalWrapper::Crossterm(term) => {
+                let vp_area = term.draw(|f| f.area()).map_err(|e| {
+                    let module = ruby.define_module("RatatuiRuby").unwrap();
+                    let error_base = module.const_get::<_, magnus::RClass>("Error").unwrap();
+                    let error_class = error_base.const_get("Terminal").unwrap();
+                    Error::new(error_class, e.to_string())
+                })?;
+                let backend_size = term.size().unwrap_or_default();
+                
+                if vp_area.height < backend_size.height {
+                    Ok("inline".to_string())
+                } else {
+                    Ok("fullscreen".to_string())
+                }
+            }
+            TerminalWrapper::Test(term) => {
+                let vp_area = term.draw(|f| f.area()).map_err(|e| {
+                    let module = ruby.define_module("RatatuiRuby").unwrap();
+                    let error_base = module.const_get::<_, magnus::RClass>("Error").unwrap();
+                    let error_class = error_base.const_get("Terminal").unwrap();
+                    Error::new(error_class, e.to_string())
+                })?;
+                let backend_size = term.size().unwrap_or_default();
+                
+                if vp_area.height < backend_size.height {
+                    Ok("inline".to_string())
+                } else {
+                    Ok("fullscreen".to_string())
+                }
+            }
+        }
+    } else {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        Err(Error::new(error_class, "Terminal not initialized"))
+    }
+}
+
+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 module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        let pos = terminal
+            .get_cursor_position()
+            .map_err(|e| Error::new(error_class, e.to_string()))?;
+        Ok(Some(pos.into()))
+    } else {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        Err(Error::new(
+            error_class,
+            "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 {
+            TerminalWrapper::Crossterm(_) => {}
+            TerminalWrapper::Test(terminal) => {
+                terminal.backend_mut().resize(width, height);
+                if let Err(e) = terminal.resize(ratatui::layout::Rect::new(0, 0, width, height)) {
+                    let module = ruby.define_module("RatatuiRuby")?;
+                    let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+                    let error_class = error_base.const_get("Terminal")?;
+                    return Err(Error::new(error_class, e.to_string()));
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+use magnus::Value;
+
+pub fn get_cell_at(x: u16, y: u16) -> Result<magnus::RHash, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let term_lock = TERMINAL.lock().unwrap();
+    if let Some(TerminalWrapper::Test(terminal)) = term_lock.as_ref() {
+        let buffer = terminal.backend().buffer();
+        if let Some(cell) = buffer.cell((x, y)) {
+            let hash = ruby.hash_new();
+            hash.aset("char", cell.symbol())?;
+            hash.aset("fg", color_to_value(cell.fg))?;
+            hash.aset("bg", color_to_value(cell.bg))?;
+            hash.aset("underline_color", color_to_value(cell.underline_color))?;
+            hash.aset("modifiers", modifiers_to_value(cell.modifier))?;
+            Ok(hash)
+        } else {
+            let module = ruby.define_module("RatatuiRuby")?;
+            let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+            let error_class = error_base.const_get("Terminal")?;
+            Err(Error::new(
+                error_class,
+                format!("Coordinates ({x}, {y}) out of bounds"),
+            ))
+        }
+    } else {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Terminal")?;
+        Err(Error::new(
+            error_class,
+            "Terminal is not initialized as TestBackend",
+        ))
+    }
+}
+
+fn color_to_value(color: ratatui::style::Color) -> Value {
+    let ruby = magnus::Ruby::get().unwrap();
+    match color {
+        ratatui::style::Color::Reset => ruby.qnil().as_value(),
+        ratatui::style::Color::Black => ruby.to_symbol("black").as_value(),
+        ratatui::style::Color::Red => ruby.to_symbol("red").as_value(),
+        ratatui::style::Color::Green => ruby.to_symbol("green").as_value(),
+        ratatui::style::Color::Yellow => ruby.to_symbol("yellow").as_value(),
+        ratatui::style::Color::Blue => ruby.to_symbol("blue").as_value(),
+        ratatui::style::Color::Magenta => ruby.to_symbol("magenta").as_value(),
+        ratatui::style::Color::Cyan => ruby.to_symbol("cyan").as_value(),
+        ratatui::style::Color::Gray => ruby.to_symbol("gray").as_value(),
+        ratatui::style::Color::DarkGray => ruby.to_symbol("dark_gray").as_value(),
+        ratatui::style::Color::LightRed => ruby.to_symbol("light_red").as_value(),
+        ratatui::style::Color::LightGreen => ruby.to_symbol("light_green").as_value(),
+        ratatui::style::Color::LightYellow => ruby.to_symbol("light_yellow").as_value(),
+        ratatui::style::Color::LightBlue => ruby.to_symbol("light_blue").as_value(),
+        ratatui::style::Color::LightMagenta => ruby.to_symbol("light_magenta").as_value(),
+        ratatui::style::Color::LightCyan => ruby.to_symbol("light_cyan").as_value(),
+        ratatui::style::Color::White => ruby.to_symbol("white").as_value(),
+        ratatui::style::Color::Rgb(r, g, b) => ruby
+            .str_new(&(format!("#{r:02x}{g:02x}{b:02x}")))
+            .as_value(),
+        ratatui::style::Color::Indexed(i) => ruby.to_symbol(format!("indexed_{i}")).as_value(),
+    }
+}
+
+fn modifiers_to_value(modifier: ratatui::style::Modifier) -> Value {
+    let ruby = magnus::Ruby::get().unwrap();
+    let ary = ruby.ary_new();
+
+    if modifier.contains(ratatui::style::Modifier::BOLD) {
+        let _ = ary.push(ruby.to_symbol("bold"));
+    }
+    if modifier.contains(ratatui::style::Modifier::ITALIC) {
+        let _ = ary.push(ruby.to_symbol("italic"));
+    }
+    if modifier.contains(ratatui::style::Modifier::DIM) {
+        let _ = ary.push(ruby.to_symbol("dim"));
+    }
+    if modifier.contains(ratatui::style::Modifier::UNDERLINED) {
+        let _ = ary.push(ruby.to_symbol("underlined"));
+    }
+    if modifier.contains(ratatui::style::Modifier::REVERSED) {
+        let _ = ary.push(ruby.to_symbol("reversed"));
+    }
+    if modifier.contains(ratatui::style::Modifier::HIDDEN) {
+        let _ = ary.push(ruby.to_symbol("hidden"));
+    }
+    if modifier.contains(ratatui::style::Modifier::CROSSED_OUT) {
+        let _ = ary.push(ruby.to_symbol("crossed_out"));
+    }
+    if modifier.contains(ratatui::style::Modifier::SLOW_BLINK) {
+        let _ = ary.push(ruby.to_symbol("slow_blink"));
+    }
+    if modifier.contains(ratatui::style::Modifier::RAPID_BLINK) {
+        let _ = ary.push(ruby.to_symbol("rapid_blink"));
+    }
+
+    ary.as_value()
+}

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

@@ -5,15 +5,16 @@ use crate::style::{parse_bar_set, parse_block, parse_style};
 use crate::text::{parse_line, parse_span};
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, RArray, Symbol, Value};
+use ratatui::buffer::Buffer;
 use ratatui::{
     layout::{Direction, Rect},
     text::Line,
+    widgets::Widget,
     widgets::{Bar, BarChart, BarGroup},
-    Frame,
 };
 
 #[allow(clippy::too_many_lines)]
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let data_val: Value = node.funcall("data", ())?;
     let bar_width: u16 = node.funcall("bar_width", ())?;
@@ -144,7 +145,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         bar_chart = bar_chart.bar_set(parse_bar_set(bar_set_val, &bump)?);
     }
 
-    frame.render_widget(bar_chart, area);
+    bar_chart.render(area, buffer);
     Ok(())
 }
 

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

@@ -5,15 +5,15 @@ use crate::rendering::render_node;
 use crate::style::parse_block;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
-use ratatui::{layout::Rect, widgets::Widget, Frame};
+use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
 
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let block = parse_block(node, &bump)?;
     let block_clone = block.clone();
 
     // Render the block itself (borders, styling)
-    block_clone.render(area, frame.buffer_mut());
+    block_clone.render(area, buffer);
 
     // Get children and render them within the block's inner area
     let children_val: Value = node.funcall("children", ())?;
@@ -30,7 +30,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
                 let index = isize::try_from(i)
                     .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
                 let child: Value = arr.entry(index)?;
-                if let Err(e) = render_node(frame, inner, child) {
+                if let Err(e) = render_node(buffer, inner, child) {
                     eprintln!("Error rendering block child {i}: {e:?}");
                 }
             }

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

@@ -5,14 +5,15 @@ use crate::style::{parse_block, parse_style};
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{
+    buffer::Buffer,
     layout::Rect,
     widgets::calendar::{CalendarEventStore, Monthly},
-    Frame,
+    widgets::Widget,
 };
 use std::convert::TryFrom;
 use time::{Date, Month};
 
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let ruby = magnus::Ruby::get().unwrap();
     let year: i32 = node.funcall("year", ())?;
@@ -78,6 +79,6 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         calendar = calendar.block(parse_block(block_val, &bump)?);
     }
 
-    frame.render_widget(calendar, area);
+    calendar.render(area, buffer);
     Ok(())
 }

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

@@ -5,14 +5,17 @@ use crate::style::{parse_block, parse_color, parse_style};
 use crate::text::parse_text;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, RArray, Symbol, Value};
+use ratatui::buffer::Buffer;
 use ratatui::{
     symbols::Marker,
-    widgets::canvas::{Canvas, Circle, Line, Map, MapResolution, Rectangle},
-    Frame,
+    widgets::{
+        canvas::{Canvas, Circle, Line, Map, MapResolution, Rectangle},
+        Widget,
+    },
 };
 
 #[allow(clippy::too_many_lines)]
-pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Result<(), Error> {
+pub fn render(buffer: &mut Buffer, area: ratatui::layout::Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let shapes_val: RArray = node.funcall("shapes", ())?;
     let x_bounds_val: RArray = node.funcall("x_bounds", ())?;
@@ -139,7 +142,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
         }
     });
 
-    frame.render_widget(canvas, area);
+    Widget::render(canvas, area, buffer);
     Ok(())
 }
 

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

@@ -4,11 +4,11 @@
 use crate::rendering::render_node;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{
+    buffer::Buffer,
     layout::{Constraint, Direction, Layout, Rect},
-    Frame,
 };
 
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
     let child: Value = node.funcall("child", ())?;
     let width_percent: u16 = node.funcall("width_percent", ())?;
     let height_percent: u16 = node.funcall("height_percent", ())?;
@@ -35,7 +35,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     let center_area = popup_layout_horizontal[1];
 
-    render_node(frame, center_area, child)?;
+    render_node(buffer, center_area, child)?;
     Ok(())
 }
 

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

@@ -6,15 +6,15 @@ use crate::style::{parse_block, parse_style};
 use crate::text::parse_line;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::buffer::Buffer;
 use ratatui::{
     layout::Rect,
     symbols,
-    widgets::{Axis, Chart, Dataset, GraphType, LegendPosition},
-    Frame,
+    widgets::{Axis, Chart, Dataset, GraphType, LegendPosition, Widget},
 };
 
 #[allow(clippy::too_many_lines)]
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let ruby = magnus::Ruby::get().unwrap();
 
@@ -133,7 +133,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         }
     }
 
-    frame.render_widget(chart, area);
+    Widget::render(chart, area, buffer);
     Ok(())
 }
 

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

@@ -3,17 +3,17 @@
 
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
-use ratatui::{layout::Rect, widgets::Widget, Frame};
+use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
 
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
-    frame.render_widget(ratatui::widgets::Clear, area);
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    ratatui::widgets::Clear.render(area, buffer);
 
     // If a block is provided, render it on top of the cleared area
     if let Ok(block_val) = node.funcall::<_, _, Value>("block", ()) {
         if !block_val.is_nil() {
             let bump = Bump::new();
             let block = crate::style::parse_block(block_val, &bump)?;
-            block.render(area, frame.buffer_mut());
+            block.render(area, buffer);
         }
     }
 
@@ -22,7 +22,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
 #[cfg(test)]
 mod tests {
-    use ratatui::{backend::TestBackend, layout::Rect, Terminal};
+    use ratatui::{backend::TestBackend, layout::Rect, widgets::Widget, Terminal};
 
     #[test]
     fn test_clear_renders_without_error() {
@@ -32,7 +32,7 @@ mod tests {
         terminal
             .draw(|frame| {
                 let area = Rect::new(0, 0, 10, 5);
-                frame.render_widget(ratatui::widgets::Clear, area);
+                ratatui::widgets::Clear.render(area, frame.buffer_mut());
             })
             .unwrap();
     }

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

@@ -1,19 +1,22 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use magnus::{prelude::*, Error, Value};
-use ratatui::{layout::Rect, Frame};
+use magnus::{Error, Value};
+use ratatui::{buffer::Buffer, layout::Rect};
 
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
-    let x: u16 = node.funcall("x", ())?;
-    let y: u16 = node.funcall("y", ())?;
-    frame.set_cursor_position((area.x + x, area.y + y));
+/// Cursor widget requires Frame for `set_cursor_position` - cannot be rendered to buffer alone
+/// This is a no-op when rendering to buffer directly (e.g., in `insert_before`)
+/// For Frame-based rendering, use `frame.set_cursor_position()` directly
+#[allow(dead_code, clippy::unnecessary_wraps)]
+pub fn render(_buffer: &mut Buffer, _area: Rect, _node: Value) -> Result<(), Error> {
+    // Cursor positioning requires Frame.set_cursor_position(), not Buffer
+    // This is intentionally a no-op for buffer-only rendering
+    // The Frame wrapper in frame.rs should handle Cursor widgets specially
     Ok(())
 }
 
 #[cfg(test)]
 mod tests {
-
     use ratatui::layout::Rect;
 
     #[test]

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

@@ -5,9 +5,10 @@ use crate::style::{parse_block, parse_style};
 use crate::text::parse_span;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
-use ratatui::{layout::Rect, widgets::Gauge, Frame};
+use ratatui::buffer::Buffer;
+use ratatui::{layout::Rect, widgets::Gauge, widgets::Widget};
 
-pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let ratio: f64 = node.funcall("ratio", ())?;
     let label_val: Value = node.funcall("label", ())?;
@@ -40,7 +41,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         gauge = gauge.block(parse_block(block_val, &bump)?);
     }
 
-    frame.render_widget(gauge, area);
+    gauge.render(area, buffer);
     Ok(())
 }