ratatui_ruby 1.4.0-x86_64-linux

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

@@ -0,0 +1,415 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::errors::type_error_with_context;
+use crate::style::{parse_block, parse_style};
+use crate::text::{parse_line, parse_span, parse_text};
+use crate::widgets::table_state::RubyTableState;
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, Symbol, TryConvert, Value};
+use ratatui::{
+    buffer::Buffer,
+    layout::{Constraint, Flex, Rect},
+    widgets::{Cell, HighlightSpacing, Row, StatefulWidget, Table, TableState},
+};
+
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
+    let ruby = magnus::Ruby::get().unwrap();
+    let header_val: Value = node.funcall("header", ())?;
+    let footer_val: Value = node.funcall("footer", ())?;
+    let rows_value: Value = node.funcall("rows", ())?;
+    let rows_array = magnus::RArray::from_value(rows_value)
+        .ok_or_else(|| type_error_with_context(&ruby, "expected array for rows", rows_value))?;
+    let widths_val: Value = node.funcall("widths", ())?;
+    let widths_array = magnus::RArray::from_value(widths_val)
+        .ok_or_else(|| type_error_with_context(&ruby, "expected array for widths", widths_val))?;
+    let row_highlight_style_val: Value = node.funcall("row_highlight_style", ())?;
+    let column_highlight_style_val: Value = node.funcall("column_highlight_style", ())?;
+    let cell_highlight_style_val: Value = node.funcall("cell_highlight_style", ())?;
+    let highlight_symbol_val: Value = node.funcall("highlight_symbol", ())?;
+    let selected_row_val: Value = node.funcall("selected_row", ())?;
+    let selected_column_val: Value = node.funcall("selected_column", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+    let flex_sym: Symbol = node.funcall("flex", ())?;
+    let highlight_spacing_sym: Symbol = node.funcall("highlight_spacing", ())?;
+
+    let mut rows = Vec::new();
+    for i in 0..rows_array.len() {
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let row_val: Value = rows_array.entry(index)?;
+        rows.push(parse_row(row_val)?);
+    }
+
+    let constraints = parse_constraints(widths_array)?;
+
+    let flex = match flex_sym.to_string().as_str() {
+        "start" => Flex::Start,
+        "center" => Flex::Center,
+        "end" => Flex::End,
+        "space_between" => Flex::SpaceBetween,
+        "space_around" => Flex::SpaceAround,
+        "space_evenly" => Flex::SpaceEvenly,
+        _ => Flex::Legacy,
+    };
+
+    let mut table = Table::new(rows, constraints).flex(flex);
+
+    let highlight_spacing = match highlight_spacing_sym.to_string().as_str() {
+        "always" => HighlightSpacing::Always,
+        "never" => HighlightSpacing::Never,
+        _ => HighlightSpacing::WhenSelected,
+    };
+    table = table.highlight_spacing(highlight_spacing);
+
+    if !header_val.is_nil() {
+        table = table.header(parse_row(header_val)?);
+    }
+
+    if !footer_val.is_nil() {
+        table = table.footer(parse_row(footer_val)?);
+    }
+
+    if !block_val.is_nil() {
+        table = table.block(parse_block(block_val, &bump)?);
+    }
+
+    if !row_highlight_style_val.is_nil() {
+        table = table.row_highlight_style(parse_style(row_highlight_style_val)?);
+    }
+
+    if !column_highlight_style_val.is_nil() {
+        table = table.column_highlight_style(parse_style(column_highlight_style_val)?);
+    }
+
+    if !cell_highlight_style_val.is_nil() {
+        table = table.cell_highlight_style(parse_style(cell_highlight_style_val)?);
+    }
+
+    if !highlight_symbol_val.is_nil() {
+        if let Ok(text) = parse_text(highlight_symbol_val) {
+            table = table.highlight_symbol(ratatui::text::Text::from(text));
+        } else {
+            let symbol: String = highlight_symbol_val.funcall("to_s", ())?;
+            table = table.highlight_symbol(symbol);
+        }
+    }
+
+    let style_val: Value = node.funcall("style", ())?;
+    if !style_val.is_nil() {
+        table = table.style(parse_style(style_val)?);
+    }
+
+    let column_spacing_val: Value = node.funcall("column_spacing", ())?;
+    if !column_spacing_val.is_nil() {
+        let spacing: u16 = column_spacing_val.funcall("to_int", ())?;
+        table = table.column_spacing(spacing);
+    }
+
+    let mut state = TableState::default();
+    if !selected_row_val.is_nil() {
+        let index: usize = selected_row_val.funcall("to_int", ())?;
+        state.select(Some(index));
+    }
+    if !selected_column_val.is_nil() {
+        let index: usize = selected_column_val.funcall("to_int", ())?;
+        state.select_column(Some(index));
+    }
+
+    let offset_val: Value = node.funcall("offset", ())?;
+    if !offset_val.is_nil() {
+        let offset: usize = offset_val.funcall("to_int", ())?;
+        *state.offset_mut() = offset;
+    }
+
+    StatefulWidget::render(table, area, buffer, &mut state);
+    Ok(())
+}
+
+/// Renders a Table with an external state object.
+///
+/// This function ignores `selected_row`, `selected_column`, and `offset` from the widget.
+/// The State object is the single source of truth for selection and scroll position.
+pub fn render_stateful(
+    buffer: &mut Buffer,
+    area: Rect,
+    node: Value,
+    state_wrapper: Value,
+) -> Result<(), Error> {
+    let bump = Bump::new();
+    let ruby = magnus::Ruby::get().unwrap();
+
+    // Extract the RubyTableState wrapper
+    let state: &RubyTableState = TryConvert::try_convert(state_wrapper)?;
+
+    // Parse rows
+    let rows_value: Value = node.funcall("rows", ())?;
+    let rows_array = magnus::RArray::from_value(rows_value)
+        .ok_or_else(|| type_error_with_context(&ruby, "expected array for rows", rows_value))?;
+    let widths_val: Value = node.funcall("widths", ())?;
+    let widths_array = magnus::RArray::from_value(widths_val)
+        .ok_or_else(|| type_error_with_context(&ruby, "expected array for widths", widths_val))?;
+
+    let mut rows = Vec::new();
+    for i in 0..rows_array.len() {
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let row_val: Value = rows_array.entry(index)?;
+        rows.push(parse_row(row_val)?);
+    }
+
+    let constraints = parse_constraints(widths_array)?;
+
+    // Build table (ignoring selected_row, selected_column, offset — State is truth)
+    let header_val: Value = node.funcall("header", ())?;
+    let footer_val: Value = node.funcall("footer", ())?;
+    let row_highlight_style_val: Value = node.funcall("row_highlight_style", ())?;
+    let column_highlight_style_val: Value = node.funcall("column_highlight_style", ())?;
+    let cell_highlight_style_val: Value = node.funcall("cell_highlight_style", ())?;
+    let highlight_symbol_val: Value = node.funcall("highlight_symbol", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+    let flex_sym: Symbol = node.funcall("flex", ())?;
+    let highlight_spacing_sym: Symbol = node.funcall("highlight_spacing", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let column_spacing_val: Value = node.funcall("column_spacing", ())?;
+
+    let flex = match flex_sym.to_string().as_str() {
+        "start" => Flex::Start,
+        "center" => Flex::Center,
+        "end" => Flex::End,
+        "space_between" => Flex::SpaceBetween,
+        "space_around" => Flex::SpaceAround,
+        "space_evenly" => Flex::SpaceEvenly,
+        _ => Flex::Legacy,
+    };
+
+    let mut table = Table::new(rows, constraints).flex(flex);
+
+    let highlight_spacing = match highlight_spacing_sym.to_string().as_str() {
+        "always" => HighlightSpacing::Always,
+        "never" => HighlightSpacing::Never,
+        _ => HighlightSpacing::WhenSelected,
+    };
+    table = table.highlight_spacing(highlight_spacing);
+
+    if !header_val.is_nil() {
+        table = table.header(parse_row(header_val)?);
+    }
+    if !footer_val.is_nil() {
+        table = table.footer(parse_row(footer_val)?);
+    }
+    if !block_val.is_nil() {
+        table = table.block(parse_block(block_val, &bump)?);
+    }
+    if !row_highlight_style_val.is_nil() {
+        table = table.row_highlight_style(parse_style(row_highlight_style_val)?);
+    }
+    if !column_highlight_style_val.is_nil() {
+        table = table.column_highlight_style(parse_style(column_highlight_style_val)?);
+    }
+    if !cell_highlight_style_val.is_nil() {
+        table = table.cell_highlight_style(parse_style(cell_highlight_style_val)?);
+    }
+    if !highlight_symbol_val.is_nil() {
+        if let Ok(text) = parse_text(highlight_symbol_val) {
+            table = table.highlight_symbol(ratatui::text::Text::from(text));
+        } else {
+            let symbol: String = highlight_symbol_val.funcall("to_s", ())?;
+            table = table.highlight_symbol(symbol);
+        }
+    }
+    if !style_val.is_nil() {
+        table = table.style(parse_style(style_val)?);
+    }
+    if !column_spacing_val.is_nil() {
+        let spacing: u16 = column_spacing_val.funcall("to_int", ())?;
+        table = table.column_spacing(spacing);
+    }
+
+    // Borrow the inner TableState, render, and release the borrow immediately
+    {
+        let mut inner_state = state.borrow_mut();
+        StatefulWidget::render(table, area, buffer, &mut inner_state);
+    }
+
+    Ok(())
+}
+
+fn parse_row(row_val: Value) -> Result<Row<'static>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+
+    // Check if this is a RatatuiRuby::Row object with cells + style + height + margins
+    let class = row_val.class();
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { class.name() }.into_owned();
+
+    if class_name == "RatatuiRuby::Widgets::Row" {
+        let cells_val: Value = row_val.funcall("cells", ())?;
+        let style_val: Value = row_val.funcall("style", ())?;
+        let height_val: Value = row_val.funcall("height", ())?;
+        let top_margin_val: Value = row_val.funcall("top_margin", ())?;
+        let bottom_margin_val: Value = row_val.funcall("bottom_margin", ())?;
+
+        let cells_array = magnus::RArray::from_value(cells_val).ok_or_else(|| {
+            type_error_with_context(&ruby, "expected array for Row.cells", cells_val)
+        })?;
+
+        let mut cells = Vec::new();
+        for i in 0..cells_array.len() {
+            let index = isize::try_from(i)
+                .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            let entry_val: Value = cells_array.entry(index)?;
+            cells.push(parse_cell(entry_val)?);
+        }
+
+        let mut row = Row::new(cells);
+
+        if !style_val.is_nil() {
+            row = row.style(parse_style(style_val)?);
+        }
+        if !height_val.is_nil() {
+            let h: u16 = height_val.funcall("to_int", ())?;
+            row = row.height(h);
+        }
+        if !top_margin_val.is_nil() {
+            let m: u16 = top_margin_val.funcall("to_int", ())?;
+            row = row.top_margin(m);
+        }
+        if !bottom_margin_val.is_nil() {
+            let m: u16 = bottom_margin_val.funcall("to_int", ())?;
+            row = row.bottom_margin(m);
+        }
+
+        return Ok(row);
+    }
+
+    // Fallback: plain array of cells
+    let row_array = magnus::RArray::from_value(row_val)
+        .ok_or_else(|| type_error_with_context(&ruby, "expected array for row", row_val))?;
+
+    let mut cells = Vec::new();
+    for i in 0..row_array.len() {
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let cell_val: Value = row_array.entry(index)?;
+        cells.push(parse_cell(cell_val)?);
+    }
+    Ok(Row::new(cells))
+}
+
+fn parse_cell(cell_val: Value) -> Result<Cell<'static>, Error> {
+    let class = cell_val.class();
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { class.name() }.into_owned();
+
+    // Try Text::Line first (contains multiple spans)
+    if class_name.contains("Line") {
+        if let Ok(line) = parse_line(cell_val) {
+            return Ok(Cell::from(line));
+        }
+    }
+
+    // Try Text::Span
+    if class_name.contains("Span") {
+        if let Ok(span) = parse_span(cell_val) {
+            return Ok(Cell::from(ratatui::text::Line::from(vec![span])));
+        }
+    }
+
+    if class_name == "RatatuiRuby::Widgets::Paragraph" {
+        let text: String = cell_val.funcall("text", ())?;
+        let style_val: Value = cell_val.funcall("style", ())?;
+        let cell_style = parse_style(style_val)?;
+        Ok(Cell::from(text).style(cell_style))
+    } else if class_name == "RatatuiRuby::Style::Style" {
+        Ok(Cell::from("").style(parse_style(cell_val)?))
+    } else if class_name == "RatatuiRuby::Widgets::Cell" {
+        // Widgets::Cell has content (String/Span/Line) and optional style
+        let content_val: Value = cell_val.funcall("content", ())?;
+        let style_val: Value = cell_val.funcall("style", ())?;
+
+        // Recursively parse the content (could be String, Span, or Line)
+        let mut cell = parse_cell(content_val)?;
+
+        if !style_val.is_nil() {
+            cell = cell.style(parse_style(style_val)?);
+        }
+        Ok(cell)
+    } else {
+        let cell_str: String = cell_val.funcall("to_s", ())?;
+        Ok(Cell::from(cell_str))
+    }
+}
+
+fn parse_constraints(widths_array: magnus::RArray) -> Result<Vec<Constraint>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let mut constraints = Vec::new();
+    for i in 0..widths_array.len() {
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let constraint_obj: Value = widths_array.entry(index)?;
+        let type_sym: Symbol = constraint_obj.funcall("type", ())?;
+        let value_obj: Value = constraint_obj.funcall("value", ())?;
+
+        match type_sym.to_string().as_str() {
+            "length" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Length(val));
+            }
+            "percentage" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Percentage(val));
+            }
+            "min" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Min(val));
+            }
+            "max" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Max(val));
+            }
+            "fill" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Fill(val));
+            }
+            "ratio" => {
+                if let Some(arr) = magnus::RArray::from_value(value_obj) {
+                    if arr.len() == 2 {
+                        let n = u32::try_convert(arr.entry(0)?)?;
+                        let d = u32::try_convert(arr.entry(1)?)?;
+                        constraints.push(Constraint::Ratio(n, d));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    Ok(constraints)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::{Row, Table, Widget};
+
+    #[test]
+    fn test_table_rendering() {
+        let rows = vec![Row::new(vec!["C1", "C2"])];
+        let table = Table::new(rows, [Constraint::Length(3), Constraint::Length(3)])
+            .header(Row::new(vec!["H1", "H2"]))
+            .footer(Row::new(vec!["F1", "F2"]));
+        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 3));
+        Widget::render(table, Rect::new(0, 0, 10, 3), &mut buf);
+
+        let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
+        // Check for presence of header and row content
+        assert!(content.contains("H1"));
+        assert!(content.contains("H2"));
+        assert!(content.contains("F1"));
+        assert!(content.contains("F2"));
+        assert!(content.contains("C1"));
+        assert!(content.contains("C2"));
+    }
+}

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

@@ -0,0 +1,203 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! `TableState` wrapper for exposing Ratatui's `TableState` to Ruby.
+//!
+//! This module provides `RubyTableState`, a Magnus-wrapped struct that holds
+//! a `RefCell<TableState>` for interior mutability during stateful rendering.
+//!
+//! # Design
+//!
+//! When using `render_stateful_widget`, the State object is the single source
+//! of truth for selection and offset. Widget properties (`selected_row`,
+//! `selected_column`, `offset`) are ignored in stateful mode.
+
+use magnus::{function, method, prelude::*, Error, Module, Ruby};
+use ratatui::widgets::TableState;
+use std::cell::RefCell;
+
+/// A wrapper around Ratatui's `TableState` exposed to Ruby.
+#[magnus::wrap(class = "RatatuiRuby::TableState")]
+pub struct RubyTableState {
+    inner: RefCell<TableState>,
+}
+
+impl RubyTableState {
+    /// Creates a new `RubyTableState` with optional initial selection.
+    pub fn new(selected: Option<usize>) -> Self {
+        let mut state = TableState::default();
+        if let Some(idx) = selected {
+            state.select(Some(idx));
+        }
+        Self {
+            inner: RefCell::new(state),
+        }
+    }
+
+    /// Sets the selected row index.
+    pub fn select(&self, index: Option<usize>) {
+        self.inner.borrow_mut().select(index);
+    }
+
+    /// Returns the currently selected row index.
+    pub fn selected(&self) -> Option<usize> {
+        self.inner.borrow().selected()
+    }
+
+    /// Sets the selected column index.
+    pub fn select_column(&self, index: Option<usize>) {
+        self.inner.borrow_mut().select_column(index);
+    }
+
+    /// Returns the currently selected column index.
+    pub fn selected_column(&self) -> Option<usize> {
+        self.inner.borrow().selected_column()
+    }
+
+    /// Returns the current scroll offset.
+    pub fn offset(&self) -> usize {
+        self.inner.borrow().offset()
+    }
+
+    /// Scrolls down by the given number of rows.
+    pub fn scroll_down_by(&self, amount: u16) {
+        self.inner.borrow_mut().scroll_down_by(amount);
+    }
+
+    /// Scrolls up by the given number of rows.
+    pub fn scroll_up_by(&self, amount: u16) {
+        self.inner.borrow_mut().scroll_up_by(amount);
+    }
+
+    /// Returns the currently selected cell as (row, column) tuple.
+    /// Returns None if either row or column is not selected.
+    pub fn selected_cell(&self) -> Option<(usize, usize)> {
+        self.inner.borrow().selected_cell()
+    }
+
+    /// Selects the next column or the first one if no column is selected.
+    pub fn select_next_column(&self) {
+        self.inner.borrow_mut().select_next_column();
+    }
+
+    /// Selects the previous column or the last one if no column is selected.
+    pub fn select_previous_column(&self) {
+        self.inner.borrow_mut().select_previous_column();
+    }
+
+    /// Selects the first column.
+    pub fn select_first_column(&self) {
+        self.inner.borrow_mut().select_first_column();
+    }
+
+    /// Selects the last column.
+    pub fn select_last_column(&self) {
+        self.inner.borrow_mut().select_last_column();
+    }
+
+    /// Selects the next row or the first one if no row is selected.
+    pub fn select_next(&self) {
+        self.inner.borrow_mut().select_next();
+    }
+
+    /// Selects the previous row or the last one if no row is selected.
+    pub fn select_previous(&self) {
+        self.inner.borrow_mut().select_previous();
+    }
+
+    /// Selects the first row.
+    pub fn select_first(&self) {
+        self.inner.borrow_mut().select_first();
+    }
+
+    /// Selects the last row.
+    pub fn select_last(&self) {
+        self.inner.borrow_mut().select_last();
+    }
+
+    /// Creates a new `RubyTableState` with a selected cell (row, column).
+    pub fn with_selected_cell(cell: Option<(usize, usize)>) -> Self {
+        let state = TableState::default().with_selected_cell(cell);
+        Self {
+            inner: RefCell::new(state),
+        }
+    }
+
+    /// Borrows the inner `TableState` mutably for rendering.
+    pub fn borrow_mut(&self) -> std::cell::RefMut<'_, TableState> {
+        self.inner.borrow_mut()
+    }
+}
+
+/// Registers the `TableState` class with Ruby.
+pub fn register(ruby: &Ruby, module: magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("TableState", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyTableState::new, 1))?;
+    class.define_singleton_method(
+        "with_selected_cell",
+        function!(RubyTableState::with_selected_cell, 1),
+    )?;
+    class.define_method("select", method!(RubyTableState::select, 1))?;
+    class.define_method("selected", method!(RubyTableState::selected, 0))?;
+    class.define_method("select_column", method!(RubyTableState::select_column, 1))?;
+    class.define_method(
+        "selected_column",
+        method!(RubyTableState::selected_column, 0),
+    )?;
+    class.define_method("selected_cell", method!(RubyTableState::selected_cell, 0))?;
+    class.define_method(
+        "select_next_column",
+        method!(RubyTableState::select_next_column, 0),
+    )?;
+    class.define_method(
+        "select_previous_column",
+        method!(RubyTableState::select_previous_column, 0),
+    )?;
+    class.define_method(
+        "select_first_column",
+        method!(RubyTableState::select_first_column, 0),
+    )?;
+    class.define_method(
+        "select_last_column",
+        method!(RubyTableState::select_last_column, 0),
+    )?;
+    class.define_method("offset", method!(RubyTableState::offset, 0))?;
+    class.define_method("scroll_down_by", method!(RubyTableState::scroll_down_by, 1))?;
+    class.define_method("scroll_up_by", method!(RubyTableState::scroll_up_by, 1))?;
+    class.define_method("select_next", method!(RubyTableState::select_next, 0))?;
+    class.define_method(
+        "select_previous",
+        method!(RubyTableState::select_previous, 0),
+    )?;
+    class.define_method("select_first", method!(RubyTableState::select_first, 0))?;
+    class.define_method("select_last", method!(RubyTableState::select_last, 0))?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_with_no_selection() {
+        let state = RubyTableState::new(None);
+        assert_eq!(state.selected(), None);
+        assert_eq!(state.selected_column(), None);
+        assert_eq!(state.offset(), 0);
+    }
+
+    #[test]
+    fn test_new_with_selection() {
+        let state = RubyTableState::new(Some(3));
+        assert_eq!(state.selected(), Some(3));
+    }
+
+    #[test]
+    fn test_column_selection() {
+        let state = RubyTableState::new(None);
+        state.select_column(Some(2));
+        assert_eq!(state.selected_column(), Some(2));
+        state.select_column(None);
+        assert_eq!(state.selected_column(), None);
+    }
+}