ratatui_ruby 0.1.0

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

@@ -0,0 +1,154 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_color};
+use magnus::{prelude::*, Error, Value};
+use ratatui::{
+    layout::Rect,
+    style::{Color, Style},
+    symbols,
+    widgets::{Chart, Dataset},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let datasets_val: magnus::RArray = node.funcall("datasets", ())?;
+    let x_labels_val: magnus::RArray = node.funcall("x_labels", ())?;
+    let y_labels_val: magnus::RArray = node.funcall("y_labels", ())?;
+    let y_bounds_val: magnus::RArray = node.funcall("y_bounds", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    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();
+    let mut name_storage: Vec<String> = Vec::new();
+
+    for i in 0..datasets_val.len() {
+        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let name: String = ds_val.funcall("name", ())?;
+        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 point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
+                Error::new(magnus::exception::type_error(), "expected array for point")
+            })?;
+            let x_val: Value = point_array.entry(0)?;
+            let y_val: Value = point_array.entry(1)?;
+
+            let x: f64 = x_val.funcall("to_f", ())?;
+            let y: f64 = y_val.funcall("to_f", ())?;
+            points.push((x, y));
+        }
+
+        data_storage.push(points);
+        name_storage.push(name);
+    }
+
+    for i in 0..data_storage.len() {
+        let ds_val: Value = datasets_val.entry(i as isize)?;
+        let color_val: Value = ds_val.funcall("color", ())?;
+        let color_str: String = color_val.funcall("to_s", ())?;
+        let color = parse_color(&color_str).unwrap_or(Color::White);
+
+        let ds = Dataset::default()
+            .name(name_storage[i].clone())
+            .marker(symbols::Marker::Braille)
+            .style(Style::default().fg(color))
+            .data(&data_storage[i]);
+        datasets.push(ds);
+    }
+
+    let mut x_labels = Vec::new();
+    for i in 0..x_labels_val.len() {
+        let label: String = x_labels_val.entry(i as isize)?;
+        x_labels.push(ratatui::text::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)?;
+        y_labels.push(ratatui::text::Span::from(label));
+    }
+
+    let y_bounds: [f64; 2] = [y_bounds_val.entry(0)?, y_bounds_val.entry(1)?];
+
+    // Calculate x_bounds based on datasets if possible
+    let mut min_x = 0.0;
+    let mut max_x = 0.0;
+    let mut first = true;
+    for ds_data in &data_storage {
+        for (x, _) in ds_data {
+            if first {
+                min_x = *x;
+                max_x = *x;
+                first = false;
+            } else {
+                if *x < min_x {
+                    min_x = *x;
+                }
+                if *x > max_x {
+                    max_x = *x;
+                }
+            }
+        }
+    }
+
+    // Ensure there's some range
+    if min_x == max_x {
+        max_x = min_x + 1.0;
+    }
+
+    let x_axis = ratatui::widgets::Axis::default()
+        .labels(x_labels)
+        .bounds([min_x, max_x]);
+
+    let y_axis = ratatui::widgets::Axis::default()
+        .labels(y_labels)
+        .bounds(y_bounds);
+
+    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)?);
+    }
+
+    frame.render_widget(chart, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::{Axis, Chart, Dataset, Widget};
+
+    #[test]
+    fn test_linechart_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()]),
+            )
+            .y_axis(
+                Axis::default()
+                    .bounds([0.0, 1.0])
+                    .labels(vec!["YMIN".into(), "YMAX".into()]),
+            );
+        let mut buf = Buffer::empty(Rect::new(0, 0, 40, 20)); // Larger buffer
+        chart.render(Rect::new(0, 0, 40, 20), &mut buf);
+        // Should have chart rendered (braille characters)
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+        // Should have labels
+        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/list.rs

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::parse_block;
+use magnus::{prelude::*, Error, Value};
+use ratatui::{
+    layout::Rect,
+    widgets::{List, ListState},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let items_val: Value = node.funcall("items", ())?;
+    let items_array = magnus::RArray::from_value(items_val)
+        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array"))?;
+    let selected_index_val: Value = node.funcall("selected_index", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut items = Vec::new();
+    for i in 0..items_array.len() {
+        let item: String = items_array.entry(i as isize)?;
+        items.push(item);
+    }
+
+    let mut state = ListState::default();
+    if !selected_index_val.is_nil() {
+        let index: usize = selected_index_val.funcall("to_int", ())?;
+        state.select(Some(index));
+    }
+
+    let mut list = List::new(items).highlight_symbol(">> ");
+
+    if !block_val.is_nil() {
+        list = list.block(parse_block(block_val)?);
+    }
+
+    frame.render_stateful_widget(list, area, &mut state);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::List;
+
+    #[test]
+    fn test_list_rendering() {
+        let items = vec!["Item 1", "Item 2"];
+        let list = List::new(items).highlight_symbol(">> ");
+        let mut state = ListState::default();
+        state.select(Some(1));
+
+        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 2));
+        use ratatui::widgets::StatefulWidget;
+        StatefulWidget::render(list, Rect::new(0, 0, 10, 2), &mut buf, &mut state);
+
+        let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
+        assert!(content.contains("Item 1"));
+        assert!(content.contains(">> Item 2"));
+    }
+}

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

@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+pub mod barchart;
+pub mod block;
+pub mod canvas;
+pub mod center;
+pub mod cursor;
+pub mod gauge;
+pub mod layout;
+pub mod linechart;
+pub mod list;
+pub mod overlay;
+pub mod paragraph;
+pub mod scrollbar;
+pub mod sparkline;
+pub mod table;
+pub mod tabs;

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

@@ -0,0 +1,20 @@
+// 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::{layout::Rect, Frame};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let layers_val: Value = node.funcall("layers", ())?;
+    let layers_array = magnus::RArray::from_value(layers_val)
+        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for layers"))?;
+
+    for i in 0..layers_array.len() {
+        let layer: Value = layers_array.entry(i as isize)?;
+        if let Err(e) = render_node(frame, area, layer) {
+            eprintln!("Error rendering overlay layer {}: {:?}", i, e);
+        }
+    }
+    Ok(())
+}

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

@@ -0,0 +1,56 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_style};
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::{
+    layout::{Alignment, Rect},
+    widgets::{Paragraph, Wrap},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let text: String = node.funcall("text", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+    let wrap: bool = node.funcall("wrap", ())?;
+    let align_sym: Symbol = node.funcall("align", ())?;
+
+    let style = parse_style(style_val)?;
+    let mut paragraph = Paragraph::new(text).style(style);
+
+    if !block_val.is_nil() {
+        paragraph = paragraph.block(parse_block(block_val)?);
+    }
+
+    if wrap {
+        paragraph = paragraph.wrap(Wrap { trim: true });
+    }
+
+    match align_sym.to_string().as_str() {
+        "center" => paragraph = paragraph.alignment(Alignment::Center),
+        "right" => paragraph = paragraph.alignment(Alignment::Right),
+        _ => {}
+    }
+
+    frame.render_widget(paragraph, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+
+    #[test]
+    fn test_paragraph_rendering() {
+        let p = Paragraph::new("test content").alignment(Alignment::Center);
+        let mut buf = Buffer::empty(Rect::new(0, 0, 20, 1));
+        use ratatui::widgets::Widget;
+        p.render(Rect::new(0, 0, 20, 1), &mut buf);
+        let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
+        assert!(content.contains("test content"));
+        // Check for centered alignment (should have leading spaces)
+        assert!(content.starts_with(' '));
+    }
+}

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

@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::parse_block;
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::{
+    layout::Rect,
+    widgets::{Scrollbar, ScrollbarOrientation, ScrollbarState},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let content_length: usize = node.funcall("content_length", ())?;
+    let position: usize = node.funcall("position", ())?;
+    let orientation_sym: Symbol = node.funcall("orientation", ())?;
+    let thumb_symbol: String = node.funcall("thumb_symbol", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut state = ScrollbarState::new(content_length).position(position);
+    let mut scrollbar = Scrollbar::default().thumb_symbol(&thumb_symbol);
+
+    scrollbar = match orientation_sym.to_string().as_str() {
+        "horizontal" => scrollbar.orientation(ScrollbarOrientation::HorizontalBottom),
+        _ => scrollbar.orientation(ScrollbarOrientation::VerticalRight),
+    };
+
+    if !block_val.is_nil() {
+        let block = parse_block(block_val)?;
+        let inner_area = block.inner(area);
+        frame.render_widget(block, area);
+        frame.render_stateful_widget(scrollbar, inner_area, &mut state);
+    } else {
+        frame.render_stateful_widget(scrollbar, area, &mut state);
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::StatefulWidget;
+
+    #[test]
+    fn test_scrollbar_vertical_render() {
+        let mut buf = Buffer::empty(Rect::new(0, 0, 1, 5));
+        let mut state = ScrollbarState::new(10).position(2);
+        let scrollbar = Scrollbar::default().orientation(ScrollbarOrientation::VerticalRight);
+
+        // Note: Scrollbar is stateful
+        scrollbar.render(Rect::new(0, 0, 1, 5), &mut buf, &mut state);
+
+        // Vertical scrollbar should render something in the first column
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+    }
+
+    #[test]
+    fn test_scrollbar_horizontal_render() {
+        let mut buf = Buffer::empty(Rect::new(0, 0, 5, 1));
+        let mut state = ScrollbarState::new(10).position(2);
+        let scrollbar = Scrollbar::default().orientation(ScrollbarOrientation::HorizontalBottom);
+
+        scrollbar.render(Rect::new(0, 0, 5, 1), &mut buf, &mut state);
+
+        // Horizontal scrollbar should render something in the first row
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+    }
+}

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

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_style};
+use magnus::{prelude::*, Error, Value};
+use ratatui::{layout::Rect, widgets::Sparkline, Frame};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let data_val: magnus::RArray = node.funcall("data", ())?;
+    let max_val: Value = node.funcall("max", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut data_vec = Vec::new();
+    for i in 0..data_val.len() {
+        let val: u64 = data_val.entry(i as isize)?;
+        data_vec.push(val);
+    }
+
+    let mut sparkline = Sparkline::default().data(&data_vec);
+
+    if !max_val.is_nil() {
+        let max: u64 = u64::try_convert(max_val)?;
+        sparkline = sparkline.max(max);
+    }
+
+    if !style_val.is_nil() {
+        sparkline = sparkline.style(parse_style(style_val)?);
+    }
+
+    if !block_val.is_nil() {
+        sparkline = sparkline.block(parse_block(block_val)?);
+    }
+
+    frame.render_widget(sparkline, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::{Sparkline, Widget};
+
+    #[test]
+    fn test_sparkline_rendering() {
+        let data = vec![1, 2, 3, 4];
+        let sparkline = Sparkline::default().data(&data);
+        let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
+        sparkline.render(Rect::new(0, 0, 4, 1), &mut buf);
+        // Should have sparkline rendered (non-space characters)
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+        // In sparkline, higher values generally result in different bar symbols
+        // but verifying exact symbols might be fragile across ratatui versions.
+        // At least we know it should have rendered 4 bars for 4 data points.
+        let bars = buf.content().iter().filter(|c| c.symbol() != " ").count();
+        assert_eq!(bars, 4);
+    }
+}

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

@@ -0,0 +1,117 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_style};
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::{
+    layout::{Constraint, Rect},
+    widgets::{Cell, Row, Table},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let header_val: Value = node.funcall("header", ())?;
+    let rows_val: Value = node.funcall("rows", ())?;
+    let rows_array = magnus::RArray::from_value(rows_val)
+        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for rows"))?;
+    let widths_val: Value = node.funcall("widths", ())?;
+    let widths_array = magnus::RArray::from_value(widths_val)
+        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for widths"))?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut rows = Vec::new();
+    for i in 0..rows_array.len() {
+        let row_val: Value = rows_array.entry(i as isize)?;
+        let row_array = magnus::RArray::from_value(row_val)
+            .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for row"))?;
+
+        let mut cells = Vec::new();
+        for j in 0..row_array.len() {
+            let cell_val: Value = row_array.entry(j as isize)?;
+            let class = cell_val.class();
+            let class_name = unsafe { class.name() };
+
+            if class_name.as_ref() == "RatatuiRuby::Paragraph" {
+                let text: String = cell_val.funcall("text", ())?;
+                let style_val: Value = cell_val.funcall("style", ())?;
+                let cell_style = parse_style(style_val)?;
+                cells.push(Cell::from(text).style(cell_style));
+            } else if class_name.as_ref() == "RatatuiRuby::Style" {
+                cells.push(Cell::from("").style(parse_style(cell_val)?));
+            } else {
+                let cell_str: String = cell_val.funcall("to_s", ())?;
+                cells.push(Cell::from(cell_str));
+            }
+        }
+        rows.push(Row::new(cells));
+    }
+
+    let mut constraints = Vec::new();
+    for i in 0..widths_array.len() {
+        let constraint_obj: Value = widths_array.entry(i as isize)?;
+        let type_sym: Symbol = constraint_obj.funcall("type", ())?;
+        let value: u16 = constraint_obj.funcall("value", ())?;
+
+        match type_sym.to_string().as_str() {
+            "length" => constraints.push(Constraint::Length(value)),
+            "percentage" => constraints.push(Constraint::Percentage(value)),
+            "min" => constraints.push(Constraint::Min(value)),
+            _ => {}
+        }
+    }
+
+    let mut table = Table::new(rows, constraints);
+
+    if !header_val.is_nil() {
+        let header_array = magnus::RArray::from_value(header_val).ok_or_else(|| {
+            Error::new(magnus::exception::type_error(), "expected array for header")
+        })?;
+        let mut header_cells = Vec::new();
+        for i in 0..header_array.len() {
+            let cell_val: Value = header_array.entry(i as isize)?;
+            let class = cell_val.class();
+            let class_name = unsafe { class.name() };
+
+            if class_name.as_ref() == "RatatuiRuby::Paragraph" {
+                let text: String = cell_val.funcall("text", ())?;
+                let style_val: Value = cell_val.funcall("style", ())?;
+                let cell_style = parse_style(style_val)?;
+                header_cells.push(Cell::from(text).style(cell_style));
+            } else {
+                let cell_str: String = cell_val.funcall("to_s", ())?;
+                header_cells.push(Cell::from(cell_str));
+            }
+        }
+        table = table.header(Row::new(header_cells));
+    }
+
+    if !block_val.is_nil() {
+        table = table.block(parse_block(block_val)?);
+    }
+
+    frame.render_widget(table, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::{Row, Table, Widget};
+
+    #[test]
+    fn test_table_rendering() {
+        let rows = vec![Row::new(vec!["C1", "C2"])];
+        let table = Table::new(rows, [Constraint::Length(3), Constraint::Length(3)])
+            .header(Row::new(vec!["H1", "H2"]));
+        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 2));
+        Widget::render(table, Rect::new(0, 0, 10, 2), &mut buf);
+
+        let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
+        // Check for presence of header and row content
+        assert!(content.contains("H1"));
+        assert!(content.contains("H2"));
+        assert!(content.contains("C1"));
+        assert!(content.contains("C2"));
+    }
+}

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

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::parse_block;
+use magnus::{prelude::*, Error, Value};
+use ratatui::{layout::Rect, text::Line, widgets::Tabs, Frame};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let titles_val: Value = node.funcall("titles", ())?;
+    let selected_index: usize = node.funcall("selected_index", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let titles_array = magnus::RArray::from_value(titles_val)
+        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array for titles"))?;
+
+    let mut titles = Vec::new();
+    for i in 0..titles_array.len() {
+        let title: String = titles_array.entry(i as isize)?;
+        titles.push(Line::from(title));
+    }
+
+    let mut tabs = Tabs::new(titles).select(selected_index);
+
+    if !block_val.is_nil() {
+        tabs = tabs.block(parse_block(block_val)?);
+    }
+
+    frame.render_widget(tabs, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::text::Line;
+    use ratatui::widgets::{Tabs, Widget};
+
+    #[test]
+    fn test_tabs_rendering() {
+        let titles = vec![Line::from("Tab1"), Line::from("Tab2")];
+        let tabs = Tabs::new(titles).select(1).divider("|");
+        let mut buf = Buffer::empty(Rect::new(0, 0, 15, 1));
+        tabs.render(Rect::new(0, 0, 15, 1), &mut buf);
+        // Should contain tab titles
+        let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
+        assert!(content.contains("Tab1"));
+        assert!(content.contains("Tab2"));
+        assert!(content.contains('|'));
+    }
+}

data/lib/ratatui_ruby/output.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+end

data/lib/ratatui_ruby/schema/bar_chart.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # A widget that displays numeric data as a bar chart.
+  #
+  # [data] A hash of { "Label" => value (Integer) }.
+  # [bar_width] The width of each bar in the chart.
+  # [bar_gap] The gap between bars.
+  # [max] Optional maximum value for the Y-axis.
+  # [style] Optional style for the bars.
+  # [block] Optional block widget to wrap the chart.
+  class BarChart < Data.define(:data, :bar_width, :bar_gap, :max, :style, :block)
+    # Creates a new BarChart widget.
+    #
+    # [data] A hash of { "Label" => value (Integer) }.
+    # [bar_width] The width of each bar in the chart.
+    # [bar_gap] The gap between bars.
+    # [max] Optional maximum value for the Y-axis.
+    # [style] Optional style for the bars.
+    # [block] Optional block widget to wrap the chart.
+    def initialize(data:, bar_width: 3, bar_gap: 1, max: nil, style: nil, block: nil)
+      super
+    end
+  end
+end

data/lib/ratatui_ruby/schema/block.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # A widget that wraps other widgets with a border and/or a title.
+  #
+  # [title] The title string to display on the border.
+  # [borders] An array of symbols representing which borders to display:
+  #           [:top, :bottom, :left, :right, :all, :none]
+  # [border_color] The color of the border (e.g., "red", "#ff0000").
+  class Block < Data.define(:title, :borders, :border_color)
+    # Creates a new Block.
+    #
+    # [title] The title string to display on the border.
+    # [borders] An array of symbols representing which borders to display.
+    # [border_color] The color of the border.
+    def initialize(title: nil, borders: [:all], border_color: nil)
+      super
+    end
+  end
+end