ratatui_ruby 0.4.0 → 0.5.0

data/ext/ratatui_ruby/src/style.rs

@@ -1,19 +1,23 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, Value};
 use ratatui::{
+    layout::Alignment,
     style::{Color, Modifier, Style},
+    symbols,
     text::Line,
     widgets::{Block, BorderType, Borders, Padding},
-    layout::Alignment,
-    symbols,
 };
-use bumpalo::Bump;
 
 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>() {
         return Some(color);
     }
-    
+
     // Try hex parsing manually: #RRGGBB
     let hex_str = color_str.trim();
     if hex_str.starts_with('#') && hex_str.len() == 7 {
@@ -24,7 +28,7 @@ pub fn parse_color(color_str: &str) -> Option<Color> {
             return Some(Color::Rgb(r, g, b));
         }
     }
-    
+
     None
 }
 
@@ -61,9 +65,12 @@ pub fn parse_style(style_val: Value) -> Result<Style, Error> {
 
     let (fg, bg, modifiers_val) = if let Some(hash) = magnus::RHash::from_value(style_val) {
         (
-            hash.lookup(ruby.to_symbol("fg")).unwrap_or_else(|_| ruby.qnil().as_value()),
-            hash.lookup(ruby.to_symbol("bg")).unwrap_or_else(|_| ruby.qnil().as_value()),
-            hash.lookup(ruby.to_symbol("modifiers")).unwrap_or_else(|_| ruby.qnil().as_value()),
+            hash.lookup(ruby.to_symbol("fg"))
+                .unwrap_or_else(|_| ruby.qnil().as_value()),
+            hash.lookup(ruby.to_symbol("bg"))
+                .unwrap_or_else(|_| ruby.qnil().as_value()),
+            hash.lookup(ruby.to_symbol("modifiers"))
+                .unwrap_or_else(|_| ruby.qnil().as_value()),
         )
     } else {
         (
@@ -92,7 +99,8 @@ pub fn parse_style(style_val: Value) -> Result<Style, Error> {
     if !modifiers_val.is_nil() {
         if let Some(modifiers_array) = magnus::RArray::from_value(modifiers_val) {
             for i in 0..modifiers_array.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()))?;
                 if let Ok(sym) = modifiers_array.entry::<Symbol>(index) {
                     if let Some(m) = parse_modifier_str(&sym.to_string()) {
                         style = style.add_modifier(m);
@@ -105,16 +113,22 @@ pub fn parse_style(style_val: Value) -> Result<Style, Error> {
     Ok(style)
 }
 
-pub fn parse_border_set<'a>(set_val: Value, bump: &'a Bump) -> Result<symbols::border::Set<'a>, Error> {
+pub fn parse_border_set<'a>(
+    set_val: Value,
+    bump: &'a Bump,
+) -> Result<symbols::border::Set<'a>, Error> {
     let ruby = magnus::Ruby::get().unwrap();
-    let hash = magnus::RHash::from_value(set_val).ok_or_else(|| {
-        Error::new(ruby.exception_type_error(), "expected hash for border_set")
-    })?;
+    let hash = magnus::RHash::from_value(set_val)
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected hash for border_set"))?;
 
     let get_char = |key: &str| -> Result<Option<&'a str>, Error> {
-        let mut val: Value = hash.lookup(ruby.to_symbol(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+        let mut val: Value = hash
+            .lookup(ruby.to_symbol(key))
+            .unwrap_or_else(|_| ruby.qnil().as_value());
         if val.is_nil() {
-            val = hash.lookup(ruby.str_new(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+            val = hash
+                .lookup(ruby.str_new(key))
+                .unwrap_or_else(|_| ruby.qnil().as_value());
         }
         if val.is_nil() {
             Ok(None)
@@ -125,28 +139,47 @@ pub fn parse_border_set<'a>(set_val: Value, bump: &'a Bump) -> Result<symbols::b
     };
 
     let mut set = symbols::border::Set::default();
-    if let Some(s) = get_char("top_left")? { set.top_left = s; }
-    if let Some(s) = get_char("top_right")? { set.top_right = s; }
-    if let Some(s) = get_char("bottom_left")? { set.bottom_left = s; }
-    if let Some(s) = get_char("bottom_right")? { set.bottom_right = s; }
-    if let Some(s) = get_char("vertical_left")? { set.vertical_left = s; }
-    if let Some(s) = get_char("vertical_right")? { set.vertical_right = s; }
-    if let Some(s) = get_char("horizontal_top")? { set.horizontal_top = s; }
-    if let Some(s) = get_char("horizontal_bottom")? { set.horizontal_bottom = s; }
+    if let Some(s) = get_char("top_left")? {
+        set.top_left = s;
+    }
+    if let Some(s) = get_char("top_right")? {
+        set.top_right = s;
+    }
+    if let Some(s) = get_char("bottom_left")? {
+        set.bottom_left = s;
+    }
+    if let Some(s) = get_char("bottom_right")? {
+        set.bottom_right = s;
+    }
+    if let Some(s) = get_char("vertical_left")? {
+        set.vertical_left = s;
+    }
+    if let Some(s) = get_char("vertical_right")? {
+        set.vertical_right = s;
+    }
+    if let Some(s) = get_char("horizontal_top")? {
+        set.horizontal_top = s;
+    }
+    if let Some(s) = get_char("horizontal_bottom")? {
+        set.horizontal_bottom = s;
+    }
 
     Ok(set)
 }
 
 pub fn parse_bar_set<'a>(set_val: Value, bump: &'a Bump) -> Result<symbols::bar::Set<'a>, Error> {
     let ruby = magnus::Ruby::get().unwrap();
-    let hash = magnus::RHash::from_value(set_val).ok_or_else(|| {
-        Error::new(ruby.exception_type_error(), "expected hash for bar_set")
-    })?;
+    let hash = magnus::RHash::from_value(set_val)
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected hash for bar_set"))?;
 
     let get_char = |key: &str| -> Result<Option<&'a str>, Error> {
-        let mut val: Value = hash.lookup(ruby.to_symbol(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+        let mut val: Value = hash
+            .lookup(ruby.to_symbol(key))
+            .unwrap_or_else(|_| ruby.qnil().as_value());
         if val.is_nil() {
-            val = hash.lookup(ruby.str_new(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+            val = hash
+                .lookup(ruby.str_new(key))
+                .unwrap_or_else(|_| ruby.qnil().as_value());
         }
         if val.is_nil() {
             Ok(None)
@@ -157,33 +190,57 @@ pub fn parse_bar_set<'a>(set_val: Value, bump: &'a Bump) -> Result<symbols::bar:
     };
 
     let mut set = symbols::bar::Set::default();
-    if let Some(s) = get_char("empty")? { set.empty = s; }
-    if let Some(s) = get_char("one_eighth")? { set.one_eighth = s; }
-    if let Some(s) = get_char("one_quarter")? { set.one_quarter = s; }
-    if let Some(s) = get_char("three_eighths")? { set.three_eighths = s; }
-    if let Some(s) = get_char("half")? { set.half = s; }
-    if let Some(s) = get_char("five_eighths")? { set.five_eighths = s; }
-    if let Some(s) = get_char("three_quarters")? { set.three_quarters = s; }
-    if let Some(s) = get_char("seven_eighths")? { set.seven_eighths = s; }
-    if let Some(s) = get_char("full")? { set.full = s; }
+    if let Some(s) = get_char("empty")? {
+        set.empty = s;
+    }
+    if let Some(s) = get_char("one_eighth")? {
+        set.one_eighth = s;
+    }
+    if let Some(s) = get_char("one_quarter")? {
+        set.one_quarter = s;
+    }
+    if let Some(s) = get_char("three_eighths")? {
+        set.three_eighths = s;
+    }
+    if let Some(s) = get_char("half")? {
+        set.half = s;
+    }
+    if let Some(s) = get_char("five_eighths")? {
+        set.five_eighths = s;
+    }
+    if let Some(s) = get_char("three_quarters")? {
+        set.three_quarters = s;
+    }
+    if let Some(s) = get_char("seven_eighths")? {
+        set.seven_eighths = s;
+    }
+    if let Some(s) = get_char("full")? {
+        set.full = s;
+    }
 
     Ok(set)
 }
 
 pub fn parse_block(block_val: Value, bump: &Bump) -> Result<Block<'_>, Error> {
-    if block_val.is_nil() { return Ok(Block::default()); }
+    if block_val.is_nil() {
+        return Ok(Block::default());
+    }
 
     let mut block = Block::default();
     if let Ok(v) = block_val.funcall::<&str, _, Value>("style", ()) {
-        if !v.is_nil() { block = block.style(parse_style(v)?); }
+        if !v.is_nil() {
+            block = block.style(parse_style(v)?);
+        }
     }
 
     if let Ok(v) = block_val.funcall::<&str, _, Value>("title_style", ()) {
-        if !v.is_nil() { block = block.title_style(parse_style(v)?); }
+        if !v.is_nil() {
+            block = block.title_style(parse_style(v)?);
+        }
     }
 
     if let Ok(title) = block_val.funcall::<&str, _, Value>("title", ()) {
-        if !title.is_nil() { 
+        if !title.is_nil() {
             let s: String = title.funcall("to_s", ())?;
             block = block.title(Line::from(s));
         }
@@ -208,11 +265,14 @@ pub fn parse_block(block_val: Value, bump: &Bump) -> Result<Block<'_>, Error> {
 
 fn parse_titles(block_val: Value, mut block: Block<'_>) -> Result<Block<'_>, Error> {
     if let Ok(titles_val) = block_val.funcall::<&str, _, Value>("titles", ()) {
-        if titles_val.is_nil() { return Ok(block); }
+        if titles_val.is_nil() {
+            return Ok(block);
+        }
         if let Some(titles_array) = magnus::RArray::from_value(titles_val) {
             for i in 0..titles_array.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 title_item: Value = titles_array.entry(index)?;
                 let mut content = String::new();
                 let mut alignment = Alignment::Left;
@@ -220,8 +280,10 @@ fn parse_titles(block_val: Value, mut block: Block<'_>) -> Result<Block<'_>, Err
                 let mut style = Style::default();
 
                 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", ())?; }
+                    if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("content")) {
+                        if !v.is_nil() {
+                            content = v.funcall("to_s", ())?;
+                        }
                     }
                     if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("alignment")) {
                         if let Some(s) = Symbol::from_value(v) {
@@ -234,25 +296,37 @@ fn parse_titles(block_val: Value, mut block: Block<'_>) -> Result<Block<'_>, Err
                     }
                     if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("position")) {
                         if let Some(s) = Symbol::from_value(v) {
-                            if s.to_string().as_str() == "bottom" { is_bottom = true; }
+                            if s.to_string().as_str() == "bottom" {
+                                is_bottom = true;
+                            }
                         }
                     }
-                    if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("style")) { 
-                        if !v.is_nil() { style = parse_style(v)?; }
+                    if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("style")) {
+                        if !v.is_nil() {
+                            style = parse_style(v)?;
+                        }
                     }
                 } else {
                     content = title_item.funcall("to_s", ())?;
                 }
 
                 let line = Line::from(content).alignment(alignment).style(style);
-                block = if is_bottom { block.title_bottom(line) } else { block.title_top(line) };
+                block = if is_bottom {
+                    block.title_bottom(line)
+                } else {
+                    block.title_top(line)
+                };
             }
         }
     }
     Ok(block)
 }
 
-fn parse_borders<'a>(block_val: Value, mut block: Block<'a>, bump: &'a Bump) -> Result<Block<'a>, Error> {
+fn parse_borders<'a>(
+    block_val: Value,
+    mut block: Block<'a>,
+    bump: &'a Bump,
+) -> Result<Block<'a>, Error> {
     if let Ok(borders_val) = block_val.funcall::<&str, _, Value>("borders", ()) {
         if !borders_val.is_nil() {
             let mut ratatui_borders = Borders::NONE;
@@ -268,7 +342,8 @@ fn parse_borders<'a>(block_val: Value, mut block: Block<'a>, bump: &'a Bump) ->
             } else if let Some(arr) = magnus::RArray::from_value(borders_val) {
                 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 sym: Symbol = arr.entry(index)?;
                     match sym.to_string().as_str() {
                         "all" => ratatui_borders |= Borders::ALL,
@@ -285,19 +360,23 @@ fn parse_borders<'a>(block_val: Value, mut block: Block<'a>, bump: &'a Bump) ->
     }
 
     if let Ok(v) = block_val.funcall::<&str, _, Value>("border_style", ()) {
-        if !v.is_nil() { block = block.border_style(parse_style(v)?); }
-        else if let Ok(color_val) = block_val.funcall::<&str, _, Value>("border_color", ()) {
+        if !v.is_nil() {
+            block = block.border_style(parse_style(v)?);
+        } else if let Ok(color_val) = block_val.funcall::<&str, _, Value>("border_color", ()) {
             if !color_val.is_nil() {
                 if let Ok(s) = color_val.funcall::<&str, _, String>("to_s", ()) {
-                    if let Some(c) = parse_color(&s) { block = block.border_style(Style::default().fg(c)); }
+                    if let Some(c) = parse_color(&s) {
+                        block = block.border_style(Style::default().fg(c));
+                    }
                 }
             }
         }
     }
 
     if let Ok(v) = block_val.funcall::<&str, _, Value>("border_set", ()) {
-        if !v.is_nil() { block = block.border_set(parse_border_set(v, bump)?); }
-        else if let Ok(v) = block_val.funcall::<&str, _, Value>("border_type", ()) {
+        if !v.is_nil() {
+            block = block.border_set(parse_border_set(v, bump)?);
+        } else if let Ok(v) = block_val.funcall::<&str, _, Value>("border_type", ()) {
             if let Some(sym) = Symbol::from_value(v) {
                 match sym.to_string().as_str() {
                     "rounded" => block = block.border_type(BorderType::Rounded),
@@ -315,7 +394,9 @@ fn parse_borders<'a>(block_val: Value, mut block: Block<'a>, bump: &'a Bump) ->
 
 fn parse_padding(block_val: Value, block: Block<'_>) -> Block<'_> {
     if let Ok(padding_val) = block_val.funcall::<&str, _, Value>("padding", ()) {
-        if padding_val.is_nil() { return block; }
+        if padding_val.is_nil() {
+            return block;
+        }
         if let Ok(p) = u16::try_convert(padding_val) {
             return block.padding(Padding::uniform(p));
         }

data/ext/ratatui_ruby/src/terminal.rs

@@ -1,8 +1,8 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use magnus::Error;
 use magnus::value::ReprValue;
+use magnus::Error;
 use ratatui::{
     backend::{CrosstermBackend, TestBackend},
     Terminal,
@@ -121,15 +121,11 @@ pub fn resize_terminal(width: u16, height: u16) -> Result<(), Error> {
     let mut term_lock = TERMINAL.lock().unwrap();
     if let Some(wrapper) = term_lock.as_mut() {
         match wrapper {
-            TerminalWrapper::Crossterm(_) => {
-            }
+            TerminalWrapper::Crossterm(_) => {}
             TerminalWrapper::Test(terminal) => {
                 terminal.backend_mut().resize(width, height);
                 if let Err(e) = terminal.resize(ratatui::layout::Rect::new(0, 0, width, height)) {
-                    return Err(Error::new(
-                        ruby.exception_runtime_error(),
-                        e.to_string(),
-                    ));
+                    return Err(Error::new(ruby.exception_runtime_error(), e.to_string()));
                 }
             }
         }
@@ -195,7 +191,7 @@ fn color_to_value(color: ratatui::style::Color) -> Value {
 fn modifiers_to_value(modifier: ratatui::style::Modifier) -> Value {
     let ruby = magnus::Ruby::get().unwrap();
     let ary = ruby.ary_new();
-    
+
     if modifier.contains(ratatui::style::Modifier::BOLD) {
         let _ = ary.push(ruby.str_new("bold"));
     }
@@ -223,6 +219,6 @@ fn modifiers_to_value(modifier: ratatui::style::Modifier) -> Value {
     if modifier.contains(ratatui::style::Modifier::RAPID_BLINK) {
         let _ = ary.push(ruby.str_new("rapid_blink"));
     }
-    
+
     ary.as_value()
 }

data/ext/ratatui_ruby/src/text.rs

@@ -23,7 +23,10 @@ pub fn parse_text(value: Value) -> Result<Vec<Line<'static>>, Error> {
     if let Ok(s) = String::try_convert(value) {
         // Split on newlines and create a Line for each.
         // We need to own the strings, so we convert each line string to a String
-        let lines: Vec<Line> = s.split('\n').map(|line| Line::from(line.to_string())).collect();
+        let lines: Vec<Line> = s
+            .split('\n')
+            .map(|line| Line::from(line.to_string()))
+            .collect();
         return if lines.is_empty() {
             Ok(vec![Line::from("")])
         } else {
@@ -36,7 +39,8 @@ pub fn parse_text(value: Value) -> Result<Vec<Line<'static>>, Error> {
         let mut lines = Vec::new();
         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 elem: Value = arr.entry(index)?;
 
             // Try to convert to String
@@ -68,7 +72,10 @@ pub fn parse_text(value: Value) -> Result<Vec<Line<'static>>, Error> {
     // Fallback: try to convert to string
     match String::try_convert(value) {
         Ok(s) => {
-            let lines: Vec<Line> = s.split('\n').map(|line| Line::from(line.to_string())).collect();
+            let lines: Vec<Line> = s
+                .split('\n')
+                .map(|line| Line::from(line.to_string()))
+                .collect();
             if lines.is_empty() {
                 Ok(vec![Line::from("")])
             } else {
@@ -139,7 +146,8 @@ pub fn parse_line(value: Value) -> Result<Line<'static>, Error> {
     let mut spans = Vec::new();
     for i in 0..spans_array.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 span_elem: Value = spans_array.entry(index)?;
 
         // If it's a string, convert to span without style
@@ -166,6 +174,5 @@ pub fn parse_line(value: Value) -> Result<Line<'static>, Error> {
 #[cfg(test)]
 mod tests {
     #[test]
-    fn test_parse_plain_string() {
-    }
+    fn test_parse_plain_string() {}
 }

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

@@ -3,7 +3,7 @@
 
 use crate::style::{parse_bar_set, parse_block, parse_style};
 use bumpalo::Bump;
-use magnus::{prelude::*, Error, Symbol, Value, RArray};
+use magnus::{prelude::*, Error, RArray, Symbol, Value};
 use ratatui::{
     layout::{Direction, Rect},
     text::Line,
@@ -41,59 +41,61 @@ 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() {
+                    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);
         }
     }
 

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