ratatui_ruby 1.5.2-arm64-darwin

data/ext/ratatui_ruby/src/terminal/storage.rs

@@ -0,0 +1,109 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+//! Private terminal storage with safe accessor functions.
+//!
+//! This module provides thread-local storage for the terminal and draw snapshot,
+//! with functions that route queries correctly:
+//! - During draw: queries go to snapshot (no lock needed)
+//! - Outside draw: queries go to live terminal
+
+use super::query::{DrawSnapshot, LiveTerminal, TerminalQuery};
+use super::wrapper::TerminalWrapper;
+use std::cell::RefCell;
+
+thread_local! {
+    static TERMINAL: RefCell<Option<TerminalWrapper>> = const { RefCell::new(None) };
+    static DRAW_SNAPSHOT: RefCell<Option<DrawSnapshot>> = const { RefCell::new(None) };
+}
+
+/// Check if we're currently inside a draw operation.
+pub fn is_in_draw_mode() -> bool {
+    DRAW_SNAPSHOT.with(|cell| cell.borrow().is_some())
+}
+
+/// Execute a query. Routes to snapshot during draw, live terminal outside.
+pub fn with_query<R, F>(f: F) -> Option<R>
+where
+    F: Fn(&dyn TerminalQuery) -> R,
+{
+    // During draw: use snapshot
+    DRAW_SNAPSHOT
+        .with(|cell| cell.borrow().as_ref().map(|snapshot| f(snapshot)))
+        .or_else(|| {
+            // Outside draw: use live terminal from thread-local storage
+            TERMINAL.with(|cell| {
+                cell.borrow_mut().as_mut().map(|t| {
+                    let live = LiveTerminal::new(t);
+                    f(&live)
+                })
+            })
+        })
+}
+
+/// Mutable access to terminal. Only works OUTSIDE draw.
+pub fn with_terminal_mut<R, F>(f: F) -> Option<R>
+where
+    F: FnOnce(&mut TerminalWrapper) -> R,
+{
+    // During draw: reject
+    if is_in_draw_mode() {
+        return None;
+    }
+    TERMINAL.with(|cell| cell.borrow_mut().as_mut().map(f))
+}
+
+/// Execute draw with snapshot for queries.
+pub fn lend_for_draw<R, F>(f: F) -> Option<R>
+where
+    F: FnOnce(&mut TerminalWrapper) -> R,
+{
+    // Take terminal out of storage
+    let mut terminal = TERMINAL.with(|cell| cell.borrow_mut().take())?;
+
+    // Capture snapshot BEFORE draw (while we have &mut)
+    let snapshot = DrawSnapshot::capture(&mut terminal);
+    DRAW_SNAPSHOT.with(|cell| *cell.borrow_mut() = Some(snapshot));
+
+    let result = f(&mut terminal);
+
+    // Clear snapshot, restore terminal
+    DRAW_SNAPSHOT.with(|cell| *cell.borrow_mut() = None);
+    TERMINAL.with(|cell| *cell.borrow_mut() = Some(terminal));
+
+    Some(result)
+}
+
+/// Set the terminal (used during initialization).
+pub fn set_terminal(wrapper: TerminalWrapper) {
+    TERMINAL.with(|cell| {
+        *cell.borrow_mut() = Some(wrapper);
+    });
+}
+
+/// Take the terminal out of storage (used during cleanup).
+pub fn take_terminal() -> Option<TerminalWrapper> {
+    TERMINAL.with(|cell| cell.borrow_mut().take())
+}
+
+/// Check if terminal is initialized.
+pub fn is_initialized() -> bool {
+    TERMINAL.with(|cell| cell.borrow().is_some())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::terminal::query::DrawSnapshot;
+    use ratatui::layout::Rect;
+
+    #[test]
+    fn test_is_in_draw_mode_false_by_default() {
+        assert!(!super::is_in_draw_mode());
+    }
+
+    #[test]
+    fn test_with_query_returns_none_when_not_initialized() {
+        let result = super::with_query(|q| q.size());
+        assert!(result.is_none());
+    }
+}

data/ext/ratatui_ruby/src/terminal/wrapper.rs

@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+//! Terminal wrapper enum for different backend types.
+
+use ratatui::{
+    backend::{CrosstermBackend, TestBackend},
+    Terminal,
+};
+use std::io;
+
+/// Unified terminal type supporting different backends.
+pub enum TerminalWrapper {
+    Crossterm(Terminal<CrosstermBackend<io::Stdout>>),
+    Test(Terminal<TestBackend>),
+}

data/ext/ratatui_ruby/src/text.rs

@@ -0,0 +1,225 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+use crate::errors::type_error_with_context;
+use crate::style::parse_style;
+use magnus::{prelude::*, Error, Value};
+use ratatui::text::{Line, Span};
+
+/// Parses a Ruby value into a ratatui Text structure.
+///
+/// Supports:
+/// - String: Plain text without styling
+/// - `Text::Span`: A single styled fragment
+/// - `Text::Line`: A line composed of multiple spans
+/// - Array: Array of `Text::Lines` or Strings
+pub fn parse_text(value: Value) -> Result<Vec<Line<'static>>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+
+    if value.is_nil() {
+        return Ok(vec![Line::from("")]);
+    }
+
+    // Check if it's a String
+    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();
+        return if lines.is_empty() {
+            Ok(vec![Line::from("")])
+        } else {
+            Ok(lines)
+        };
+    }
+
+    // Check if it's an Array
+    if let Some(arr) = magnus::RArray::from_value(value) {
+        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 elem: Value = arr.entry(index)?;
+
+            // Try to convert to String
+            if let Ok(s) = String::try_convert(elem) {
+                lines.push(Line::from(s));
+            } else if let Ok(line) = parse_line(elem) {
+                lines.push(line);
+            } else if let Ok(span) = parse_span(elem) {
+                lines.push(Line::from(vec![span]));
+            }
+        }
+        return if lines.is_empty() {
+            Ok(vec![Line::from("")])
+        } else {
+            Ok(lines)
+        };
+    }
+
+    // Try to parse as Line
+    if let Ok(line) = parse_line(value) {
+        return Ok(vec![line]);
+    }
+
+    // Try to parse as Span
+    if let Ok(span) = parse_span(value) {
+        return Ok(vec![Line::from(vec![span])]);
+    }
+
+    // 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();
+            if lines.is_empty() {
+                Ok(vec![Line::from("")])
+            } else {
+                Ok(lines)
+            }
+        }
+        Err(_) => Err(type_error_with_context(
+            &ruby,
+            "expected String, Text::Span, Text::Line, or Array of Text::Lines/Spans",
+            value,
+        )),
+    }
+}
+
+/// Parses a Ruby Span object into a ratatui Span.
+pub fn parse_span(value: Value) -> Result<Span<'static>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+
+    // Get class name
+    let class_obj: Value = value.funcall("class", ())?;
+    let class_name: String = class_obj.funcall("name", ())?;
+
+    if !class_name.contains("Span") {
+        return Err(type_error_with_context(
+            &ruby,
+            "expected a Text::Span object",
+            value,
+        ));
+    }
+
+    // Extract content and style from the Ruby Span
+    let content: Value = value.funcall("content", ())?;
+    let style_val: Value = value.funcall("style", ())?;
+
+    let content_str: String = content.funcall("to_s", ())?;
+    let style = parse_style(style_val)?;
+
+    Ok(Span::styled(content_str, style))
+}
+
+/// Parses a Ruby `Text::Line` object into a ratatui Line.
+/// Also accepts `Text::Span` objects and auto-coerces them to a Line.
+pub fn parse_line(value: Value) -> Result<Line<'static>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+
+    // Get class name
+    let class_obj: Value = value.funcall("class", ())?;
+    let class_name: String = class_obj.funcall("name", ())?;
+
+    // Auto-coerce Span to Line: wrap a single Span in a Line
+    if class_name.contains("Span") {
+        let span = parse_span(value)?;
+        return Ok(Line::from(vec![span]));
+    }
+
+    if !class_name.contains("Line") {
+        return Err(type_error_with_context(
+            &ruby,
+            "expected a Text::Line or Text::Span object",
+            value,
+        ));
+    }
+
+    // Extract spans from the Ruby Line
+    let spans_val: Value = value.funcall("spans", ())?;
+    // v0.7.0: Extract style from the Ruby Line
+    let style_val: Value = value.funcall("style", ())?;
+    // Extract alignment from the Ruby Line
+    let alignment_val: Value = value.funcall("alignment", ())?;
+
+    if spans_val.is_nil() {
+        return Ok(Line::from(""));
+    }
+
+    let spans_array = magnus::RArray::from_value(spans_val).ok_or_else(|| {
+        type_error_with_context(
+            &ruby,
+            "expected array of Spans in Text::Line.spans",
+            spans_val,
+        )
+    })?;
+
+    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 span_elem: Value = spans_array.entry(index)?;
+
+        // If it's a string, convert to span without style
+        if let Ok(s) = String::try_convert(span_elem) {
+            spans.push(Span::raw(s));
+        } else {
+            // Try to parse as Span object
+            if let Ok(span) = parse_span(span_elem) {
+                spans.push(span);
+            } else if let Ok(s) = String::try_convert(span_elem) {
+                // If it fails, try converting to string
+                spans.push(Span::raw(s));
+            }
+        }
+    }
+
+    let mut line = if spans.is_empty() {
+        Line::from("")
+    } else {
+        Line::from(spans)
+    };
+
+    // v0.7.0: Apply line-level style if present
+    if !style_val.is_nil() {
+        line = line.style(parse_style(style_val)?);
+    }
+
+    // Apply alignment if present
+    if !alignment_val.is_nil() {
+        if let Ok(alignment_sym) = magnus::Symbol::try_convert(alignment_val) {
+            let alignment_str = alignment_sym.name().map_err(|e| {
+                Error::new(
+                    ruby.exception_type_error(),
+                    format!("Invalid alignment symbol: {e}"),
+                )
+            })?;
+            let alignment = match alignment_str.as_ref() {
+                "left" => ratatui::layout::Alignment::Left,
+                "center" => ratatui::layout::Alignment::Center,
+                "right" => ratatui::layout::Alignment::Right,
+                _ => {
+                    return Err(Error::new(
+                        ruby.exception_arg_error(),
+                        format!("Invalid alignment: {alignment_str}. Valid values: :left, :center, :right"),
+                    ));
+                }
+            };
+            line = line.alignment(alignment);
+        }
+    }
+
+    Ok(line)
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_parse_plain_string() {}
+}

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

@@ -0,0 +1,169 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+use crate::style::{parse_bar_set, parse_block, parse_style};
+use crate::text::{parse_line, parse_span};
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, RArray, Symbol, Value};
+use ratatui::buffer::Buffer;
+use ratatui::{
+    layout::{Direction, Rect},
+    text::Line,
+    widgets::Widget,
+    widgets::{Bar, BarChart, BarGroup},
+};
+
+#[allow(clippy::too_many_lines)]
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
+    let data_val: Value = node.funcall("data", ())?;
+    let bar_width: u16 = node.funcall("bar_width", ())?;
+    let bar_gap: u16 = node.funcall("bar_gap", ())?;
+    let group_gap: u16 = node.funcall("group_gap", ())?;
+    let max_val: Value = node.funcall("max", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+    let direction_sym: Symbol = node.funcall("direction", ())?;
+    let label_style_val: Value = node.funcall("label_style", ())?;
+    let value_style_val: Value = node.funcall("value_style", ())?;
+    let bar_set_val: Value = node.funcall("bar_set", ())?;
+
+    let direction = if direction_sym.to_string() == "horizontal" {
+        Direction::Horizontal
+    } else {
+        Direction::Vertical
+    };
+
+    let mut bar_chart = BarChart::default()
+        .bar_width(bar_width)
+        .bar_gap(bar_gap)
+        .group_gap(group_gap)
+        .direction(direction);
+
+    // Data parsing
+    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 group_label: Line = if label_val.is_nil() {
+                Line::from("")
+            } else if let Ok(line) = parse_line(label_val) {
+                line
+            } else {
+                let label_str: String = label_val.funcall("to_s", ())?;
+                Line::from(label_str)
+            };
+
+            let bars_array: RArray = group_obj.funcall("bars", ())?;
+            let mut bars: Vec<Bar> = Vec::new();
+
+            for j in 0..bars_array.len() {
+                let bar_idx = isize::try_from(j)
+                    .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                let bar_obj: Value = bars_array.entry(bar_idx)?;
+
+                let value: u64 = bar_obj.funcall("value", ())?;
+                let mut bar = Bar::default().value(value);
+
+                let label_val: Value = bar_obj.funcall("label", ())?;
+                if !label_val.is_nil() {
+                    // Try to parse as Line (rich text)
+                    if let Ok(line) = parse_line(label_val) {
+                        bar = bar.label(line);
+                    } else if let Ok(span) = parse_span(label_val) {
+                        bar = bar.label(Line::from(vec![span]));
+                    } else {
+                        // Fallback to string
+                        let s: String = label_val.funcall("to_s", ())?;
+                        let s_ref = bump.alloc_str(&s) as &str;
+                        bar = bar.label(Line::from(s_ref));
+                    }
+                }
+
+                let text_val: Value = bar_obj.funcall("text_value", ())?;
+                if !text_val.is_nil() {
+                    // Try to parse as Line (rich text)
+                    if let Ok(line) = parse_line(text_val) {
+                        bar = bar.text_value(line);
+                    } else if let Ok(span) = parse_span(text_val) {
+                        bar = bar.text_value(Line::from(vec![span]));
+                    } else {
+                        // Fallback to string
+                        let s: String = text_val.funcall("to_s", ())?;
+                        let s_ref = bump.alloc_str(&s) as &str;
+                        bar = bar.text_value(s_ref);
+                    }
+                }
+
+                let style_val: Value = bar_obj.funcall("style", ())?;
+                if !style_val.is_nil() {
+                    bar = bar.style(parse_style(style_val)?);
+                }
+
+                let val_style_val: Value = bar_obj.funcall("value_style", ())?;
+                if !val_style_val.is_nil() {
+                    bar = bar.value_style(parse_style(val_style_val)?);
+                }
+
+                bars.push(bar);
+            }
+
+            let mut group = BarGroup::new(bars);
+            if !group_label.spans.is_empty() {
+                group = group.label(group_label);
+            }
+            bar_chart = bar_chart.data(group);
+        }
+    }
+
+    if !max_val.is_nil() {
+        let max: u64 = u64::try_convert(max_val)?;
+        bar_chart = bar_chart.max(max);
+    }
+
+    if !style_val.is_nil() {
+        bar_chart = bar_chart.style(parse_style(style_val)?);
+    }
+
+    if !block_val.is_nil() {
+        bar_chart = bar_chart.block(parse_block(block_val, &bump)?);
+    }
+
+    if !label_style_val.is_nil() {
+        bar_chart = bar_chart.label_style(parse_style(label_style_val)?);
+    }
+
+    if !value_style_val.is_nil() {
+        bar_chart = bar_chart.value_style(parse_style(value_style_val)?);
+    }
+
+    if !bar_set_val.is_nil() {
+        bar_chart = bar_chart.bar_set(parse_bar_set(bar_set_val, &bump)?);
+    }
+
+    bar_chart.render(area, buffer);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::{BarChart, Widget};
+
+    #[test]
+    fn test_barchart_rendering() {
+        let data = [("B1", 10), ("B2", 20)];
+        let chart = BarChart::default().data(&data).bar_width(3);
+        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 5));
+        chart.render(Rect::new(0, 0, 10, 5), &mut buf);
+        // Should have bars rendered (non-space characters)
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+        // Should have labels
+        assert!(buf.content().iter().any(|c| c.symbol().contains('B')));
+    }
+}

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

@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+use crate::rendering::render_node;
+use crate::style::parse_block;
+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> {
+    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, buffer);
+
+    // 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 child: Value = arr.entry(index)?;
+                if let Err(e) = render_node(buffer, inner, child) {
+                    eprintln!("Error rendering block child {i}: {e:?}");
+                }
+            }
+        }
+    }
+
+    Ok(())
+}

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

@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: LGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_style};
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, Value};
+use ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    widgets::calendar::{CalendarEventStore, Monthly},
+    widgets::Widget,
+};
+use std::convert::TryFrom;
+use time::{Date, Month};
+
+pub fn render(buffer: &mut Buffer, 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 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()))?;
+
+    let date = Date::from_calendar_date(year, month, 1)
+        .map_err(|e| Error::new(ruby.exception_arg_error(), e.to_string()))?;
+
+    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 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)?
+    };
+
+    let show_month_header: bool = node.funcall("show_month_header", ())?;
+    if show_month_header {
+        calendar = calendar.show_month_header(header_style);
+    }
+
+    if show_weekdays_header {
+        calendar = calendar.show_weekdays_header(header_style);
+    }
+
+    if !show_surrounding_val.is_nil() {
+        calendar = calendar.show_surrounding(parse_style(show_surrounding_val)?);
+    }
+
+    if !default_style_val.is_nil() {
+        calendar = calendar.default_style(parse_style(default_style_val)?);
+    }
+
+    if !block_val.is_nil() {
+        calendar = calendar.block(parse_block(block_val, &bump)?);
+    }
+
+    calendar.render(area, buffer);
+    Ok(())
+}