ratatui_ruby 0.3.1 → 0.5.0

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

@@ -2,6 +2,7 @@
 // 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,
@@ -12,12 +13,16 @@ use std::convert::TryFrom;
 use time::{Date, Month};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
     let ruby = magnus::Ruby::get().unwrap();
     let year: i32 = node.funcall("year", ())?;
     let month_u8: u8 = node.funcall("month", ())?;
-    let day_style_val: Value = node.funcall("day_style", ())?;
+    let events_val: Value = node.funcall("events", ())?;
+    let default_style_val: Value = node.funcall("default_style", ())?;
     let header_style_val: Value = node.funcall("header_style", ())?;
     let block_val: Value = node.funcall("block", ())?;
+    let show_weekdays_header: bool = node.funcall("show_weekdays_header", ())?;
+    let show_surrounding_val: Value = node.funcall("show_surrounding", ())?;
 
     let month = Month::try_from(month_u8)
         .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
@@ -25,58 +30,54 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let date = Date::from_calendar_date(year, month, 1)
         .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
 
-    let mut calendar = Monthly::new(date, CalendarEventStore::default());
+    let mut event_store = CalendarEventStore::default();
+    if !events_val.is_nil() {
+        let events_hash = magnus::RHash::try_convert(events_val)?;
+        events_hash.foreach(|date_val: Value, style_val: Value| {
+            let year = date_val.funcall("year", ())?;
+            let month_u8: u8 = date_val.funcall("month", ())?;
+            let day: u8 = date_val.funcall("day", ())?;
 
-    let header_style = if !header_style_val.is_nil() {
-        parse_style(header_style_val)?
-    } else {
+            let month = Month::try_from(month_u8)
+                .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
+            let date = Date::from_calendar_date(year, month, day)
+                .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
+            let style = parse_style(style_val)?;
+
+            event_store.add(date, style);
+            Ok(magnus::r_hash::ForEach::Continue)
+        })?;
+    }
+
+    let mut calendar = Monthly::new(date, event_store);
+
+    let header_style = if header_style_val.is_nil() {
         ratatui::style::Style::default()
+    } else {
+        parse_style(header_style_val)?
     };
-    calendar = calendar
-        .show_month_header(header_style)
-        .show_weekdays_header(header_style);
 
-    if !day_style_val.is_nil() {
-        calendar = calendar.default_style(parse_style(day_style_val)?);
+    let show_month_header: bool = node.funcall("show_month_header", ())?;
+    if show_month_header {
+        calendar = calendar.show_month_header(header_style);
     }
 
-    if !block_val.is_nil() {
-        calendar = calendar.block(parse_block(block_val)?);
+    if show_weekdays_header {
+        calendar = calendar.show_weekdays_header(header_style);
     }
 
-    frame.render_widget(calendar, area);
-    Ok(())
-}
+    if !show_surrounding_val.is_nil() {
+        calendar = calendar.show_surrounding(parse_style(show_surrounding_val)?);
+    }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use ratatui::buffer::Buffer;
-    use ratatui::widgets::Widget;
+    if !default_style_val.is_nil() {
+        calendar = calendar.default_style(parse_style(default_style_val)?);
+    }
 
-    #[test]
-    fn test_calendar_rendering() {
-        let date = Date::from_calendar_date(2025, Month::December, 1).unwrap();
-        let calendar = Monthly::new(date, CalendarEventStore::default())
-            .show_month_header(ratatui::style::Style::default());
-        let mut buf = Buffer::empty(Rect::new(0, 0, 40, 20));
-        calendar.render(Rect::new(0, 0, 40, 20), &mut buf);
-        let mut content = String::new();
-        for y in 0..20 {
-            for x in 0..40 {
-                content.push_str(buf.cell((x, y)).unwrap().symbol());
-            }
-            content.push('\n');
-        }
-        assert!(
-            content.contains("December"),
-            "Content did not contain December: \n{}",
-            content
-        );
-        assert!(
-            content.contains("2025"),
-            "Content did not contain 2025: \n{}",
-            content
-        );
+    if !block_val.is_nil() {
+        calendar = calendar.block(parse_block(block_val, &bump)?);
     }
+
+    frame.render_widget(calendar, area);
+    Ok(())
 }

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,
@@ -9,7 +11,9 @@ 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", ())?;
     let x_bounds_val: RArray = node.funcall("x_bounds", ())?;
     let y_bounds_val: RArray = node.funcall("y_bounds", ())?;
@@ -23,6 +27,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 +40,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);
@@ -57,7 +73,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                         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);
@@ -73,7 +89,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                         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);
@@ -87,7 +103,7 @@ pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Re
                         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 +114,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 +168,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,24 @@ 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 +56,14 @@ 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 +71,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 +96,55 @@ 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 +154,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 +180,16 @@ 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 +201,15 @@ 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 +222,17 @@ 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 +262,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 +271,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);