ratatui_ruby 0.3.1 → 0.4.0

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

@@ -1,7 +1,9 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use crate::style::{parse_block, parse_color};
+use crate::style::{parse_block, parse_color, parse_style};
+use crate::text::parse_text;
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, RArray, Symbol, Value};
 use ratatui::{
     symbols::Marker,
@@ -10,6 +12,7 @@ use ratatui::{
 };
 
 pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
     let shapes_val: RArray = node.funcall("shapes", ())?;
     let x_bounds_val: RArray = node.funcall("x_bounds", ())?;
     let y_bounds_val: RArray = node.funcall("y_bounds", ())?;
@@ -23,6 +26,10 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
         "dot" => Marker::Dot,
         "block" => Marker::Block,
         "bar" => Marker::Bar,
+        "half_block" => Marker::HalfBlock,
+        "quadrant" => Marker::Quadrant,
+        "sextant" => Marker::Sextant,
+        "octant" => Marker::Octant,
         _ => Marker::Braille,
     };
 
@@ -32,16 +39,24 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
         .marker(marker);
 
     if !block_val.is_nil() {
-        canvas = canvas.block(parse_block(block_val)?);
+        canvas = canvas.block(parse_block(block_val, &bump)?);
+    }
+
+    let background_color_val: Value = node.funcall("background_color", ())?;
+    if !background_color_val.is_nil() {
+        let background_color =
+            parse_color(&background_color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
+        canvas = canvas.background_color(background_color);
     }
 
     let canvas = canvas.paint(|ctx| {
         for shape_val in shapes_val {
             let class = shape_val.class();
-            let class_name = unsafe { class.name() };
+            // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+            let class_name = unsafe { class.name() }.into_owned();
 
-            match class_name.as_ref() {
-                "RatatuiRuby::Line" => {
+            match class_name.as_str() {
+                "RatatuiRuby::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);
@@ -49,15 +64,9 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                     let color_val: Value = shape_val.funcall("color", ()).unwrap();
                     let color =
                         parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
-                    ctx.draw(&Line {
-                        x1,
-                        y1,
-                        x2,
-                        y2,
-                        color,
-                    });
+                    ctx.draw(&Line { x1, y1, x2, y2, color });
                 }
-                "RatatuiRuby::Rectangle" => {
+                "RatatuiRuby::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);
@@ -65,29 +74,18 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                     let color_val: Value = shape_val.funcall("color", ()).unwrap();
                     let color =
                         parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
-                    ctx.draw(&Rectangle {
-                        x,
-                        y,
-                        width,
-                        height,
-                        color,
-                    });
+                    ctx.draw(&Rectangle { x, y, width, height, color });
                 }
-                "RatatuiRuby::Circle" => {
+                "RatatuiRuby::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);
                     let color_val: Value = shape_val.funcall("color", ()).unwrap();
                     let color =
                         parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
-                    ctx.draw(&Circle {
-                        x,
-                        y,
-                        radius,
-                        color,
-                    });
+                    ctx.draw(&Circle { x, y, radius, color });
                 }
-                "RatatuiRuby::Map" => {
+                "RatatuiRuby::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);
@@ -98,6 +96,26 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                     };
                     ctx.draw(&Map { color, resolution });
                 }
+                "RatatuiRuby::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();
+                    let style_val: Value = shape_val.funcall("style", ()).unwrap();
+
+                    // Parse text - take first line if multiple
+                    if let Ok(lines) = parse_text(text_val) {
+                        let mut line = lines.into_iter().next().unwrap_or_default();
+
+                        // Apply style if provided
+                        if !style_val.is_nil() {
+                            if let Ok(style) = parse_style(style_val) {
+                                line = line.style(style);
+                            }
+                        }
+
+                        ctx.print(x, y, line);
+                    }
+                }
                 _ => {}
             }
         }
@@ -132,7 +150,6 @@ mod tests {
         let mut buf = Buffer::empty(Rect::new(0, 0, 5, 5));
         canvas.render(Rect::new(0, 0, 5, 5), &mut buf);
 
-        // Verify that some Braille characters are rendered
         let mut found_braille = false;
         for cell in buf.content() {
             if !cell.symbol().trim().is_empty() {

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

@@ -2,19 +2,21 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_block, parse_style};
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, Value};
 use ratatui::{
     layout::Rect,
     symbols,
     text::Span,
-    widgets::{Axis, Chart, Dataset, GraphType},
+    widgets::{Axis, Chart, Dataset, GraphType, LegendPosition},
     Frame,
 };
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
     let ruby = magnus::Ruby::get().unwrap();
-    let class = node.class();
-    let class_name = unsafe { class.name() };
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { node.class().name() }.into_owned();
 
     if class_name == "RatatuiRuby::LineChart" {
         return render_line_chart(frame, area, node);
@@ -25,18 +27,22 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let y_axis_val: Value = node.funcall("y_axis", ())?;
     let block_val: Value = node.funcall("block", ())?;
     let style_val: Value = node.funcall("style", ())?;
+    let legend_position_val: Value = node.funcall("legend_position", ())?;
+    let hidden_legend_constraints_val: Value = node.funcall("hidden_legend_constraints", ())?;
 
     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 index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let ds_val: Value = datasets_val.entry(index)?;
         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 index = isize::try_from(j).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            let point_array_val: Value = data_array.entry(index)?;
             let point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
                 Error::new(ruby.exception_type_error(), "expected array for point")
             })?;
@@ -48,13 +54,13 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     for (i, points) in data_storage.iter().enumerate() {
-        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let ds_val: Value = datasets_val.entry(index)?;
         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,
@@ -62,18 +68,14 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         };
 
         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 style_val: Value = ds_val.funcall("style", ())?;
+        if !style_val.is_nil() {
+            ds_style = parse_style(style_val)?;
         }
 
         let ds = Dataset::default()
@@ -91,28 +93,53 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     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)?);
+        chart = chart.block(parse_block(block_val, &bump)?);
     }
 
     if !style_val.is_nil() {
         chart = chart.style(parse_style(style_val)?);
     }
 
+    if !legend_position_val.is_nil() {
+        let pos_sym: Symbol = legend_position_val.funcall("to_sym", ())?;
+        let pos = match pos_sym.to_string().as_str() {
+            "top_left" => LegendPosition::TopLeft,
+            "bottom_left" => LegendPosition::BottomLeft,
+            "bottom_right" => LegendPosition::BottomRight,
+            _ => LegendPosition::TopRight,
+        };
+        chart = chart.legend_position(Some(pos));
+    }
+
+    if !hidden_legend_constraints_val.is_nil() {
+        let constraints_array: magnus::RArray = hidden_legend_constraints_val.funcall("to_a", ())?;
+        if constraints_array.len() == 2 {
+            let width_val: Value = constraints_array.entry(0)?;
+            let height_val: Value = constraints_array.entry(1)?;
+            let width_constraint = super::layout::parse_constraint(width_val)?;
+            let height_constraint = super::layout::parse_constraint(height_val)?;
+            chart = chart.hidden_legend_constraints((width_constraint, height_constraint));
+        }
+    }
+
     frame.render_widget(chart, area);
     Ok(())
 }
 
 fn parse_axis(axis_val: Value) -> Result<Axis<'static>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
     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 labels_alignment_val: Value = axis_val.funcall("labels_alignment", ())?;
 
     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)?;
+        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let label: String = labels_val.entry(index)?;
         labels.push(Span::from(label));
     }
 
@@ -122,10 +149,21 @@ fn parse_axis(axis_val: Value) -> Result<Axis<'static>, Error> {
         axis = axis.style(parse_style(style_val)?);
     }
 
+    if !labels_alignment_val.is_nil() {
+        let alignment_sym: Symbol = labels_alignment_val.funcall("to_sym", ())?;
+        let alignment = match alignment_sym.to_string().as_str() {
+            "left" => ratatui::layout::HorizontalAlignment::Left,
+            "right" => ratatui::layout::HorizontalAlignment::Right,
+            _ => ratatui::layout::HorizontalAlignment::Center,
+        };
+        axis = axis.labels_alignment(alignment);
+    }
+
     Ok(axis)
 }
 
 fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
     let ruby = magnus::Ruby::get().unwrap();
     let datasets_val: magnus::RArray = node.funcall("datasets", ())?;
     let x_labels_val: magnus::RArray = node.funcall("x_labels", ())?;
@@ -137,12 +175,14 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
     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 index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let ds_val: Value = datasets_val.entry(index)?;
         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 index = isize::try_from(j).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            let point_array_val: Value = data_array.entry(index)?;
             let point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
                 Error::new(ruby.exception_type_error(), "expected array for point")
             })?;
@@ -154,14 +194,14 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
     }
 
     for (i, points) in data_storage.iter().enumerate() {
-        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let ds_val: Value = datasets_val.entry(index)?;
         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 style_val: Value = ds_val.funcall("style", ())?;
+        if !style_val.is_nil() {
+            ds_style = parse_style(style_val)?;
         }
 
         let ds = Dataset::default()
@@ -174,13 +214,15 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
 
     let mut x_labels = Vec::new();
     for i in 0..x_labels_val.len() {
-        let label: String = x_labels_val.entry(i as isize)?;
+        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let label: String = x_labels_val.entry(index)?;
         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)?;
+        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let label: String = y_labels_val.entry(index)?;
         y_labels.push(Span::from(label));
     }
     // Ratatui 0.29+ requires labels to be present for the axis line to render
@@ -210,7 +252,7 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
             }
         }
     }
-    if min_x == max_x {
+    if (min_x - max_x).abs() < f64::EPSILON {
         max_x = min_x + 1.0;
     }
 
@@ -219,7 +261,7 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
 
     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)?);
+        chart = chart.block(parse_block(block_val, &bump)?);
     }
 
     frame.render_widget(chart, area);

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

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, widgets::Widget, Frame};
 
@@ -10,7 +11,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     // 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)?;
+            let bump = Bump::new();
+            let block = crate::style::parse_block(block_val, &bump)?;
             block.render(area, frame.buffer_mut());
         }
     }

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

@@ -2,16 +2,19 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_block, parse_style};
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, widgets::Gauge, Frame};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
     let ratio: f64 = node.funcall("ratio", ())?;
     let label_val: Value = node.funcall("label", ())?;
     let style_val: Value = node.funcall("style", ())?;
+    let gauge_style_val: Value = node.funcall("gauge_style", ())?;
     let block_val: Value = node.funcall("block", ())?;
-
-    let mut gauge = Gauge::default().ratio(ratio);
+    let use_unicode: bool = node.funcall("use_unicode", ())?;
+    let mut gauge = Gauge::default().ratio(ratio).use_unicode(use_unicode);
 
     if !label_val.is_nil() {
         let label_str: String = label_val.funcall("to_s", ())?;
@@ -19,11 +22,15 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     if !style_val.is_nil() {
-        gauge = gauge.gauge_style(parse_style(style_val)?);
+        gauge = gauge.style(parse_style(style_val)?);
+    }
+
+    if !gauge_style_val.is_nil() {
+        gauge = gauge.gauge_style(parse_style(gauge_style_val)?);
     }
 
     if !block_val.is_nil() {
-        gauge = gauge.block(parse_block(block_val)?);
+        gauge = gauge.block(parse_block(block_val, &bump)?);
     }
 
     frame.render_widget(gauge, area);