ratatui_ruby 1.4.0-x86_64-linux

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

@@ -0,0 +1,183 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+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::buffer::Buffer;
+use ratatui::{
+    symbols::Marker,
+    widgets::{
+        canvas::{Canvas, Circle, Line, Map, MapResolution, Rectangle},
+        Widget,
+    },
+};
+
+#[allow(clippy::too_many_lines)]
+pub fn render(buffer: &mut Buffer, 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", ())?;
+    let marker_sym: Symbol = node.funcall("marker", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let x_bounds: [f64; 2] = [x_bounds_val.entry::<f64>(0)?, x_bounds_val.entry::<f64>(1)?];
+    let y_bounds: [f64; 2] = [y_bounds_val.entry::<f64>(0)?, y_bounds_val.entry::<f64>(1)?];
+
+    let marker = match marker_sym.to_string().as_str() {
+        "dot" => Marker::Dot,
+        "block" => Marker::Block,
+        "bar" => Marker::Bar,
+        "half_block" => Marker::HalfBlock,
+        "quadrant" => Marker::Quadrant,
+        "sextant" => Marker::Sextant,
+        "octant" => Marker::Octant,
+        _ => Marker::Braille,
+    };
+
+    let mut canvas = Canvas::default()
+        .x_bounds(x_bounds)
+        .y_bounds(y_bounds)
+        .marker(marker);
+
+    if !block_val.is_nil() {
+        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();
+            // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+            let class_name = unsafe { class.name() }.into_owned();
+
+            match class_name.as_str() {
+                "RatatuiRuby::Widgets::Shape::Line" => {
+                    let x1: f64 = shape_val.funcall("x1", ()).unwrap_or(0.0);
+                    let y1: f64 = shape_val.funcall("y1", ()).unwrap_or(0.0);
+                    let x2: f64 = shape_val.funcall("x2", ()).unwrap_or(0.0);
+                    let y2: f64 = shape_val.funcall("y2", ()).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(&Line {
+                        x1,
+                        y1,
+                        x2,
+                        y2,
+                        color,
+                    });
+                }
+                "RatatuiRuby::Widgets::Shape::Rectangle" => {
+                    let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
+                    let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
+                    let width: f64 = shape_val.funcall("width", ()).unwrap_or(0.0);
+                    let height: f64 = shape_val.funcall("height", ()).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(&Rectangle {
+                        x,
+                        y,
+                        width,
+                        height,
+                        color,
+                    });
+                }
+                "RatatuiRuby::Widgets::Shape::Circle" => {
+                    let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
+                    let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
+                    let radius: f64 = shape_val.funcall("radius", ()).unwrap_or(0.0);
+                    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,
+                    });
+                }
+                "RatatuiRuby::Widgets::Shape::Map" => {
+                    let color_val: Value = shape_val.funcall("color", ()).unwrap();
+                    let color =
+                        parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
+                    let resolution_sym: Symbol = shape_val.funcall("resolution", ()).unwrap();
+                    let resolution = match resolution_sym.to_string().as_str() {
+                        "high" => MapResolution::High,
+                        _ => MapResolution::Low,
+                    };
+                    ctx.draw(&Map { color, resolution });
+                }
+                "RatatuiRuby::Widgets::Shape::Label" => {
+                    let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
+                    let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
+                    let text_val: Value = shape_val.funcall("text", ()).unwrap();
+                    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);
+                    }
+                }
+                _ => {}
+            }
+        }
+    });
+
+    Widget::render(canvas, area, buffer);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::layout::Rect;
+    use ratatui::widgets::Widget;
+
+    #[test]
+    fn test_canvas_rendering() {
+        let canvas = Canvas::default()
+            .x_bounds([0.0, 10.0])
+            .y_bounds([0.0, 10.0])
+            .marker(Marker::Braille)
+            .paint(|ctx| {
+                ctx.draw(&Line {
+                    x1: 0.0,
+                    y1: 0.0,
+                    x2: 10.0,
+                    y2: 10.0,
+                    color: ratatui::style::Color::Red,
+                });
+            });
+        let mut buf = Buffer::empty(Rect::new(0, 0, 5, 5));
+        canvas.render(Rect::new(0, 0, 5, 5), &mut buf);
+
+        let mut found_braille = false;
+        for cell in buf.content() {
+            if !cell.symbol().trim().is_empty() {
+                found_braille = true;
+                break;
+            }
+        }
+        assert!(found_braille, "Canvas should render Braille characters");
+    }
+}

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

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::rendering::render_node;
+use magnus::{prelude::*, Error, Value};
+use ratatui::{
+    buffer::Buffer,
+    layout::{Constraint, Direction, Layout, Rect},
+};
+
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    let child: Value = node.funcall("child", ())?;
+    let width_percent: u16 = node.funcall("width_percent", ())?;
+    let height_percent: u16 = node.funcall("height_percent", ())?;
+
+    let popup_layout = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Percentage((100 - height_percent) / 2),
+            Constraint::Percentage(height_percent),
+            Constraint::Percentage((100 - height_percent) / 2),
+        ])
+        .split(area);
+
+    let vertical_center_area = popup_layout[1];
+
+    let popup_layout_horizontal = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([
+            Constraint::Percentage((100 - width_percent) / 2),
+            Constraint::Percentage(width_percent),
+            Constraint::Percentage((100 - width_percent) / 2),
+        ])
+        .split(vertical_center_area);
+
+    let center_area = popup_layout_horizontal[1];
+
+    render_node(buffer, center_area, child)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+
+    use ratatui::layout::{Constraint, Direction, Layout, Rect};
+
+    #[test]
+    fn test_center_logic() {
+        let area = Rect::new(0, 0, 100, 100);
+        let width_percent = 50;
+        let height_percent = 50;
+
+        let popup_layout = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Percentage((100 - height_percent) / 2),
+                Constraint::Percentage(height_percent),
+                Constraint::Percentage((100 - height_percent) / 2),
+            ])
+            .split(area);
+        let vertical_center = popup_layout[1];
+
+        // Vertical check
+        assert_eq!(vertical_center.height, 50);
+
+        let popup_layout_horizontal = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([
+                Constraint::Percentage((100 - width_percent) / 2),
+                Constraint::Percentage(width_percent),
+                Constraint::Percentage((100 - width_percent) / 2),
+            ])
+            .split(vertical_center);
+        let center = popup_layout_horizontal[1];
+
+        // Horizontal check
+        assert_eq!(center.width, 50);
+    }
+}

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

@@ -0,0 +1,222 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::errors::type_error_with_context;
+use crate::style::{parse_block, parse_style};
+use crate::text::parse_line;
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::buffer::Buffer;
+use ratatui::{
+    layout::Rect,
+    symbols,
+    widgets::{Axis, Chart, Dataset, GraphType, LegendPosition, Widget},
+};
+
+#[allow(clippy::too_many_lines)]
+pub fn render(buffer: &mut Buffer, 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_axis_val: Value = node.funcall("x_axis", ())?;
+    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 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 point_array_val: Value = data_array.entry(index)?;
+            let point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
+                type_error_with_context(&ruby, "expected array for point", point_array_val)
+            })?;
+            let x: f64 = point_array.entry(0)?;
+            let y: f64 = point_array.entry(1)?;
+            points.push((x, y));
+        }
+        data_storage.push(points);
+    }
+
+    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 ds_val: Value = datasets_val.entry(index)?;
+        let name_val: Value = ds_val.funcall("name", ())?;
+        let name = if let Ok(line) = parse_line(name_val) {
+            line
+        } else {
+            let name_str: String = name_val.funcall("to_s", ())?;
+            ratatui::text::Line::from(name_str)
+        };
+        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() {
+            "braille" => symbols::Marker::Braille,
+            "block" => symbols::Marker::Block,
+            "bar" => symbols::Marker::Bar,
+            "half_block" => symbols::Marker::HalfBlock,
+            _ => symbols::Marker::Dot,
+        };
+
+        let graph_type = match graph_type_sym.to_string().as_str() {
+            "scatter" => GraphType::Scatter,
+            _ => GraphType::Line,
+        };
+
+        let mut ds_style = ratatui::style::Style::default();
+        let style_val: Value = ds_val.funcall("style", ())?;
+        if !style_val.is_nil() {
+            ds_style = parse_style(style_val)?;
+        }
+
+        let ds = Dataset::default()
+            .name(name)
+            .marker(marker)
+            .graph_type(graph_type)
+            .style(ds_style)
+            .data(points);
+        datasets.push(ds);
+    }
+
+    let x_axis = parse_axis(x_axis_val)?;
+    let y_axis = parse_axis(y_axis_val)?;
+
+    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, &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,
+            "top" => LegendPosition::Top,
+            "bottom_left" => LegendPosition::BottomLeft,
+            "bottom" => LegendPosition::Bottom,
+            "bottom_right" => LegendPosition::BottomRight,
+            "left" => LegendPosition::Left,
+            "right" => LegendPosition::Right,
+            _ => 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));
+        }
+    }
+
+    Widget::render(chart, area, buffer);
+    Ok(())
+}
+
+fn parse_axis(axis_val: Value) -> Result<Axis<'static>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let title_val: Value = axis_val.funcall("title", ())?;
+    let title = if title_val.is_nil() {
+        ratatui::text::Line::from("")
+    } else if let Ok(line) = parse_line(title_val) {
+        line
+    } else {
+        let title_str: String = title_val.funcall("to_s", ())?;
+        ratatui::text::Line::from(title_str)
+    };
+    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 index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let entry_val: Value = labels_val.entry(index)?;
+        let label = if let Ok(line) = parse_line(entry_val) {
+            line
+        } else {
+            let label_str: String = entry_val.funcall("to_s", ())?;
+            ratatui::text::Line::from(label_str)
+        };
+        labels.push(label);
+    }
+
+    let mut axis = Axis::default().title(title).bounds(bounds).labels(labels);
+
+    if !style_val.is_nil() {
+        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)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::Widget;
+
+    #[test]
+    fn test_chart_rendering() {
+        let data = vec![(0.0, 0.0), (1.0, 1.0)];
+        let datasets = vec![Dataset::default().name("TestDS").data(&data)];
+        let chart = Chart::new(datasets)
+            .x_axis(
+                Axis::default()
+                    .bounds([0.0, 1.0])
+                    .labels(vec!["XMIN".into(), "XMAX".into()] as Vec<ratatui::text::Line>),
+            )
+            .y_axis(
+                Axis::default()
+                    .bounds([0.0, 1.0])
+                    .labels(vec!["YMIN".into(), "YMAX".into()] as Vec<ratatui::text::Line>),
+            );
+        let mut buf = Buffer::empty(Rect::new(0, 0, 40, 20));
+        chart.render(Rect::new(0, 0, 40, 20), &mut buf);
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+        let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
+        assert!(content.contains("XMIN"));
+        assert!(content.contains("XMAX"));
+        assert!(content.contains("YMIN"));
+        assert!(content.contains("YMAX"));
+        assert!(content.contains("TestDS"));
+    }
+}

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

@@ -0,0 +1,39 @@
+// 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::{buffer::Buffer, layout::Rect, widgets::Widget};
+
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    ratatui::widgets::Clear.render(area, buffer);
+
+    // 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 bump = Bump::new();
+            let block = crate::style::parse_block(block_val, &bump)?;
+            block.render(area, buffer);
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use ratatui::{backend::TestBackend, layout::Rect, widgets::Widget, Terminal};
+
+    #[test]
+    fn test_clear_renders_without_error() {
+        let backend = TestBackend::new(10, 5);
+        let mut terminal = Terminal::new(backend).unwrap();
+
+        terminal
+            .draw(|frame| {
+                let area = Rect::new(0, 0, 10, 5);
+                ratatui::widgets::Clear.render(area, frame.buffer_mut());
+            })
+            .unwrap();
+    }
+}

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

@@ -0,0 +1,32 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::{Error, Value};
+use ratatui::{buffer::Buffer, layout::Rect};
+
+/// Cursor widget requires Frame for `set_cursor_position` - cannot be rendered to buffer alone
+/// This is a no-op when rendering to buffer directly (e.g., in `insert_before`)
+/// For Frame-based rendering, use `frame.set_cursor_position()` directly
+#[allow(dead_code, clippy::unnecessary_wraps)]
+pub fn render(_buffer: &mut Buffer, _area: Rect, _node: Value) -> Result<(), Error> {
+    // Cursor positioning requires Frame.set_cursor_position(), not Buffer
+    // This is intentionally a no-op for buffer-only rendering
+    // The Frame wrapper in frame.rs should handle Cursor widgets specially
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use ratatui::layout::Rect;
+
+    #[test]
+    fn test_cursor_math() {
+        let area = Rect::new(10, 10, 50, 50);
+        let x = 5;
+        let y = 5;
+        let abs_x = area.x + x;
+        let abs_y = area.y + y;
+        assert_eq!(abs_x, 15);
+        assert_eq!(abs_y, 15);
+    }
+}

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

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// 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::buffer::Buffer;
+use ratatui::{layout::Rect, widgets::Gauge, widgets::Widget};
+
+pub fn render(buffer: &mut Buffer, 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 use_unicode: bool = node.funcall("use_unicode", ())?;
+    let mut gauge = Gauge::default().ratio(ratio).use_unicode(use_unicode);
+
+    if !label_val.is_nil() {
+        // 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() {
+        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, &bump)?);
+    }
+
+    gauge.render(area, buffer);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::{Gauge, Widget};
+
+    #[test]
+    fn test_gauge_rendering() {
+        let gauge = Gauge::default().ratio(0.5).label("50%");
+        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 1));
+        gauge.render(Rect::new(0, 0, 10, 1), &mut buf);
+        // Gauge renders block characters
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+        // Should contain label
+        assert!(buf.content().iter().any(|c| c.symbol() == "5"));
+        assert!(buf.content().iter().any(|c| c.symbol() == "%"));
+    }
+}