ratatui_ruby 0.1.0 → 0.3.0

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

@@ -0,0 +1,82 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_style};
+use magnus::{prelude::*, Error, Value};
+use ratatui::{
+    layout::Rect,
+    widgets::calendar::{CalendarEventStore, Monthly},
+    Frame,
+};
+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", ())?;
+    let header_style_val: Value = node.funcall("header_style", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let month = Month::try_from(month_u8)
+        .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(ruby.exception_arg_error(), e.to_string()))?;
+
+    let mut calendar = Monthly::new(date, CalendarEventStore::default());
+
+    let header_style = if !header_style_val.is_nil() {
+        parse_style(header_style_val)?
+    } else {
+        ratatui::style::Style::default()
+    };
+    calendar = calendar
+        .show_month_header(header_style)
+        .show_weekdays_header(header_style);
+
+    if !day_style_val.is_nil() {
+        calendar = calendar.default_style(parse_style(day_style_val)?);
+    }
+
+    if !block_val.is_nil() {
+        calendar = calendar.block(parse_block(block_val)?);
+    }
+
+    frame.render_widget(calendar, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::Widget;
+
+    #[test]
+    fn test_calendar_rendering() {
+        let date = Date::from_calendar_date(2025, Month::December, 1).unwrap();
+        let calendar = Monthly::new(date, CalendarEventStore::default())
+            .show_month_header(ratatui::style::Style::default());
+        let mut buf = Buffer::empty(Rect::new(0, 0, 40, 20));
+        calendar.render(Rect::new(0, 0, 40, 20), &mut buf);
+        let mut content = String::new();
+        for y in 0..20 {
+            for x in 0..40 {
+                content.push_str(buf.cell((x, y)).unwrap().symbol());
+            }
+            content.push('\n');
+        }
+        assert!(
+            content.contains("December"),
+            "Content did not contain December: \n{}",
+            content
+        );
+        assert!(
+            content.contains("2025"),
+            "Content did not contain 2025: \n{}",
+            content
+        );
+    }
+}

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() };
 

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

@@ -5,7 +5,6 @@ use crate::rendering::render_node;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{
     layout::{Constraint, Direction, Layout, Rect},
-    widgets::Clear,
     Frame,
 };
 
@@ -36,7 +35,6 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     let center_area = popup_layout_horizontal[1];
 
-    frame.render_widget(Clear, center_area);
     render_node(frame, center_area, child)?;
     Ok(())
 }

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

@@ -0,0 +1,260 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_style};
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::{
+    layout::Rect,
+    symbols,
+    text::Span,
+    widgets::{Axis, Chart, Dataset, GraphType},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let class = node.class();
+    let class_name = unsafe { class.name() };
+
+    if class_name == "RatatuiRuby::LineChart" {
+        return render_line_chart(frame, area, node);
+    }
+
+    let datasets_val: magnus::RArray = node.funcall("datasets", ())?;
+    let x_axis_val: Value = node.funcall("x_axis", ())?;
+    let y_axis_val: Value = node.funcall("y_axis", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+
+    let mut datasets = Vec::new();
+    // We need to keep the data alive until the chart is rendered
+    let mut data_storage: Vec<Vec<(f64, f64)>> = Vec::new();
+
+    for i in 0..datasets_val.len() {
+        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let data_array: magnus::RArray = ds_val.funcall("data", ())?;
+
+        let mut points = Vec::new();
+        for j in 0..data_array.len() {
+            let point_array_val: Value = data_array.entry(j as isize)?;
+            let point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
+                Error::new(ruby.exception_type_error(), "expected array for point")
+            })?;
+            let x: f64 = point_array.entry(0)?;
+            let y: f64 = point_array.entry(1)?;
+            points.push((x, y));
+        }
+        data_storage.push(points);
+    }
+
+    for (i, points) in data_storage.iter().enumerate() {
+        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let name: String = ds_val.funcall("name", ())?;
+        let marker_sym: Symbol = ds_val.funcall("marker", ())?;
+        let graph_type_sym: Symbol = ds_val.funcall("graph_type", ())?;
+
+        let marker = match marker_sym.to_string().as_str() {
+            "dot" => symbols::Marker::Dot,
+            "braille" => symbols::Marker::Braille,
+            "block" => symbols::Marker::Block,
+            "bar" => symbols::Marker::Bar,
+            _ => symbols::Marker::Dot,
+        };
+
+        let graph_type = match graph_type_sym.to_string().as_str() {
+            "line" => GraphType::Line,
+            "scatter" => GraphType::Scatter,
+            _ => GraphType::Line,
+        };
+
+        let mut ds_style = ratatui::style::Style::default();
+        let color_val: Value = ds_val.funcall("color", ())?;
+        if !color_val.is_nil() {
+            let color_str: String = color_val.funcall("to_s", ())?;
+            if let Some(color) = crate::style::parse_color(&color_str) {
+                ds_style = ds_style.fg(color);
+            }
+        }
+
+        let ds = Dataset::default()
+            .name(name)
+            .marker(marker)
+            .graph_type(graph_type)
+            .style(ds_style)
+            .data(points);
+        datasets.push(ds);
+    }
+
+    let x_axis = parse_axis(x_axis_val)?;
+    let y_axis = parse_axis(y_axis_val)?;
+
+    let mut chart = Chart::new(datasets).x_axis(x_axis).y_axis(y_axis);
+
+    if !block_val.is_nil() {
+        chart = chart.block(parse_block(block_val)?);
+    }
+
+    if !style_val.is_nil() {
+        chart = chart.style(parse_style(style_val)?);
+    }
+
+    frame.render_widget(chart, area);
+    Ok(())
+}
+
+fn parse_axis(axis_val: Value) -> Result<Axis<'static>, Error> {
+    let title: String = axis_val.funcall("title", ())?;
+    let bounds_val: magnus::RArray = axis_val.funcall("bounds", ())?;
+    let labels_val: magnus::RArray = axis_val.funcall("labels", ())?;
+    let style_val: Value = axis_val.funcall("style", ())?;
+
+    let bounds: [f64; 2] = [bounds_val.entry(0)?, bounds_val.entry(1)?];
+
+    let mut labels = Vec::new();
+    for i in 0..labels_val.len() {
+        let label: String = labels_val.entry(i as isize)?;
+        labels.push(Span::from(label));
+    }
+
+    let mut axis = Axis::default().title(title).bounds(bounds).labels(labels);
+
+    if !style_val.is_nil() {
+        axis = axis.style(parse_style(style_val)?);
+    }
+
+    Ok(axis)
+}
+
+fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let datasets_val: magnus::RArray = node.funcall("datasets", ())?;
+    let x_labels_val: magnus::RArray = node.funcall("x_labels", ())?;
+    let y_labels_val: magnus::RArray = node.funcall("y_labels", ())?;
+    let y_bounds_val: magnus::RArray = node.funcall("y_bounds", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut datasets = Vec::new();
+    let mut data_storage: Vec<Vec<(f64, f64)>> = Vec::new();
+
+    for i in 0..datasets_val.len() {
+        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let data_array: magnus::RArray = ds_val.funcall("data", ())?;
+
+        let mut points = Vec::new();
+        for j in 0..data_array.len() {
+            let point_array_val: Value = data_array.entry(j as isize)?;
+            let point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
+                Error::new(ruby.exception_type_error(), "expected array for point")
+            })?;
+            let x: f64 = point_array.entry(0)?;
+            let y: f64 = point_array.entry(1)?;
+            points.push((x, y));
+        }
+        data_storage.push(points);
+    }
+
+    for (i, points) in data_storage.iter().enumerate() {
+        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let name: String = ds_val.funcall("name", ())?;
+
+        let mut ds_style = ratatui::style::Style::default();
+        let color_val: Value = ds_val.funcall("color", ())?;
+        let color_str: String = color_val.funcall("to_s", ())?;
+        if let Some(color) = crate::style::parse_color(&color_str) {
+            ds_style = ds_style.fg(color);
+        }
+
+        let ds = Dataset::default()
+            .name(name)
+            .marker(symbols::Marker::Braille)
+            .style(ds_style)
+            .data(points);
+        datasets.push(ds);
+    }
+
+    let mut x_labels = Vec::new();
+    for i in 0..x_labels_val.len() {
+        let label: String = x_labels_val.entry(i as isize)?;
+        x_labels.push(Span::from(label));
+    }
+
+    let mut y_labels = Vec::new();
+    for i in 0..y_labels_val.len() {
+        let label: String = y_labels_val.entry(i as isize)?;
+        y_labels.push(Span::from(label));
+    }
+    // Ratatui 0.29+ requires labels to be present for the axis line to render
+    if y_labels.is_empty() {
+        y_labels.push(Span::from(""));
+        y_labels.push(Span::from(""));
+    }
+
+    let y_bounds: [f64; 2] = [y_bounds_val.entry(0)?, y_bounds_val.entry(1)?];
+
+    let mut min_x = 0.0;
+    let mut max_x = 0.0;
+    let mut first = true;
+    for ds_data in &data_storage {
+        for (x, _) in ds_data {
+            if first {
+                min_x = *x;
+                max_x = *x;
+                first = false;
+            } else {
+                if *x < min_x {
+                    min_x = *x;
+                }
+                if *x > max_x {
+                    max_x = *x;
+                }
+            }
+        }
+    }
+    if min_x == max_x {
+        max_x = min_x + 1.0;
+    }
+
+    let x_axis = Axis::default().labels(x_labels).bounds([min_x, max_x]);
+    let y_axis = Axis::default().labels(y_labels).bounds(y_bounds);
+
+    let mut chart = Chart::new(datasets).x_axis(x_axis).y_axis(y_axis);
+    if !block_val.is_nil() {
+        chart = chart.block(parse_block(block_val)?);
+    }
+
+    frame.render_widget(chart, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::Widget;
+
+    #[test]
+    fn test_chart_rendering() {
+        let data = vec![(0.0, 0.0), (1.0, 1.0)];
+        let datasets = vec![Dataset::default().name("TestDS").data(&data)];
+        let chart = Chart::new(datasets)
+            .x_axis(
+                Axis::default()
+                    .bounds([0.0, 1.0])
+                    .labels(vec!["XMIN".into(), "XMAX".into()] as Vec<ratatui::text::Line>),
+            )
+            .y_axis(
+                Axis::default()
+                    .bounds([0.0, 1.0])
+                    .labels(vec!["YMIN".into(), "YMAX".into()] as Vec<ratatui::text::Line>),
+            );
+        let mut buf = Buffer::empty(Rect::new(0, 0, 40, 20));
+        chart.render(Rect::new(0, 0, 40, 20), &mut buf);
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+        let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
+        assert!(content.contains("XMIN"));
+        assert!(content.contains("XMAX"));
+        assert!(content.contains("YMIN"));
+        assert!(content.contains("YMAX"));
+        assert!(content.contains("TestDS"));
+    }
+}

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

@@ -0,0 +1,37 @@
+// 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, widgets::Widget, Frame};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    frame.render_widget(ratatui::widgets::Clear, area);
+
+    // 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 block = crate::style::parse_block(block_val)?;
+            block.render(area, frame.buffer_mut());
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use ratatui::{backend::TestBackend, layout::Rect, Terminal};
+
+    #[test]
+    fn test_clear_renders_without_error() {
+        let backend = TestBackend::new(10, 5);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|frame| {
+                let area = Rect::new(0, 0, 10, 5);
+                frame.render_widget(ratatui::widgets::Clear, area);
+            })
+            .unwrap();
+    }
+}

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

@@ -7,7 +7,7 @@ use ratatui::{layout::Rect, Frame};
 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(area.x + x, area.y + y);
+    frame.set_cursor_position((area.x + x, area.y + y));
     Ok(())
 }
 

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

@@ -9,10 +9,11 @@ use ratatui::{
 };
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let direction_sym: Symbol = node.funcall("direction", ())?;
     let children_val: Value = node.funcall("children", ())?;
     let children_array = magnus::RArray::from_value(children_val)
-        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array"))?;
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array"))?;
 
     let constraints_val: Value = node.funcall("constraints", ())?;
     let constraints_array = magnus::RArray::from_value(constraints_val);

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

@@ -1,8 +1,8 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use crate::style::parse_block;
-use magnus::{prelude::*, Error, Value};
+use crate::style::{parse_block, parse_style};
+use magnus::{prelude::*, Error, TryConvert, Value};
 use ratatui::{
     layout::Rect,
     widgets::{List, ListState},
@@ -10,10 +10,14 @@ use ratatui::{
 };
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let items_val: Value = node.funcall("items", ())?;
     let items_array = magnus::RArray::from_value(items_val)
-        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array"))?;
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array"))?;
     let selected_index_val: Value = node.funcall("selected_index", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let highlight_style_val: Value = node.funcall("highlight_style", ())?;
+    let highlight_symbol_val: Value = node.funcall("highlight_symbol", ())?;
     let block_val: Value = node.funcall("block", ())?;
 
     let mut items = Vec::new();
@@ -22,13 +26,32 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         items.push(item);
     }
 
+    let symbol: String = if !highlight_symbol_val.is_nil() {
+        let s: String = String::try_convert(highlight_symbol_val)?;
+        s
+    } else {
+        String::new()
+    };
+
     let mut state = ListState::default();
     if !selected_index_val.is_nil() {
         let index: usize = selected_index_val.funcall("to_int", ())?;
         state.select(Some(index));
     }
 
-    let mut list = List::new(items).highlight_symbol(">> ");
+    let mut list = List::new(items);
+
+    if !highlight_symbol_val.is_nil() {
+        list = list.highlight_symbol(&symbol);
+    }
+
+    if !style_val.is_nil() {
+        list = list.style(parse_style(style_val)?);
+    }
+
+    if !highlight_style_val.is_nil() {
+        list = list.highlight_style(parse_style(highlight_style_val)?);
+    }
 
     if !block_val.is_nil() {
         list = list.block(parse_block(block_val)?);
@@ -47,7 +70,14 @@ mod tests {
     #[test]
     fn test_list_rendering() {
         let items = vec!["Item 1", "Item 2"];
-        let list = List::new(items).highlight_symbol(">> ");
+        let list = List::new(items)
+            .highlight_symbol(">> ")
+            .style(ratatui::style::Style::default().fg(ratatui::style::Color::White))
+            .highlight_style(
+                ratatui::style::Style::default()
+                    .fg(ratatui::style::Color::Yellow)
+                    .add_modifier(ratatui::style::Modifier::BOLD),
+            );
         let mut state = ListState::default();
         state.select(Some(1));
 
@@ -58,5 +88,14 @@ mod tests {
         let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
         assert!(content.contains("Item 1"));
         assert!(content.contains(">> Item 2"));
+
+        // Check colors
+        assert_eq!(buf.cell((0, 0)).unwrap().fg, ratatui::style::Color::White);
+        assert_eq!(buf.cell((0, 1)).unwrap().fg, ratatui::style::Color::Yellow);
+        assert!(buf
+            .cell((0, 1))
+            .unwrap()
+            .modifier
+            .contains(ratatui::style::Modifier::BOLD));
     }
 }

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

@@ -3,12 +3,14 @@
 
 pub mod barchart;
 pub mod block;
+pub mod calendar;
 pub mod canvas;
 pub mod center;
+pub mod chart;
+pub mod clear;
 pub mod cursor;
 pub mod gauge;
 pub mod layout;
-pub mod linechart;
 pub mod list;
 pub mod overlay;
 pub mod paragraph;

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

@@ -6,9 +6,10 @@ use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, Frame};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let layers_val: Value = node.funcall("layers", ())?;
     let layers_array = magnus::RArray::from_value(layers_val)
-        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for layers"))?;
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for layers"))?;
 
     for i in 0..layers_array.len() {
         let layer: Value = layers_array.entry(i as isize)?;

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

@@ -15,6 +15,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let block_val: Value = node.funcall("block", ())?;
     let wrap: bool = node.funcall("wrap", ())?;
     let align_sym: Symbol = node.funcall("align", ())?;
+    let scroll_val: Value = node.funcall("scroll", ())?;
 
     let style = parse_style(style_val)?;
     let mut paragraph = Paragraph::new(text).style(style);
@@ -33,6 +34,15 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         _ => {}
     }
 
+    // Apply scroll offset if provided
+    // Ruby passes (y, x) array matching ratatui's convention
+    if !scroll_val.is_nil() {
+        let scroll_array: Vec<u16> = Vec::<u16>::try_convert(scroll_val)?;
+        if scroll_array.len() >= 2 {
+            paragraph = paragraph.scroll((scroll_array[0], scroll_array[1]));
+        }
+    }
+
     frame.render_widget(paragraph, area);
     Ok(())
 }

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

@@ -5,25 +5,29 @@ use crate::style::{parse_block, parse_style};
 use magnus::{prelude::*, Error, Symbol, Value};
 use ratatui::{
     layout::{Constraint, Rect},
-    widgets::{Cell, Row, Table},
+    widgets::{Cell, Row, Table, TableState},
     Frame,
 };
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let header_val: Value = node.funcall("header", ())?;
     let rows_val: Value = node.funcall("rows", ())?;
     let rows_array = magnus::RArray::from_value(rows_val)
-        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for rows"))?;
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for rows"))?;
     let widths_val: Value = node.funcall("widths", ())?;
     let widths_array = magnus::RArray::from_value(widths_val)
-        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for widths"))?;
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for widths"))?;
+    let highlight_style_val: Value = node.funcall("highlight_style", ())?;
+    let highlight_symbol_val: Value = node.funcall("highlight_symbol", ())?;
+    let selected_row_val: Value = node.funcall("selected_row", ())?;
     let block_val: Value = node.funcall("block", ())?;
 
     let mut rows = Vec::new();
     for i in 0..rows_array.len() {
         let row_val: Value = rows_array.entry(i as isize)?;
         let row_array = magnus::RArray::from_value(row_val)
-            .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for row"))?;
+            .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for row"))?;
 
         let mut cells = Vec::new();
         for j in 0..row_array.len() {
@@ -64,7 +68,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     if !header_val.is_nil() {
         let header_array = magnus::RArray::from_value(header_val).ok_or_else(|| {
-            Error::new(magnus::exception::type_error(), "expected array for header")
+            Error::new(ruby.exception_type_error(), "expected array for header")
         })?;
         let mut header_cells = Vec::new();
         for i in 0..header_array.len() {
@@ -89,7 +93,22 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         table = table.block(parse_block(block_val)?);
     }
 
-    frame.render_widget(table, area);
+    if !highlight_style_val.is_nil() {
+        table = table.row_highlight_style(parse_style(highlight_style_val)?);
+    }
+
+    if !highlight_symbol_val.is_nil() {
+        let symbol: String = highlight_symbol_val.funcall("to_s", ())?;
+        table = table.highlight_symbol(symbol);
+    }
+
+    let mut state = TableState::default();
+    if !selected_row_val.is_nil() {
+        let index: usize = selected_row_val.funcall("to_int", ())?;
+        state.select(Some(index));
+    }
+
+    frame.render_stateful_widget(table, area, &mut state);
     Ok(())
 }
 

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

@@ -6,12 +6,13 @@ use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, text::Line, widgets::Tabs, Frame};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     let titles_val: Value = node.funcall("titles", ())?;
     let selected_index: usize = node.funcall("selected_index", ())?;
     let block_val: Value = node.funcall("block", ())?;
 
     let titles_array = magnus::RArray::from_value(titles_val)
-        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for titles"))?;
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for titles"))?;
 
     let mut titles = Vec::new();
     for i in 0..titles_array.len() {