ratatui_ruby 0.6.0 → 0.7.1

data/examples/widget_ratatui_mascot_demo/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Ratatui Mascot Example
 
+[![widget_ratatui_mascot_demo](../../doc/images/widget_ratatui_mascot_demo.png)](app.rb)
+
 Demonstrates the project mascot widget for adding personality.
 
 Interfaces can feel clinical. A friendly mascot adds charm and brand identity to your terminal application.
@@ -29,6 +31,4 @@ ruby examples/widget_ratatui_mascot_demo/app.rb
 
 Use this example if you need to...
 - Add visual flair to your UI.
-- Create a friendly empty state or success screen.
-
-![Demo](/doc/images/widget_ratatui_mascot_demo.png)
+- Create a friendly empty state or success screen.

data/examples/widget_rect/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Rect (Geometry) Widget Example
 
+[![widget_rect](../../doc/images/widget_rect.png)](app.rb)
+
 Demonstrates the Rect geometry primitive and hit-testing patterns.
 
 TUI layouts are composed of rectangles. Understanding how to manipulate `Rect` objects, reuse them from the layout phase, and use them for mouse interaction is critical for building interactive apps.
@@ -33,6 +35,4 @@ ruby examples/widget_rect/app.rb
 Use this example if you need to...
 - Handle mouse clicks on specific buttons or areas.
 - Create resizable panes (like a split pane in an IDE).
-- Debug layout issues by inspecting Rect coordinates.
-
-![Demo](/doc/images/widget_rect.png)
+- Debug layout issues by inspecting Rect coordinates.

data/examples/widget_render/README.md

@@ -5,6 +5,8 @@ SPDX-License-Identifier: CC-BY-SA-4.0
 
 # Render (Custom Widget) Example
 
+[![widget_render](../../doc/images/widget_render.png)](app.rb)
+
 Demonstrates how to build Custom Widgets using absolute coordinates.
 
 Sometimes standard widgets aren't enough. You need to draw custom shapes, games, or graphs. This example shows how to implement the `render(area)` contract to draw anything you want while respecting layout boundaries.
@@ -32,6 +34,4 @@ ruby examples/widget_render/app.rb
 Use this example if you need to...
 - Build a game (Snake, Tetris) inside the terminal.
 - Create a specialized visualization (Network topology graph).
-- Draw custom UI elements not provided by the library.
-
-![Demo](/doc/images/widget_render.png)
+- Draw custom UI elements not provided by the library.

data/examples/widget_render/app.rb

@@ -21,7 +21,7 @@ class DiagonalWidget
         area.x + i,
         area.y + i,
         "\\",
-        RatatuiRuby::Style.new(fg: :red, modifiers: [:bold])
+        RatatuiRuby::Style::Style.new(fg: :red, modifiers: [:bold])
       )
     end
   end
@@ -47,7 +47,7 @@ class CheckerboardWidget
           area.x + col,
           area.y + row,
           @char,
-          RatatuiRuby::Style.new(fg: :cyan)
+          RatatuiRuby::Style::Style.new(fg: :cyan)
         )
       end
     end
@@ -63,7 +63,7 @@ end
 class BorderWidget
   def render(area)
     result = []
-    style = RatatuiRuby::Style.new(fg: :green)
+    style = RatatuiRuby::Style::Style.new(fg: :green)
 
     # Top and bottom
     (0...area.width).each do |x| # rubocop:disable Lint/AmbiguousRange

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.1"
 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.1"
 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/style.rs

@@ -12,6 +12,8 @@ use ratatui::{
     widgets::{Block, BorderType, Borders, Padding},
 };
 
+use crate::text::parse_line;
+
 pub fn parse_color(color_str: &str) -> Option<Color> {
     // Try standard ratatui parsing first (named colors, indexed, etc.)
     if let Ok(color) = color_str.parse::<Color>() {
@@ -274,15 +276,22 @@ fn parse_titles(block_val: Value, mut block: Block<'_>) -> Result<Block<'_>, Err
                 let index = isize::try_from(i)
                     .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
                 let title_item: Value = titles_array.entry(index)?;
-                let mut content = String::new();
                 let mut alignment = Alignment::Left;
                 let mut is_bottom = false;
                 let mut style = Style::default();
+                let mut line: Option<Line<'static>> = None;
 
                 if let Some(hash) = magnus::RHash::from_value(title_item) {
                     if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("content")) {
                         if !v.is_nil() {
-                            content = v.funcall("to_s", ())?;
+                            // First, try to parse as a Line object (preserves styling)
+                            if let Ok(parsed_line) = parse_line(v) {
+                                line = Some(parsed_line);
+                            } else {
+                                // Fallback to string
+                                let content: String = v.funcall("to_s", ())?;
+                                line = Some(Line::from(content));
+                            }
                         }
                     }
                     if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("alignment")) {
@@ -307,15 +316,22 @@ fn parse_titles(block_val: Value, mut block: Block<'_>) -> Result<Block<'_>, Err
                         }
                     }
                 } else {
-                    content = title_item.funcall("to_s", ())?;
+                    let content: String = title_item.funcall("to_s", ())?;
+                    line = Some(Line::from(content));
                 }
 
-                let line = Line::from(content).alignment(alignment).style(style);
-                block = if is_bottom {
-                    block.title_bottom(line)
-                } else {
-                    block.title_top(line)
-                };
+                if let Some(mut l) = line {
+                    l = l.alignment(alignment);
+                    // Only apply style if the line doesn't already have styled spans
+                    if style != Style::default() {
+                        l = l.style(style);
+                    }
+                    block = if is_bottom {
+                        block.title_bottom(l)
+                    } else {
+                        block.title_top(l)
+                    };
+                }
             }
         }
     }

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