ratatui_ruby 0.4.0 → 0.6.0

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

@@ -2,12 +2,14 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_block, parse_style};
+use crate::text::{parse_line, parse_span};
+use crate::widgets::list_state::RubyListState;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, TryConvert, Value};
 use ratatui::{
     layout::Rect,
     text::Line,
-    widgets::{HighlightSpacing, List, ListState},
+    widgets::{HighlightSpacing, List, ListItem, ListState},
     Frame,
 };
 
@@ -27,10 +29,12 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let scroll_padding_val: Value = node.funcall("scroll_padding", ())?;
     let block_val: Value = node.funcall("block", ())?;
 
-    let mut items: Vec<String> = Vec::new();
+    let mut items: Vec<ListItem> = Vec::new();
     for i in 0..items_array.len() {
-        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
-        let item: String = items_array.entry(index)?;
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let item_val: Value = items_array.entry(index)?;
+        let item = parse_list_item(item_val)?;
         items.push(item);
     }
 
@@ -46,6 +50,12 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         state.select(Some(index));
     }
 
+    let offset_val: Value = node.funcall("offset", ())?;
+    if !offset_val.is_nil() {
+        let offset: usize = offset_val.funcall("to_int", ())?;
+        *state.offset_mut() = offset;
+    }
+
     let mut list = List::new(items);
 
     let highlight_spacing = match highlight_spacing_sym.to_string().as_str() {
@@ -100,6 +110,173 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     Ok(())
 }
 
+/// Renders a List with an external state object.
+///
+/// This function ignores `selected_index` and `offset` from the widget.
+/// The State object is the single source of truth for selection and scroll position.
+pub fn render_stateful(
+    frame: &mut Frame,
+    area: Rect,
+    node: Value,
+    state_wrapper: Value,
+) -> Result<(), Error> {
+    let bump = Bump::new();
+    let ruby = magnus::Ruby::get().unwrap();
+
+    // Extract the RubyListState wrapper
+    let state: &RubyListState = TryConvert::try_convert(state_wrapper)?;
+
+    // Build items
+    let items_val: Value = node.funcall("items", ())?;
+    let items_array = magnus::RArray::from_value(items_val)
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array"))?;
+
+    let mut items: Vec<ListItem> = Vec::new();
+    for i in 0..items_array.len() {
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let item_val: Value = items_array.entry(index)?;
+        let item = parse_list_item(item_val)?;
+        items.push(item);
+    }
+
+    // Build widget (ignoring selected_index and offset — State is truth)
+    let style_val: Value = node.funcall("style", ())?;
+    let highlight_style_val: Value = node.funcall("highlight_style", ())?;
+    let highlight_symbol_val: Value = node.funcall("highlight_symbol", ())?;
+    let repeat_highlight_symbol_val: Value = node.funcall("repeat_highlight_symbol", ())?;
+    let highlight_spacing_sym: Symbol = node.funcall("highlight_spacing", ())?;
+    let direction_val: Value = node.funcall("direction", ())?;
+    let scroll_padding_val: Value = node.funcall("scroll_padding", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let symbol: String = if highlight_symbol_val.is_nil() {
+        String::new()
+    } else {
+        String::try_convert(highlight_symbol_val)?
+    };
+
+    let mut list = List::new(items);
+
+    let highlight_spacing = match highlight_spacing_sym.to_string().as_str() {
+        "always" => HighlightSpacing::Always,
+        "never" => HighlightSpacing::Never,
+        _ => HighlightSpacing::WhenSelected,
+    };
+    list = list.highlight_spacing(highlight_spacing);
+
+    if !highlight_symbol_val.is_nil() {
+        list = list.highlight_symbol(Line::from(symbol));
+    }
+
+    if !repeat_highlight_symbol_val.is_nil() {
+        let repeat: bool = TryConvert::try_convert(repeat_highlight_symbol_val)?;
+        list = list.repeat_highlight_symbol(repeat);
+    }
+
+    if !direction_val.is_nil() {
+        let direction_sym: magnus::Symbol = TryConvert::try_convert(direction_val)?;
+        let direction_str = direction_sym.name().unwrap();
+        match direction_str.as_ref() {
+            "top_to_bottom" => list = list.direction(ratatui::widgets::ListDirection::TopToBottom),
+            "bottom_to_top" => list = list.direction(ratatui::widgets::ListDirection::BottomToTop),
+            _ => {
+                return Err(Error::new(
+                    ruby.exception_arg_error(),
+                    "direction must be :top_to_bottom or :bottom_to_top",
+                ))
+            }
+        }
+    }
+
+    if !scroll_padding_val.is_nil() {
+        let padding: usize = TryConvert::try_convert(scroll_padding_val)?;
+        list = list.scroll_padding(padding);
+    }
+
+    if !style_val.is_nil() {
+        list = list.style(parse_style(style_val)?);
+    }
+
+    if !highlight_style_val.is_nil() {
+        list = list.highlight_style(parse_style(highlight_style_val)?);
+    }
+
+    if !block_val.is_nil() {
+        list = list.block(parse_block(block_val, &bump)?);
+    }
+
+    // Borrow the inner ListState, render, and release the borrow immediately
+    {
+        let mut inner_state = state.borrow_mut();
+        frame.render_stateful_widget(list, area, &mut inner_state);
+    }
+    // Borrow is now released
+
+    Ok(())
+}
+
+/// Parses a Ruby list item into a ratatui `ListItem`.
+///
+/// Accepts:
+/// - `String`: Plain text item
+/// - `Text::Span`: A single styled fragment
+/// - `Text::Line`: A line composed of multiple spans
+/// - `RatatuiRuby::ListItem`: A `ListItem` object with content and optional style
+fn parse_list_item(value: Value) -> Result<ListItem<'static>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+
+    // Check if it's a RatatuiRuby::ListItem
+    if let Ok(class_obj) = value.funcall::<_, _, Value>("class", ()) {
+        if let Ok(class_name) = class_obj.funcall::<_, _, String>("name", ()) {
+            if class_name.contains("ListItem") {
+                // Extract content and style from the ListItem
+                let content_val: Value = value.funcall("content", ())?;
+                let style_val: Value = value.funcall("style", ())?;
+
+                // Parse content as a Line
+                let line = if let Ok(s) = String::try_convert(content_val) {
+                    Line::from(s)
+                } else if let Ok(line) = parse_line(content_val) {
+                    line
+                } else if let Ok(span) = parse_span(content_val) {
+                    Line::from(vec![span])
+                } else {
+                    Line::from("")
+                };
+
+                // Parse and apply style if present
+                let mut item = ListItem::new(line);
+                if !style_val.is_nil() {
+                    item = item.style(parse_style(style_val)?);
+                }
+                return Ok(item);
+            }
+        }
+    }
+
+    // Try as String
+    if let Ok(s) = String::try_convert(value) {
+        return Ok(ListItem::new(Line::from(s)));
+    }
+
+    // Try as Line
+    if let Ok(line) = parse_line(value) {
+        return Ok(ListItem::new(line));
+    }
+
+    // Try as Span
+    if let Ok(span) = parse_span(value) {
+        return Ok(ListItem::new(Line::from(vec![span])));
+    }
+
+    // Fallback
+    Err(Error::new(
+        ruby.exception_type_error(),
+        "expected String, Text::Span, Text::Line, or ListItem",
+    ))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -142,21 +319,41 @@ mod tests {
     fn test_repeat_highlight_symbol() {
         let items = vec!["Item 1", "Item 2"];
         let list_without_repeat = List::new(items.clone()).highlight_symbol(Line::from(">> "));
-        let list_with_repeat = List::new(items).highlight_symbol(Line::from(">> ")).repeat_highlight_symbol(true);
-        
+        let list_with_repeat = List::new(items)
+            .highlight_symbol(Line::from(">> "))
+            .repeat_highlight_symbol(true);
+
         let mut state = ListState::default();
         state.select(Some(0));
 
         let mut buf1 = Buffer::empty(Rect::new(0, 0, 10, 2));
         use ratatui::widgets::StatefulWidget;
-        StatefulWidget::render(list_without_repeat, Rect::new(0, 0, 10, 2), &mut buf1, &mut state);
+        StatefulWidget::render(
+            list_without_repeat,
+            Rect::new(0, 0, 10, 2),
+            &mut buf1,
+            &mut state,
+        );
 
         let mut buf2 = Buffer::empty(Rect::new(0, 0, 10, 2));
-        StatefulWidget::render(list_with_repeat, Rect::new(0, 0, 10, 2), &mut buf2, &mut state);
+        StatefulWidget::render(
+            list_with_repeat,
+            Rect::new(0, 0, 10, 2),
+            &mut buf2,
+            &mut state,
+        );
 
         // Both should render, but the behavior might differ based on content width
-        let content1 = buf1.content().iter().map(|c| c.symbol()).collect::<String>();
-        let content2 = buf2.content().iter().map(|c| c.symbol()).collect::<String>();
+        let content1 = buf1
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+        let content2 = buf2
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
         assert!(!content1.is_empty());
         assert!(!content2.is_empty());
     }
@@ -164,8 +361,10 @@ mod tests {
     #[test]
     fn test_scroll_padding() {
         let items = vec!["Item 1", "Item 2", "Item 3", "Item 4"];
-        let list = List::new(items).scroll_padding(1).highlight_symbol(Line::from(">> "));
-        
+        let list = List::new(items)
+            .scroll_padding(1)
+            .highlight_symbol(Line::from(">> "));
+
         let mut state = ListState::default();
         state.select(Some(1));
 

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

@@ -0,0 +1,137 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! `ListState` wrapper for exposing Ratatui's `ListState` to Ruby.
+//!
+//! This module provides `RubyListState`, a Magnus-wrapped struct that holds
+//! a `RefCell<ListState>` for interior mutability during stateful rendering.
+//!
+//! # Design
+//!
+//! When using `render_stateful_widget`, the State object is the single source
+//! of truth for selection and offset. Widget properties (`selected_index`, `offset`)
+//! are ignored in stateful mode.
+//!
+//! # Safety
+//!
+//! The `RefCell` is borrowed only during the `render_stateful_widget` call.
+//! The borrow is released immediately after to avoid double-borrow panics
+//! if a user inspects state inside a custom widget's render method.
+
+use magnus::{function, method, prelude::*, Error, Module, Ruby};
+use ratatui::widgets::ListState;
+use std::cell::RefCell;
+
+/// A wrapper around Ratatui's `ListState` exposed to Ruby.
+///
+/// This struct uses `RefCell` for interior mutability, allowing the state
+/// to be updated during rendering while remaining accessible from Ruby.
+#[magnus::wrap(class = "RatatuiRuby::ListState")]
+pub struct RubyListState {
+    inner: RefCell<ListState>,
+}
+
+impl RubyListState {
+    /// Creates a new `RubyListState` with optional initial selection.
+    ///
+    /// # Arguments
+    ///
+    /// * `selected` - Optional initial selection index
+    pub fn new(selected: Option<usize>) -> Self {
+        let mut state = ListState::default();
+        if let Some(idx) = selected {
+            state.select(Some(idx));
+        }
+        Self {
+            inner: RefCell::new(state),
+        }
+    }
+
+    /// Sets the selected index.
+    ///
+    /// Pass `nil` to deselect.
+    pub fn select(&self, index: Option<usize>) {
+        self.inner.borrow_mut().select(index);
+    }
+
+    /// Returns the currently selected index, or `nil` if nothing is selected.
+    pub fn selected(&self) -> Option<usize> {
+        self.inner.borrow().selected()
+    }
+
+    /// Returns the current scroll offset.
+    ///
+    /// This is the critical read-back method. After `render_stateful_widget`,
+    /// this returns the scroll position calculated by Ratatui to keep the
+    /// selection visible.
+    pub fn offset(&self) -> usize {
+        self.inner.borrow().offset()
+    }
+
+    /// Scrolls down by the given number of items.
+    pub fn scroll_down_by(&self, amount: u16) {
+        self.inner.borrow_mut().scroll_down_by(amount);
+    }
+
+    /// Scrolls up by the given number of items.
+    pub fn scroll_up_by(&self, amount: u16) {
+        self.inner.borrow_mut().scroll_up_by(amount);
+    }
+
+    /// Borrows the inner `ListState` mutably for rendering.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure the borrow is released before returning
+    /// control to Ruby to avoid double-borrow panics.
+    pub fn borrow_mut(&self) -> std::cell::RefMut<'_, ListState> {
+        self.inner.borrow_mut()
+    }
+}
+
+/// Registers the `ListState` class with Ruby.
+pub fn register(ruby: &Ruby, module: magnus::RModule) -> Result<(), Error> {
+    let class = module.define_class("ListState", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RubyListState::new, 1))?;
+    class.define_method("select", method!(RubyListState::select, 1))?;
+    class.define_method("selected", method!(RubyListState::selected, 0))?;
+    class.define_method("offset", method!(RubyListState::offset, 0))?;
+    class.define_method("scroll_down_by", method!(RubyListState::scroll_down_by, 1))?;
+    class.define_method("scroll_up_by", method!(RubyListState::scroll_up_by, 1))?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_new_with_no_selection() {
+        let state = RubyListState::new(None);
+        assert_eq!(state.selected(), None);
+        assert_eq!(state.offset(), 0);
+    }
+
+    #[test]
+    fn test_new_with_selection() {
+        let state = RubyListState::new(Some(5));
+        assert_eq!(state.selected(), Some(5));
+    }
+
+    #[test]
+    fn test_select_and_deselect() {
+        let state = RubyListState::new(None);
+        state.select(Some(3));
+        assert_eq!(state.selected(), Some(3));
+        state.select(None);
+        assert_eq!(state.selected(), None);
+    }
+
+    #[test]
+    fn test_scroll_operations() {
+        let state = RubyListState::new(None);
+        state.scroll_down_by(5);
+        // Note: scroll operations affect offset, but the exact behavior
+        // depends on the list size which is determined during rendering
+    }
+}

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

@@ -13,11 +13,14 @@ pub mod gauge;
 pub mod layout;
 pub mod line_gauge;
 pub mod list;
+pub mod list_state;
 pub mod overlay;
 pub mod paragraph;
 pub mod ratatui_logo;
 pub mod ratatui_mascot;
 pub mod scrollbar;
+pub mod scrollbar_state;
 pub mod sparkline;
 pub mod table;
+pub mod table_state;
 pub mod tabs;

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

@@ -12,7 +12,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for layers"))?;
 
     for i in 0..layers_array.len() {
-        let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+        let index = isize::try_from(i)
+            .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
         let layer: Value = layers_array.entry(index)?;
         if let Err(e) = render_node(frame, area, layer) {
             eprintln!("Error rendering overlay layer {i}: {e:?}");

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

@@ -12,7 +12,7 @@ use ratatui::{
 
 use crate::text::parse_text;
 
-fn create_paragraph<'a>(node: Value, bump: &'a Bump) -> Result<Paragraph<'a>, Error> {
+fn create_paragraph(node: Value, bump: &Bump) -> Result<Paragraph<'_>, Error> {
     let text_val: Value = node.funcall("text", ())?;
     let style_val: Value = node.funcall("style", ())?;
     let block_val: Value = node.funcall("block", ())?;

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

@@ -1,27 +1,38 @@
-use magnus::{Error, Value};
-use ratatui::{layout::Rect, widgets::{RatatuiLogo, RatatuiLogoSize}, Frame};
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
 
-pub fn render(frame: &mut Frame, area: Rect, _node: Value) -> Result<(), Error> {
+use magnus::Value;
+use ratatui::{
+    layout::Rect,
+    widgets::{RatatuiLogo, RatatuiLogoSize},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, 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);
     frame.render_widget(widget, area);
-    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
-    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
     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>();
-        
+
+        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

@@ -1,11 +1,11 @@
+// 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::{
-    layout::Rect,
-    widgets::RatatuiMascot,
-    Frame,
-};
+use ratatui::{layout::Rect, widgets::RatatuiMascot, Frame};
 
 pub fn render_ratatui_mascot(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let block_val: Value = node.funcall("block", ())?;
@@ -26,19 +26,26 @@ pub fn render_ratatui_mascot(frame: &mut Frame, area: Rect, node: Value) -> Resu
 
 #[cfg(test)]
 mod tests {
-    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
     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>();
-        
+
+        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.contains("█"),
+            "Mascot rendering should contain block characters"
+        );
         assert!(!content.trim().is_empty());
     }
 }

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

@@ -2,8 +2,9 @@
 // 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, Value};
+use magnus::{prelude::*, Error, Symbol, TryConvert, Value};
 use ratatui::{
     layout::Rect,
     widgets::{Scrollbar, ScrollbarOrientation, ScrollbarState},
@@ -14,7 +15,7 @@ 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_val: Value = node.funcall("thumb_symbol", ())?;
     let thumb_style_val: Value = node.funcall("thumb_style", ())?;
     let track_symbol_val: Value = node.funcall("track_symbol", ())?;
@@ -32,7 +33,9 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     scrollbar = match orientation_sym.to_string().as_str() {
         "vertical_left" => scrollbar.orientation(ScrollbarOrientation::VerticalLeft),
-        "horizontal_bottom" | "horizontal" => scrollbar.orientation(ScrollbarOrientation::HorizontalBottom),
+        "horizontal_bottom" | "horizontal" => {
+            scrollbar.orientation(ScrollbarOrientation::HorizontalBottom)
+        }
         "horizontal_top" => scrollbar.orientation(ScrollbarOrientation::HorizontalTop),
         _ => scrollbar.orientation(ScrollbarOrientation::VerticalRight),
     };
@@ -87,6 +90,97 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     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(
+    frame: &mut Frame,
+    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() {
+            frame.render_stateful_widget(scrollbar, area, &mut inner_state);
+        } else {
+            let bump = Bump::new();
+            let block = parse_block(block_val, &bump)?;
+            let inner_area = block.inner(area);
+            frame.render_widget(block, area);
+            frame.render_stateful_widget(scrollbar, inner_area, &mut inner_state);
+        }
+    }
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;