ratatui_ruby 1.4.0-x86_64-linux

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

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::Value;
+use ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    widgets::{RatatuiLogo, RatatuiLogoSize, Widget},
+};
+
+pub fn render(buffer: &mut Buffer, area: Rect, _node: Value) {
+    // RatatuiLogo does not support custom styling (it has fixed colors).
+    // It requires a size argument.
+    let widget = RatatuiLogo::new(RatatuiLogoSize::Small);
+    widget.render(area, buffer);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
+
+    #[test]
+    fn test_render() {
+        let mut buffer = Buffer::empty(Rect::new(0, 0, 50, 20));
+        let widget = RatatuiLogo::new(RatatuiLogoSize::Small);
+        widget.render(Rect::new(0, 0, 50, 20), &mut buffer);
+
+        let content = buffer
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+
+        // The logo uses block characters for rendering
+        assert!(content.contains('█'));
+        assert!(!content.trim().is_empty());
+    }
+}

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

@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::parse_block;
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, Value};
+use ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    widgets::{RatatuiMascot, Widget},
+};
+
+pub fn render_ratatui_mascot(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut inner_area = area;
+
+    if !block_val.is_nil() {
+        let bump = Bump::new();
+        let block = parse_block(block_val, &bump)?;
+        inner_area = block.inner(area);
+        block.render(area, buffer);
+    }
+
+    let widget = RatatuiMascot::new();
+    widget.render(inner_area, buffer);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
+
+    #[test]
+    fn test_render() {
+        let mut buffer = Buffer::empty(Rect::new(0, 0, 50, 20));
+        let widget = RatatuiMascot::new();
+        widget.render(Rect::new(0, 0, 50, 20), &mut buffer);
+
+        let content = buffer
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+
+        // The mascot uses block drawing characters
+        assert!(
+            content.contains("█"),
+            "Mascot rendering should contain block characters"
+        );
+        assert!(!content.trim().is_empty());
+    }
+}

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

@@ -0,0 +1,214 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::parse_block;
+use crate::widgets::scrollbar_state::RubyScrollbarState;
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, Symbol, TryConvert, Value};
+use ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    widgets::{Scrollbar, ScrollbarOrientation, ScrollbarState, StatefulWidget, Widget},
+};
+
+pub fn render(buffer: &mut Buffer, 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_val: Value = node.funcall("thumb_symbol", ())?;
+    let thumb_style_val: Value = node.funcall("thumb_style", ())?;
+    let track_symbol_val: Value = node.funcall("track_symbol", ())?;
+    let track_style_val: Value = node.funcall("track_style", ())?;
+    let begin_symbol_val: Value = node.funcall("begin_symbol", ())?;
+    let begin_style_val: Value = node.funcall("begin_style", ())?;
+    let end_symbol_val: Value = node.funcall("end_symbol", ())?;
+    let end_style_val: Value = node.funcall("end_style", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut state = ScrollbarState::new(content_length).position(position);
+    let mut scrollbar = Scrollbar::default();
+
+    scrollbar = match orientation_sym.to_string().as_str() {
+        "vertical_left" => scrollbar.orientation(ScrollbarOrientation::VerticalLeft),
+        "horizontal_bottom" | "horizontal" => {
+            scrollbar.orientation(ScrollbarOrientation::HorizontalBottom)
+        }
+        "horizontal_top" => scrollbar.orientation(ScrollbarOrientation::HorizontalTop),
+        _ => scrollbar.orientation(ScrollbarOrientation::VerticalRight),
+    };
+
+    // Hoisted strings to extend lifetime
+    let thumb_str: String;
+    let track_str: String;
+    let begin_str: String;
+    let end_str: String;
+
+    if !thumb_symbol_val.is_nil() {
+        thumb_str = thumb_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.thumb_symbol(&thumb_str);
+    }
+    if !thumb_style_val.is_nil() {
+        scrollbar = scrollbar.thumb_style(crate::style::parse_style(thumb_style_val)?);
+    }
+    if !track_symbol_val.is_nil() {
+        track_str = track_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.track_symbol(Some(&track_str));
+    }
+    if !track_style_val.is_nil() {
+        scrollbar = scrollbar.track_style(crate::style::parse_style(track_style_val)?);
+    }
+    if !begin_symbol_val.is_nil() {
+        begin_str = begin_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.begin_symbol(Some(&begin_str));
+    }
+    if !begin_style_val.is_nil() {
+        scrollbar = scrollbar.begin_style(crate::style::parse_style(begin_style_val)?);
+    }
+    if !end_symbol_val.is_nil() {
+        end_str = end_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.end_symbol(Some(&end_str));
+    }
+    if !end_style_val.is_nil() {
+        scrollbar = scrollbar.end_style(crate::style::parse_style(end_style_val)?);
+    }
+    if !style_val.is_nil() {
+        scrollbar = scrollbar.style(crate::style::parse_style(style_val)?);
+    }
+
+    if block_val.is_nil() {
+        StatefulWidget::render(scrollbar, area, buffer, &mut state);
+    } else {
+        let bump = Bump::new();
+        let block = parse_block(block_val, &bump)?;
+        let inner_area = block.inner(area);
+        block.render(area, buffer);
+        StatefulWidget::render(scrollbar, inner_area, buffer, &mut state);
+    }
+    Ok(())
+}
+
+/// Renders a Scrollbar with an external state object.
+///
+/// The State object is the single source of truth for position and `content_length`.
+/// Widget properties (`position`, `content_length`) are ignored.
+pub fn render_stateful(
+    buffer: &mut Buffer,
+    area: Rect,
+    node: Value,
+    state_wrapper: Value,
+) -> Result<(), Error> {
+    // Extract the RubyScrollbarState wrapper
+    let state: &RubyScrollbarState = TryConvert::try_convert(state_wrapper)?;
+
+    let orientation_sym: Symbol = node.funcall("orientation", ())?;
+    let thumb_symbol_val: Value = node.funcall("thumb_symbol", ())?;
+    let thumb_style_val: Value = node.funcall("thumb_style", ())?;
+    let track_symbol_val: Value = node.funcall("track_symbol", ())?;
+    let track_style_val: Value = node.funcall("track_style", ())?;
+    let begin_symbol_val: Value = node.funcall("begin_symbol", ())?;
+    let begin_style_val: Value = node.funcall("begin_style", ())?;
+    let end_symbol_val: Value = node.funcall("end_symbol", ())?;
+    let end_style_val: Value = node.funcall("end_style", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut scrollbar = Scrollbar::default();
+
+    scrollbar = match orientation_sym.to_string().as_str() {
+        "vertical_left" => scrollbar.orientation(ScrollbarOrientation::VerticalLeft),
+        "horizontal_bottom" | "horizontal" => {
+            scrollbar.orientation(ScrollbarOrientation::HorizontalBottom)
+        }
+        "horizontal_top" => scrollbar.orientation(ScrollbarOrientation::HorizontalTop),
+        _ => scrollbar.orientation(ScrollbarOrientation::VerticalRight),
+    };
+
+    // Hoisted strings to extend lifetime
+    let thumb_str: String;
+    let track_str: String;
+    let begin_str: String;
+    let end_str: String;
+
+    if !thumb_symbol_val.is_nil() {
+        thumb_str = thumb_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.thumb_symbol(&thumb_str);
+    }
+    if !thumb_style_val.is_nil() {
+        scrollbar = scrollbar.thumb_style(crate::style::parse_style(thumb_style_val)?);
+    }
+    if !track_symbol_val.is_nil() {
+        track_str = track_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.track_symbol(Some(&track_str));
+    }
+    if !track_style_val.is_nil() {
+        scrollbar = scrollbar.track_style(crate::style::parse_style(track_style_val)?);
+    }
+    if !begin_symbol_val.is_nil() {
+        begin_str = begin_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.begin_symbol(Some(&begin_str));
+    }
+    if !begin_style_val.is_nil() {
+        scrollbar = scrollbar.begin_style(crate::style::parse_style(begin_style_val)?);
+    }
+    if !end_symbol_val.is_nil() {
+        end_str = end_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.end_symbol(Some(&end_str));
+    }
+    if !end_style_val.is_nil() {
+        scrollbar = scrollbar.end_style(crate::style::parse_style(end_style_val)?);
+    }
+    if !style_val.is_nil() {
+        scrollbar = scrollbar.style(crate::style::parse_style(style_val)?);
+    }
+
+    // Borrow the inner ScrollbarState, render, and release the borrow immediately
+    {
+        let mut inner_state = state.borrow_mut();
+        if block_val.is_nil() {
+            StatefulWidget::render(scrollbar, area, buffer, &mut inner_state);
+        } else {
+            let bump = Bump::new();
+            let block = parse_block(block_val, &bump)?;
+            let inner_area = block.inner(area);
+            block.render(area, buffer);
+            StatefulWidget::render(scrollbar, inner_area, buffer, &mut inner_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/scrollbar_state.rs

@@ -0,0 +1,169 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! `ScrollbarState` wrapper for exposing Ratatui's `ScrollbarState` to Ruby.
+//!
+//! This module provides `RubyScrollbarState`, a Magnus-wrapped struct that holds
+//! a `RefCell<ScrollbarState>` for interior mutability during stateful rendering.
+
+use magnus::{function, method, prelude::*, Error, Module, Ruby};
+use ratatui::widgets::ScrollbarState;
+use std::cell::RefCell;
+
+/// A wrapper around Ratatui's `ScrollbarState` exposed to Ruby.
+///
+/// Ratatui's `ScrollbarState` doesn't expose getters for `position`, `content_length`,
+/// or `viewport_content_length`. We track these values internally.
+#[magnus::wrap(class = "RatatuiRuby::ScrollbarState")]
+pub struct RubyScrollbarState {
+    inner: RefCell<ScrollbarState>,
+    /// We store these values ourselves since Ratatui's `ScrollbarState`
+    /// doesn't expose getters for them.
+    position_val: RefCell<usize>,
+    content_len: RefCell<usize>,
+    viewport_len: RefCell<usize>,
+}
+
+impl RubyScrollbarState {
+    /// Creates a new `RubyScrollbarState` with the given content length.
+    pub fn new(content_length: usize) -> Self {
+        Self {
+            inner: RefCell::new(ScrollbarState::new(content_length)),
+            position_val: RefCell::new(0),
+            content_len: RefCell::new(content_length),
+            viewport_len: RefCell::new(0),
+        }
+    }
+
+    /// Returns the current scroll position.
+    pub fn position(&self) -> usize {
+        *self.position_val.borrow()
+    }
+
+    /// Sets the current scroll position.
+    pub fn set_position(&self, position: usize) {
+        *self.position_val.borrow_mut() = position;
+        let mut state = self.inner.borrow_mut();
+        *state = state.position(position);
+    }
+
+    /// Returns the total content length.
+    pub fn content_length(&self) -> usize {
+        *self.content_len.borrow()
+    }
+
+    /// Sets the total content length.
+    pub fn set_content_length(&self, length: usize) {
+        *self.content_len.borrow_mut() = length;
+        let mut state = self.inner.borrow_mut();
+        *state = state.content_length(length);
+    }
+
+    /// Returns the viewport content length.
+    pub fn viewport_content_length(&self) -> usize {
+        *self.viewport_len.borrow()
+    }
+
+    /// Sets the viewport content length.
+    pub fn set_viewport_content_length(&self, length: usize) {
+        *self.viewport_len.borrow_mut() = length;
+        let mut state = self.inner.borrow_mut();
+        *state = state.viewport_content_length(length);
+    }
+
+    /// Scrolls to the first position.
+    pub fn first(&self) {
+        *self.position_val.borrow_mut() = 0;
+        self.inner.borrow_mut().first();
+    }
+
+    /// Scrolls to the last position.
+    pub fn last(&self) {
+        let content_len = *self.content_len.borrow();
+        let new_pos = content_len.saturating_sub(1);
+        *self.position_val.borrow_mut() = new_pos;
+        self.inner.borrow_mut().last();
+    }
+
+    /// Scrolls to the next position.
+    pub fn next(&self) {
+        let content_len = *self.content_len.borrow();
+        let current = *self.position_val.borrow();
+        let new_pos = (current + 1).min(content_len.saturating_sub(1));
+        *self.position_val.borrow_mut() = new_pos;
+        self.inner.borrow_mut().next();
+    }
+
+    /// Scrolls to the previous position.
+    pub fn prev(&self) {
+        let current = *self.position_val.borrow();
+        let new_pos = current.saturating_sub(1);
+        *self.position_val.borrow_mut() = new_pos;
+        self.inner.borrow_mut().prev();
+    }
+
+    /// Borrows the inner `ScrollbarState` mutably for rendering.
+    pub fn borrow_mut(&self) -> std::cell::RefMut<'_, ScrollbarState> {
+        self.inner.borrow_mut()
+    }
+}
+
+/// Registers the `ScrollbarState` class with Ruby.
+pub fn register(ruby: &Ruby, module: magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("ScrollbarState", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyScrollbarState::new, 1))?;
+    class.define_method("position", method!(RubyScrollbarState::position, 0))?;
+    class.define_method("position=", method!(RubyScrollbarState::set_position, 1))?;
+    class.define_method(
+        "content_length",
+        method!(RubyScrollbarState::content_length, 0),
+    )?;
+    class.define_method(
+        "content_length=",
+        method!(RubyScrollbarState::set_content_length, 1),
+    )?;
+    class.define_method(
+        "viewport_content_length",
+        method!(RubyScrollbarState::viewport_content_length, 0),
+    )?;
+    class.define_method(
+        "viewport_content_length=",
+        method!(RubyScrollbarState::set_viewport_content_length, 1),
+    )?;
+    class.define_method("first", method!(RubyScrollbarState::first, 0))?;
+    class.define_method("last", method!(RubyScrollbarState::last, 0))?;
+    class.define_method("next", method!(RubyScrollbarState::next, 0))?;
+    class.define_method("prev", method!(RubyScrollbarState::prev, 0))?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_with_content_length() {
+        let state = RubyScrollbarState::new(100);
+        assert_eq!(state.content_length(), 100);
+        assert_eq!(state.position(), 0);
+    }
+
+    #[test]
+    fn test_position_navigation() {
+        let state = RubyScrollbarState::new(10);
+        state.next();
+        assert_eq!(state.position(), 1);
+        state.prev();
+        assert_eq!(state.position(), 0);
+    }
+
+    #[test]
+    fn test_first_and_last() {
+        let state = RubyScrollbarState::new(10);
+        state.set_position(5);
+        state.first();
+        assert_eq!(state.position(), 0);
+        state.last();
+        assert_eq!(state.position(), 9);
+    }
+}

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

@@ -0,0 +1,127 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_bar_set, parse_block, parse_style};
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, RString, Value};
+use ratatui::buffer::Buffer;
+use ratatui::{layout::Rect, widgets::RenderDirection, widgets::Sparkline, widgets::Widget};
+
+pub fn render(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
+    let ruby = magnus::Ruby::get().unwrap();
+    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 direction_val: Value = node.funcall("direction", ())?;
+    let absent_value_symbol_val: Value = node.funcall("absent_value_symbol", ())?;
+    let absent_value_style_val: Value = node.funcall("absent_value_style", ())?;
+    let bar_set_val: Value = node.funcall("bar_set", ())?;
+
+    let mut data_vec = Vec::new();
+    for i in 0..data_val.len() {
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let val: Value = data_val.entry(index)?;
+        if val.is_nil() {
+            data_vec.push(None);
+        } else {
+            let num: u64 = u64::try_convert(val)?;
+            data_vec.push(Some(num));
+        }
+    }
+
+    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, &bump)?);
+    }
+
+    if !direction_val.is_nil() {
+        let direction_sym: RString = direction_val.funcall("to_s", ())?;
+        let direction_str = direction_sym.to_string()?;
+        let direction = match direction_str.as_str() {
+            "right_to_left" => RenderDirection::RightToLeft,
+            _ => RenderDirection::LeftToRight,
+        };
+        sparkline = sparkline.direction(direction);
+    }
+
+    if !absent_value_symbol_val.is_nil() {
+        let symbol_str: String = String::try_convert(absent_value_symbol_val)?;
+        // Only use the first character if multiple are provided
+        if let Some(first_char) = symbol_str.chars().next() {
+            sparkline = sparkline.absent_value_symbol(first_char);
+        }
+    }
+
+    if !absent_value_style_val.is_nil() {
+        sparkline = sparkline.absent_value_style(parse_style(absent_value_style_val)?);
+    }
+
+    if !bar_set_val.is_nil() {
+        sparkline = sparkline.bar_set(parse_bar_set(bar_set_val, &bump)?);
+    }
+
+    sparkline.render(area, buffer);
+    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);
+    }
+
+    #[test]
+    fn test_sparkline_absent_value_symbol() {
+        // Data with absent (None) and present values: [Some(5), None, Some(8), None]
+        let data = vec![Some(5), None, Some(8), None];
+        let sparkline = Sparkline::default().data(&data).absent_value_symbol("-");
+        let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
+        sparkline.render(Rect::new(0, 0, 4, 1), &mut buf);
+
+        // Collect all rendered symbols
+        let symbols: Vec<&str> = buf.content().iter().map(|c| c.symbol()).collect();
+
+        // Check that we have 4 cells rendered
+        assert_eq!(
+            symbols.len(),
+            4,
+            "Should have 4 cells rendered for 4 data points"
+        );
+
+        // Absent values (None) should render as "-"
+        assert_eq!(symbols[1], "-", "Second value (None) should render as dash");
+        assert_eq!(symbols[3], "-", "Fourth value (None) should render as dash");
+
+        // Present values should not be dashes
+        assert_ne!(symbols[0], "-", "First value (Some(5)) should not be dash");
+        assert_ne!(symbols[2], "-", "Third value (Some(8)) should not be dash");
+    }
+}