ratatui_ruby 0.6.0 → 0.7.0

data/examples/widget_rich_text/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Rich Text Example
 
+[![widget_rich_text](../../doc/images/widget_rich_text.png)](app.rb)
+
 Demonstrates styling individual words and characters.
 
 Standard strings are monochromatic. "Rich Text" is composed of `Lines` containing multiple `Spans`, where each Span has its own style. This allows for multi-colored, multi-styled text blocks.
@@ -30,6 +32,4 @@ ruby examples/widget_rich_text/app.rb
 Use this example if you need to...
 - Highlight keywords in code (Syntax highlighting).
 - Create status lines with icons (e.g., "✔ Success" where the checkmark is green).
-- Emphasize specific data points in a paragraph.
-
-![Demo](/doc/images/widget_rich_text.png)
+- Emphasize specific data points in a paragraph.

data/examples/widget_scroll_text/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Scroll Text Example
 
+[![widget_scroll_text](../../doc/images/widget_scroll_text.png)](app.rb)
+
 Demonstrates scrolling long text content within a fixed viewport.
 
 Sometimes text exceeds the available space. The `Paragraph` widget supports a `scroll` parameter to simulate a viewport, allowing users to pan vertically and horizontally.
@@ -32,6 +34,4 @@ ruby examples/widget_scroll_text/app.rb
 Use this example if you need to...
 - Build a log viewer.
 - Create a "terms and conditions" scrollbox.
-- Display code snippets that might be wider than the terminal.
-
-![Demo](/doc/images/widget_scroll_text.png)
+- Display code snippets that might be wider than the terminal.

data/examples/widget_scrollbar_demo/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Scrollbar Widget Example
 
+[![widget_scrollbar_demo](../../doc/images/widget_scrollbar_demo.png)](app.rb)
+
 Demonstrates explicit scrollbars for navigation feedback.
 
 Content overflows. Users get lost in long lists. Scrollbars provide essential spatial awareness ("How far down am I?") and navigation controls.
@@ -32,6 +34,4 @@ ruby examples/widget_scrollbar_demo/app.rb
 
 Use this example if you need to...
 - Add visual scroll indicators to Lists or Tables.
-- Implement specialized inputs like sliders or volume controls.
-
-![Demo](/doc/images/widget_scrollbar_demo.png)
+- Implement specialized inputs like sliders or volume controls.

data/examples/widget_sparkline_demo/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Sparkline Widget Example
 
+[![widget_sparkline_demo](../../doc/images/widget_sparkline_demo.png)](app.rb)
+
 Demonstrates high-density data visualization in a condensed footprint.
 
 Users need context. A single number ("90% CPU") tells you status, but not the trend. Full charts take up too much space. Sparklines condense history into a single line, perfect for headers and dashboards.
@@ -37,6 +39,4 @@ ruby examples/widget_sparkline_demo/app.rb
 Use this example if you need to...
 - Add a "CPU Load" graph to your header.
 - Visualize stock price trends in a list row.
-- Monitor memory usage over the last 60 seconds.
-
-![Demo](/doc/images/widget_sparkline_demo.png)
+- Monitor memory usage over the last 60 seconds.

data/examples/widget_style_colors/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Style Colors Example
 
+[![widget_style_colors](../../doc/images/widget_style_colors.png)](app.rb)
+
 Demonstrates high-fidelity color support.
 
 Terminals support millions of colors. This example generates a mathematically precise HSL gradient to prove the rendering engine's color fidelity.
@@ -29,6 +31,4 @@ ruby examples/widget_style_colors/app.rb
 Use this example if you need to...
 - Create meaningful heatmaps.
 - Generate color palettes dynamically.
-- Test your terminal's color support capabilities.
-
-![Demo](/doc/images/widget_style_colors.png)
+- Test your terminal's color support capabilities.

data/examples/widget_table_demo/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Table Widget Example
 
+[![widget_table_demo](../../doc/images/widget_table_demo.png)](app.rb)
+
 Demonstrates advanced options for the `Table` widget, including selection, row-level highlighting, and column-level highlighting.
 
 Data grids are complex. Users expect to navigate them with keys, select rows, and clearly see which cell is active. The `Table` widget provides these features out of the box efficiently.
@@ -43,6 +45,4 @@ ruby examples/widget_table_demo/app.rb
 Use this example if you need to...
 - Build a file explorer or process list.
 - Create a data-heavy dashboard.
-- Handle conflicting style requirements (e.g., "Highlight this row, but make this error cell red").
-
-![Demo](/doc/images/widget_table_demo.png)
+- Handle conflicting style requirements (e.g., "Highlight this row, but make this error cell red").

data/examples/widget_table_demo/app.rb

@@ -82,8 +82,23 @@ class WidgetTableDemo
   end
 
   private def render(frame)
-    # Create table rows from process data
-    rows = PROCESSES.map { |p| [p[:pid].to_s, p[:name], "#{p[:cpu]}%"] }
+    # v0.7.0: Create table rows using table_row and table_cell for per-cell styling
+    rows = PROCESSES.map do |p|
+      cpu_style = case p[:cpu]
+                  when 0...10 then @tui.style(fg: :green)
+                  when 10...30 then @tui.style(fg: :yellow)
+                  else @tui.style(fg: :red, modifiers: [:bold])
+      end
+      @tui.table_row(
+        cells: [
+          p[:pid].to_s,
+          p[:name],
+          @tui.table_cell(content: "#{p[:cpu]}%", style: cpu_style),
+        ],
+        # Apply alternating row backgrounds for readability
+        style: p[:pid].even? ? @tui.style(bg: :dark_gray) : nil
+      )
+    end
 
     # Define column widths
     widths = [
@@ -93,7 +108,7 @@ class WidgetTableDemo
     ]
 
     # Create highlight style (yellow text)
-    highlight_style = @tui.style(fg: :yellow)
+    row_highlight_style = @tui.style(fg: :yellow)
 
     current_style_entry = @styles[@current_style_index]
     current_spacing_entry = HIGHLIGHT_SPACINGS[@highlight_spacing_index]
@@ -114,7 +129,7 @@ class WidgetTableDemo
       selected_row: effective_selection,
       selected_column: @selected_col,
       offset: effective_offset,
-      highlight_style:,
+      row_highlight_style:,
       highlight_symbol: "> ",
       highlight_spacing: current_spacing_entry[:spacing],
       column_highlight_style: @show_column_highlight ? @column_highlight_style : nil,

data/examples/widget_tabs_demo/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Tabs Widget Example
 
+[![widget_tabs_demo](../../doc/images/widget_tabs_demo.png)](app.rb)
+
 Demonstrates view segregation with interactive navigation.
 
 Screen real estate is limited. You cannot show everything at once. Tabs segregate content into specialized views (modes), allowing users to switch contexts easily.
@@ -36,6 +38,4 @@ ruby examples/widget_tabs_demo/app.rb
 Use this example if you need to...
 - Build a multi-pane dashboard.
 - Create a "Settings" screen with different categories.
-- Implement a "wizard" interface with steps.
-
-![Demo](/doc/images/widget_tabs_demo.png)
+- Implement a "wizard" interface with steps.

data/examples/widget_text_width/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Text Width Calculator
 
+[![widget_text_width](../../doc/images/widget_text_width.png)](app.rb)
+
 Demonstrates string width calculation in a terminal environment.
 
 Not all characters are created equal. In a TUI, "Width" means cell count, not string length. Emoji (`👍`) take 2 cells. Chinese characters (`你`) take 2 cells. The `tui.text_width` helper tells you the visual width of a string.
@@ -30,6 +32,4 @@ ruby examples/widget_text_width/app.rb
 Use this example if you need to...
 - Align text correctly in columns.
 - Truncate strings that are too long for a widget.
-- Build your own custom layout engine.
-
-![Demo](/doc/images/widget_text_width.png)
+- Build your own custom layout engine.

data/examples/widget_text_width/app.rb

@@ -49,11 +49,18 @@ class WidgetTextWidth
     sample = @text_samples[@selected_index]
     measured_width = @tui.text_width(sample[:text])
 
+    # v0.7.0: Text::Line#width instance method for rich text measurement
+    styled_line = @tui.text_line(spans: [
+      @tui.text_span(content: sample[:text], style: @tui.style(fg: :cyan)),
+    ])
+    line_width = styled_line.width
+
     # Build content text with newlines
     content = []
     content << "Sample: #{sample[:text]}"
     content << ""
-    content << "Display Width: #{measured_width} cells"
+    content << "Display Width (text_width): #{measured_width} cells"
+    content << "Display Width (line.width): #{line_width} cells"
     content << "Character Count: #{sample[:text].length}"
     content << ""
     content << sample[:desc]

data/ext/ratatui_ruby/Cargo.lock

@@ -1012,7 +1012,7 @@ dependencies = [
 
 [[package]]
 name = "ratatui_ruby"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "bumpalo",
  "lazy_static",

data/ext/ratatui_ruby/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "ratatui_ruby"
-version = "0.6.0"
+version = "0.7.0"
 edition = "2021"
 
 [lib]

data/ext/ratatui_ruby/src/frame.rs

@@ -118,9 +118,10 @@ impl RubyFrame {
         // The ensure_active() check above guarantees we're still in the callback.
         let area = unsafe { (*self.inner.get()).as_ref().area() };
 
-        // Create a Ruby Rect object
+        // Create a Ruby Layout::Rect object
         let module = ruby.define_module("RatatuiRuby")?;
-        let class = module.const_get::<_, magnus::RClass>("Rect")?;
+        let layout_mod = module.const_get::<_, magnus::RModule>("Layout")?;
+        let class = layout_mod.const_get::<_, magnus::RClass>("Rect")?;
         class.funcall("new", (area.x, area.y, area.width, area.height))
     }
 
@@ -190,13 +191,13 @@ impl RubyFrame {
         let state_class = unsafe { state.class().name() }.into_owned();
 
         match (widget_class.as_str(), state_class.as_str()) {
-            ("RatatuiRuby::List", "RatatuiRuby::ListState") => {
+            ("RatatuiRuby::Widgets::List", "RatatuiRuby::ListState") => {
                 widgets::list::render_stateful(frame, rect, widget, state)
             }
-            ("RatatuiRuby::Table", "RatatuiRuby::TableState") => {
+            ("RatatuiRuby::Widgets::Table", "RatatuiRuby::TableState") => {
                 widgets::table::render_stateful(frame, rect, widget, state)
             }
-            ("RatatuiRuby::Scrollbar", "RatatuiRuby::ScrollbarState") => {
+            ("RatatuiRuby::Widgets::Scrollbar", "RatatuiRuby::ScrollbarState") => {
                 widgets::scrollbar::render_stateful(frame, rect, widget, state)
             }
             _ => Err(Error::new(

data/ext/ratatui_ruby/src/lib.rs

@@ -161,8 +161,9 @@ fn init() -> Result<(), Error> {
     m.define_module_function("_get_cell_at", function!(terminal::get_cell_at, 2))?;
     m.define_module_function("resize_terminal", function!(terminal::resize_terminal, 2))?;
 
-    // Register Layout.split on the Layout class
-    let layout_class = m.const_get::<_, magnus::RClass>("Layout")?;
+    // Register Layout.split on the Layout::Layout class (inside the Layout module)
+    let layout_mod = m.const_get::<_, magnus::RModule>("Layout")?;
+    let layout_class = layout_mod.const_get::<_, magnus::RClass>("Layout")?;
     layout_class.define_singleton_method("_split", function!(widgets::layout::split_layout, 4))?;
 
     // Paragraph metrics

data/ext/ratatui_ruby/src/rendering.rs

@@ -11,7 +11,8 @@ pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Err
         let ruby = magnus::Ruby::get().unwrap();
         let ruby_area = {
             let module = ruby.define_module("RatatuiRuby")?;
-            let class = module.const_get::<_, magnus::RClass>("Rect")?;
+            let layout_mod = module.const_get::<_, magnus::RModule>("Layout")?;
+            let class = layout_mod.const_get::<_, magnus::RClass>("Rect")?;
             class.funcall::<_, _, Value>("new", (area.x, area.y, area.width, area.height))?
         };
 
@@ -35,28 +36,28 @@ pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Err
     let class_name = unsafe { node.class().name() }.into_owned();
 
     match class_name.as_str() {
-        "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)?,
-        "RatatuiRuby::Layout" => widgets::layout::render(frame, area, node)?,
-        "RatatuiRuby::List" => widgets::list::render(frame, area, node)?,
-        "RatatuiRuby::Gauge" => widgets::gauge::render(frame, area, node)?,
-        "RatatuiRuby::LineGauge" => widgets::line_gauge::render(frame, area, node)?,
-        "RatatuiRuby::Table" => widgets::table::render(frame, area, node)?,
-        "RatatuiRuby::Block" => widgets::block::render(frame, area, node)?,
-        "RatatuiRuby::Tabs" => widgets::tabs::render(frame, area, node)?,
-        "RatatuiRuby::Scrollbar" => widgets::scrollbar::render(frame, area, node)?,
-        "RatatuiRuby::BarChart" => widgets::barchart::render(frame, area, node)?,
-        "RatatuiRuby::Canvas" => widgets::canvas::render(frame, area, node)?,
-        "RatatuiRuby::Calendar" => widgets::calendar::render(frame, area, node)?,
-        "RatatuiRuby::Sparkline" => widgets::sparkline::render(frame, area, node)?,
-        "RatatuiRuby::Chart" | "RatatuiRuby::LineChart" => {
+        "RatatuiRuby::Widgets::Paragraph" => widgets::paragraph::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Clear" => widgets::clear::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Cursor" => widgets::cursor::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Overlay" => widgets::overlay::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Center" => widgets::center::render(frame, area, node)?,
+        "RatatuiRuby::Layout::Layout" => widgets::layout::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::List" => widgets::list::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Gauge" => widgets::gauge::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::LineGauge" => widgets::line_gauge::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Table" => widgets::table::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Block" => widgets::block::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Tabs" => widgets::tabs::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Scrollbar" => widgets::scrollbar::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::BarChart" => widgets::barchart::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Canvas" => widgets::canvas::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Calendar" => widgets::calendar::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Sparkline" => widgets::sparkline::render(frame, area, node)?,
+        "RatatuiRuby::Widgets::Chart" | "RatatuiRuby::LineChart" => {
             widgets::chart::render(frame, area, node)?;
         }
-        "RatatuiRuby::RatatuiLogo" => widgets::ratatui_logo::render(frame, area, node),
-        "RatatuiRuby::RatatuiMascot" => {
+        "RatatuiRuby::Widgets::RatatuiLogo" => widgets::ratatui_logo::render(frame, area, node),
+        "RatatuiRuby::Widgets::RatatuiMascot" => {
             widgets::ratatui_mascot::render_ratatui_mascot(frame, area, node)?;
         }
         _ => {}

data/ext/ratatui_ruby/src/text.rs

@@ -131,6 +131,8 @@ pub fn parse_line(value: Value) -> Result<Line<'static>, Error> {
 
     // Extract spans from the Ruby Line
     let spans_val: Value = value.funcall("spans", ())?;
+    // v0.7.0: Extract style from the Ruby Line
+    let style_val: Value = value.funcall("style", ())?;
 
     if spans_val.is_nil() {
         return Ok(Line::from(""));
@@ -164,11 +166,18 @@ pub fn parse_line(value: Value) -> Result<Line<'static>, Error> {
         }
     }
 
-    if spans.is_empty() {
-        Ok(Line::from(""))
+    let mut line = if spans.is_empty() {
+        Line::from("")
     } else {
-        Ok(Line::from(spans))
+        Line::from(spans)
+    };
+
+    // v0.7.0: Apply line-level style if present
+    if !style_val.is_nil() {
+        line = line.style(parse_style(style_val)?);
     }
+
+    Ok(line)
 }
 
 #[cfg(test)]

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

@@ -57,7 +57,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
             let class_name = unsafe { class.name() }.into_owned();
 
             match class_name.as_str() {
-                "RatatuiRuby::Shape::Line" => {
+                "RatatuiRuby::Widgets::Shape::Line" => {
                     let x1: f64 = shape_val.funcall("x1", ()).unwrap_or(0.0);
                     let y1: f64 = shape_val.funcall("y1", ()).unwrap_or(0.0);
                     let x2: f64 = shape_val.funcall("x2", ()).unwrap_or(0.0);
@@ -73,7 +73,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                         color,
                     });
                 }
-                "RatatuiRuby::Shape::Rectangle" => {
+                "RatatuiRuby::Widgets::Shape::Rectangle" => {
                     let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
                     let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
                     let width: f64 = shape_val.funcall("width", ()).unwrap_or(0.0);
@@ -89,7 +89,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                         color,
                     });
                 }
-                "RatatuiRuby::Shape::Circle" => {
+                "RatatuiRuby::Widgets::Shape::Circle" => {
                     let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
                     let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
                     let radius: f64 = shape_val.funcall("radius", ()).unwrap_or(0.0);
@@ -103,7 +103,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                         color,
                     });
                 }
-                "RatatuiRuby::Shape::Map" => {
+                "RatatuiRuby::Widgets::Shape::Map" => {
                     let color_val: Value = shape_val.funcall("color", ()).unwrap();
                     let color =
                         parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
@@ -114,7 +114,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                     };
                     ctx.draw(&Map { color, resolution });
                 }
-                "RatatuiRuby::Shape::Label" => {
+                "RatatuiRuby::Widgets::Shape::Label" => {
                     let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
                     let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
                     let text_val: Value = shape_val.funcall("text", ()).unwrap();

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_block, parse_style};
+use crate::text::{parse_line, parse_span};
 use crate::widgets::table_state::RubyTableState;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, TryConvert, Value};
@@ -22,7 +23,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let widths_val: Value = node.funcall("widths", ())?;
     let widths_array = magnus::RArray::from_value(widths_val)
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for widths"))?;
-    let highlight_style_val: Value = node.funcall("highlight_style", ())?;
+    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", ())?;
@@ -73,8 +74,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         table = table.block(parse_block(block_val, &bump)?);
     }
 
-    if !highlight_style_val.is_nil() {
-        table = table.row_highlight_style(parse_style(highlight_style_val)?);
+    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() {
@@ -158,7 +159,7 @@ pub fn render_stateful(
     // 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 highlight_style_val: Value = node.funcall("highlight_style", ())?;
+    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", ())?;
@@ -196,8 +197,8 @@ pub fn render_stateful(
     if !block_val.is_nil() {
         table = table.block(parse_block(block_val, &bump)?);
     }
-    if !highlight_style_val.is_nil() {
-        table = table.row_highlight_style(parse_style(highlight_style_val)?);
+    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)?);
@@ -228,6 +229,53 @@ pub fn render_stateful(
 
 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(|| {
+            Error::new(ruby.exception_type_error(), "expected array for Row.cells")
+        })?;
+
+        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(|| Error::new(ruby.exception_type_error(), "expected array for row"))?;
 
@@ -246,42 +294,39 @@ fn parse_cell(cell_val: Value) -> Result<Cell<'static>, Error> {
     // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
     let class_name = unsafe { class.name() }.into_owned();
 
-    if class_name == "RatatuiRuby::Paragraph" {
+    // 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" {
+    } else if class_name == "RatatuiRuby::Style::Style" {
         Ok(Cell::from("").style(parse_style(cell_val)?))
-    } else if class_name == "RatatuiRuby::Cell" {
-        let symbol: String = cell_val.funcall("char", ())?;
-        let fg_val: Value = cell_val.funcall("fg", ())?;
-        let bg_val: Value = cell_val.funcall("bg", ())?;
-        let modifiers_val: Value = cell_val.funcall("modifiers", ())?;
-
-        let mut style = ratatui::style::Style::default();
-        if !fg_val.is_nil() {
-            if let Some(color) = crate::style::parse_color_value(fg_val)? {
-                style = style.fg(color);
-            }
-        }
-        if !bg_val.is_nil() {
-            if let Some(color) = crate::style::parse_color_value(bg_val)? {
-                style = style.bg(color);
-            }
-        }
-        if let Some(mods_array) = magnus::RArray::from_value(modifiers_val) {
-            let ruby = magnus::Ruby::get().unwrap();
-            for i in 0..mods_array.len() {
-                let index = isize::try_from(i)
-                    .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
-                let mod_str: String = mods_array.entry::<String>(index)?;
-                if let Some(modifier) = crate::style::parse_modifier_str(&mod_str) {
-                    style = style.add_modifier(modifier);
-                }
-            }
+    } 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::from(symbol).style(style))
+        Ok(cell)
     } else {
         let cell_str: String = cell_val.funcall("to_s", ())?;
         Ok(Cell::from(cell_str))