ratatui_ruby 0.4.0 → 0.6.0

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

@@ -2,8 +2,9 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_bar_set, parse_block, parse_style};
+use crate::text::{parse_line, parse_span};
 use bumpalo::Bump;
-use magnus::{prelude::*, Error, Symbol, Value, RArray};
+use magnus::{prelude::*, Error, RArray, Symbol, Value};
 use ratatui::{
     layout::{Direction, Rect},
     text::Line,
@@ -11,6 +12,7 @@ use ratatui::{
     Frame,
 };
 
+#[allow(clippy::too_many_lines)]
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let data_val: Value = node.funcall("data", ())?;
@@ -41,59 +43,77 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let ruby = magnus::Ruby::get().unwrap();
     if let Some(array) = RArray::from_value(data_val) {
         for i in 0..array.len() {
-             let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
-             let group_obj: Value = array.entry(index)?;
-             
-             let label_val: Value = group_obj.funcall("label", ())?;
-             let label_str: String = if !label_val.is_nil() {
-                 label_val.funcall("to_s", ())?
-             } else {
-                 String::new()
-             };
-             let label_ref = bump.alloc_str(&label_str) as &str;
-
-             let bars_array: RArray = group_obj.funcall("bars", ())?;
-             let mut bars: Vec<Bar> = Vec::new();
-
-             for j in 0..bars_array.len() {
-                  let bar_idx = isize::try_from(j).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
-                  let bar_obj: Value = bars_array.entry(bar_idx)?;
-
-                  let value: u64 = bar_obj.funcall("value", ())?;
-                  let mut bar = Bar::default().value(value);
-
-                  let label_val: Value = bar_obj.funcall("label", ())?;
-                  if !label_val.is_nil() {
-                      let s: String = label_val.funcall("to_s", ())?;
-                      let s_ref = bump.alloc_str(&s) as &str;
-                      bar = bar.label(Line::from(s_ref));
-                  }
-
-                   let text_val: Value = bar_obj.funcall("text_value", ())?;
-                  if !text_val.is_nil() {
-                      let s: String = text_val.funcall("to_s", ())?;
-                      let s_ref = bump.alloc_str(&s) as &str;
-                      bar = bar.text_value(s_ref);
-                  }
-
-                  let style_val: Value = bar_obj.funcall("style", ())?;
-                  if !style_val.is_nil() {
-                      bar = bar.style(parse_style(style_val)?);
-                  }
-
-                  let val_style_val: Value = bar_obj.funcall("value_style", ())?;
-                  if !val_style_val.is_nil() {
-                      bar = bar.value_style(parse_style(val_style_val)?);
-                  }
-                  
-                  bars.push(bar);
-             }
-             
-             let mut group = BarGroup::new(bars);
-             if !label_ref.is_empty() {
-                 group = group.label(Line::from(label_ref));
-             }
-             bar_chart = bar_chart.data(group);
+            let index = isize::try_from(i)
+                .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            let group_obj: Value = array.entry(index)?;
+
+            let label_val: Value = group_obj.funcall("label", ())?;
+            let label_str: String = if label_val.is_nil() {
+                String::new()
+            } else {
+                label_val.funcall("to_s", ())?
+            };
+            let label_ref = bump.alloc_str(&label_str) as &str;
+
+            let bars_array: RArray = group_obj.funcall("bars", ())?;
+            let mut bars: Vec<Bar> = Vec::new();
+
+            for j in 0..bars_array.len() {
+                let bar_idx = isize::try_from(j)
+                    .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                let bar_obj: Value = bars_array.entry(bar_idx)?;
+
+                let value: u64 = bar_obj.funcall("value", ())?;
+                let mut bar = Bar::default().value(value);
+
+                let label_val: Value = bar_obj.funcall("label", ())?;
+                if !label_val.is_nil() {
+                    // Try to parse as Line (rich text)
+                    if let Ok(line) = parse_line(label_val) {
+                        bar = bar.label(line);
+                    } else if let Ok(span) = parse_span(label_val) {
+                        bar = bar.label(Line::from(vec![span]));
+                    } else {
+                        // Fallback to string
+                        let s: String = label_val.funcall("to_s", ())?;
+                        let s_ref = bump.alloc_str(&s) as &str;
+                        bar = bar.label(Line::from(s_ref));
+                    }
+                }
+
+                let text_val: Value = bar_obj.funcall("text_value", ())?;
+                if !text_val.is_nil() {
+                    // Try to parse as Line (rich text)
+                    if let Ok(line) = parse_line(text_val) {
+                        bar = bar.text_value(line);
+                    } else if let Ok(span) = parse_span(text_val) {
+                        bar = bar.text_value(Line::from(vec![span]));
+                    } else {
+                        // Fallback to string
+                        let s: String = text_val.funcall("to_s", ())?;
+                        let s_ref = bump.alloc_str(&s) as &str;
+                        bar = bar.text_value(s_ref);
+                    }
+                }
+
+                let style_val: Value = bar_obj.funcall("style", ())?;
+                if !style_val.is_nil() {
+                    bar = bar.style(parse_style(style_val)?);
+                }
+
+                let val_style_val: Value = bar_obj.funcall("value_style", ())?;
+                if !val_style_val.is_nil() {
+                    bar = bar.value_style(parse_style(val_style_val)?);
+                }
+
+                bars.push(bar);
+            }
+
+            let mut group = BarGroup::new(bars);
+            if !label_ref.is_empty() {
+                group = group.label(Line::from(label_ref));
+            }
+            bar_chart = bar_chart.data(group);
         }
     }
 

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

@@ -11,23 +11,24 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
     let block = parse_block(node, &bump)?;
     let block_clone = block.clone();
-    
+
     // Render the block itself (borders, styling)
     block_clone.render(area, frame.buffer_mut());
-    
+
     // Get children and render them within the block's inner area
     let children_val: Value = node.funcall("children", ())?;
     let children_array = magnus::RArray::from_value(children_val);
-    
+
     if let Some(arr) = children_array {
         if !arr.is_empty() {
             // Calculate the inner area of the block (excluding borders and padding)
             let inner = block.inner(area);
-            
+
             // Render each child in the block's inner area
             for i in 0..arr.len() {
                 let ruby = magnus::Ruby::get().unwrap();
-                let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                let index = isize::try_from(i)
+                    .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
                 let child: Value = arr.entry(index)?;
                 if let Err(e) = render_node(frame, inner, child) {
                     eprintln!("Error rendering block child {i}: {e:?}");
@@ -35,6 +36,6 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
             }
         }
     }
-    
+
     Ok(())
 }

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

@@ -11,6 +11,7 @@ use ratatui::{
     Frame,
 };
 
+#[allow(clippy::too_many_lines)]
 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", ())?;
@@ -64,7 +65,13 @@ 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::Shape::Rectangle" => {
                     let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
@@ -74,7 +81,13 @@ 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::Shape::Circle" => {
                     let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
@@ -83,7 +96,12 @@ 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(&Circle { x, y, radius, color });
+                    ctx.draw(&Circle {
+                        x,
+                        y,
+                        radius,
+                        color,
+                    });
                 }
                 "RatatuiRuby::Shape::Map" => {
                     let color_val: Value = shape_val.funcall("color", ()).unwrap();

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

@@ -35,13 +35,15 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let mut data_storage: Vec<Vec<(f64, f64)>> = Vec::new();
 
     for i in 0..datasets_val.len() {
-        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        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 index = isize::try_from(j).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            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")
@@ -54,7 +56,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     for (i, points) in data_storage.iter().enumerate() {
-        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        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", ())?;
@@ -112,7 +115,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     if !hidden_legend_constraints_val.is_nil() {
-        let constraints_array: magnus::RArray = hidden_legend_constraints_val.funcall("to_a", ())?;
+        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)?;
@@ -138,7 +142,8 @@ fn parse_axis(axis_val: Value) -> Result<Axis<'static>, Error> {
 
     let mut labels = Vec::new();
     for i in 0..labels_val.len() {
-        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        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));
     }
@@ -175,13 +180,15 @@ 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 index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        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 index = isize::try_from(j).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            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")
@@ -194,7 +201,8 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
     }
 
     for (i, points) in data_storage.iter().enumerate() {
-        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        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", ())?;
 
@@ -214,14 +222,16 @@ 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 index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        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 index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        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));
     }

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_block, parse_style};
+use crate::text::parse_span;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, widgets::Gauge, Frame};
@@ -17,8 +18,14 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     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", ())?;
-        gauge = gauge.label(label_str);
+        // Try to parse as a Span (rich text)
+        if let Ok(span) = parse_span(label_val) {
+            gauge = gauge.label(span);
+        } else {
+            // Fallback to string
+            let label_str: String = label_val.funcall("to_s", ())?;
+            gauge = gauge.label(label_str);
+        }
     }
 
     if !style_val.is_nil() {

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

@@ -42,7 +42,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
         if let Some(arr) = constraints_array {
             for i in 0..arr.len() {
-                let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                let index = isize::try_from(i)
+                    .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
                 let constraint_obj: Value = arr.entry(index)?;
                 if let Ok(constraint) = parse_constraint(constraint_obj) {
                     ratatui_constraints.push(constraint);
@@ -53,7 +54,9 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         // If constraints don't match children, adjust or default
         if ratatui_constraints.len() != len {
             ratatui_constraints = (0..len)
-                .map(|_| Constraint::Percentage(100 / u16::try_from(len).unwrap_or(u16::MAX).max(1)))
+                .map(|_| {
+                    Constraint::Percentage(100 / u16::try_from(len).unwrap_or(u16::MAX).max(1))
+                })
                 .collect();
         }
 
@@ -64,7 +67,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
             .split(area);
 
         for i in 0..len {
-            let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            let index = isize::try_from(i)
+                .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
             let child: Value = children_array.entry(index)?;
             if let Err(e) = render_node(frame, chunks[i], child) {
                 eprintln!("Error rendering child {i}: {e:?}");
@@ -168,7 +172,8 @@ pub fn split_layout(
     // Parse constraints
     let mut ratatui_constraints = Vec::new();
     for i in 0..constraints.len() {
-        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
         let constraint_obj: Value = constraints.entry(index)?;
         if let Ok(constraint) = parse_constraint(constraint_obj) {
             ratatui_constraints.push(constraint);

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_block, parse_style};
+use crate::text::parse_span;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, widgets::LineGauge, Frame};
@@ -23,8 +24,14 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         .unfilled_symbol(&unfilled_symbol_val);
 
     if !label_val.is_nil() {
-        let label_str: String = label_val.funcall("to_s", ())?;
-        gauge = gauge.label(label_str);
+        // Try to parse as a Span (rich text)
+        if let Ok(span) = parse_span(label_val) {
+            gauge = gauge.label(span);
+        } else {
+            // Fallback to string
+            let label_str: String = label_val.funcall("to_s", ())?;
+            gauge = gauge.label(label_str);
+        }
     }
 
     if !style_val.is_nil() {