ratatui_ruby 0.3.1 → 0.5.0

data/ext/ratatui_ruby/src/terminal.rs

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use magnus::value::ReprValue;
 use magnus::Error;
 use ratatui::{
     backend::{CrosstermBackend, TestBackend},
@@ -11,14 +12,12 @@ use std::sync::Mutex;
 
 pub enum TerminalWrapper {
     Crossterm(Terminal<CrosstermBackend<io::Stdout>>),
-    Test(Terminal<TestBackend>), // We don't need Mutex inside the enum variant because the global is a Mutex
+    Test(Terminal<TestBackend>),
 }
 
-lazy_static::lazy_static! {
-    pub static ref TERMINAL: Mutex<Option<TerminalWrapper>> = Mutex::new(None);
-}
+pub static TERMINAL: Mutex<Option<TerminalWrapper>> = Mutex::new(None);
 
-pub fn init_terminal() -> Result<(), Error> {
+pub fn init_terminal(focus_events: bool, bracketed_paste: bool) -> Result<(), Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let mut term_lock = TERMINAL.lock().unwrap();
     if term_lock.is_none() {
@@ -31,6 +30,16 @@ pub fn init_terminal() -> Result<(), Error> {
             ratatui::crossterm::event::EnableMouseCapture
         )
         .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+
+        if focus_events {
+            ratatui::crossterm::execute!(stdout, ratatui::crossterm::event::EnableFocusChange)
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+        }
+        if bracketed_paste {
+            ratatui::crossterm::execute!(stdout, ratatui::crossterm::event::EnableBracketedPaste)
+                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+        }
+
         let backend = CrosstermBackend::new(stdout);
         let terminal = Terminal::new(backend)
             .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
@@ -49,30 +58,30 @@ pub fn init_test_terminal(width: u16, height: u16) -> Result<(), Error> {
     Ok(())
 }
 
-pub fn restore_terminal() -> Result<(), Error> {
+pub fn restore_terminal() {
     let mut term_lock = TERMINAL.lock().unwrap();
-    if let Some(TerminalWrapper::Crossterm(mut terminal)) = term_lock.take() {
-        let _ = ratatui::crossterm::terminal::disable_raw_mode();
-        let _ = ratatui::crossterm::execute!(
-            terminal.backend_mut(),
-            ratatui::crossterm::terminal::LeaveAlternateScreen,
-            ratatui::crossterm::event::DisableMouseCapture
-        );
+    if let Some(wrapper) = term_lock.take() {
+        match wrapper {
+            TerminalWrapper::Crossterm(mut t) => {
+                let _ = ratatui::crossterm::terminal::disable_raw_mode();
+                let _ = ratatui::crossterm::execute!(
+                    t.backend_mut(),
+                    ratatui::crossterm::terminal::LeaveAlternateScreen,
+                    ratatui::crossterm::event::DisableMouseCapture,
+                    ratatui::crossterm::event::DisableFocusChange,
+                    ratatui::crossterm::event::DisableBracketedPaste
+                );
+            }
+            TerminalWrapper::Test(_) => {}
+        }
     }
-    Ok(())
 }
 
 pub fn get_buffer_content() -> Result<String, Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let term_lock = TERMINAL.lock().unwrap();
     if let Some(TerminalWrapper::Test(terminal)) = term_lock.as_ref() {
-        // We need to access the buffer.
-        // Since we are mocking, we can just print the buffer to a string.
         let buffer = terminal.backend().buffer();
-        // Simple representation: each cell's symbol.
-        // For a more complex representation we could return an array of strings.
-        // Let's just return the full string representation for now which is useful for debugging/asserting.
-        // Actually, let's reconstruct it line by line.
         let area = buffer.area;
         let mut result = String::new();
         for y in 0..area.height {
@@ -112,23 +121,104 @@ pub fn resize_terminal(width: u16, height: u16) -> Result<(), Error> {
     let mut term_lock = TERMINAL.lock().unwrap();
     if let Some(wrapper) = term_lock.as_mut() {
         match wrapper {
-            TerminalWrapper::Crossterm(_) => {
-                // Resize happens automatically for Crossterm via signals usually,
-                // but we can't easily force it here without OS interaction.
-                // Ignoring for now as it's less critical for unit testing the logic.
-            }
+            TerminalWrapper::Crossterm(_) => {}
             TerminalWrapper::Test(terminal) => {
                 terminal.backend_mut().resize(width, height);
-                // Also resize the terminal wrapper itself if needed, but TestBackend resize handles the buffer.
-                // We might need to call terminal.resize() too if Ratatui caches the size.
                 if let Err(e) = terminal.resize(ratatui::layout::Rect::new(0, 0, width, height)) {
-                    return Err(Error::new(
-                        ruby.exception_runtime_error(),
-                        e.to_string(),
-                    ));
+                    return Err(Error::new(ruby.exception_runtime_error(), e.to_string()));
                 }
             }
         }
     }
     Ok(())
 }
+
+use magnus::Value;
+
+pub fn get_cell_at(x: u16, y: u16) -> Result<magnus::RHash, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let term_lock = TERMINAL.lock().unwrap();
+    if let Some(TerminalWrapper::Test(terminal)) = term_lock.as_ref() {
+        let buffer = terminal.backend().buffer();
+        if let Some(cell) = buffer.cell((x, y)) {
+            let hash = ruby.hash_new();
+            hash.aset("char", cell.symbol())?;
+            hash.aset("fg", color_to_value(cell.fg))?;
+            hash.aset("bg", color_to_value(cell.bg))?;
+            hash.aset("modifiers", modifiers_to_value(cell.modifier))?;
+            Ok(hash)
+        } else {
+            Err(Error::new(
+                ruby.exception_runtime_error(),
+                format!("Coordinates ({x}, {y}) out of bounds"),
+            ))
+        }
+    } else {
+        Err(Error::new(
+            ruby.exception_runtime_error(),
+            "Terminal is not initialized as TestBackend",
+        ))
+    }
+}
+
+fn color_to_value(color: ratatui::style::Color) -> Value {
+    let ruby = magnus::Ruby::get().unwrap();
+    match color {
+        ratatui::style::Color::Reset => ruby.qnil().as_value(),
+        ratatui::style::Color::Black => ruby.to_symbol("black").as_value(),
+        ratatui::style::Color::Red => ruby.to_symbol("red").as_value(),
+        ratatui::style::Color::Green => ruby.to_symbol("green").as_value(),
+        ratatui::style::Color::Yellow => ruby.to_symbol("yellow").as_value(),
+        ratatui::style::Color::Blue => ruby.to_symbol("blue").as_value(),
+        ratatui::style::Color::Magenta => ruby.to_symbol("magenta").as_value(),
+        ratatui::style::Color::Cyan => ruby.to_symbol("cyan").as_value(),
+        ratatui::style::Color::Gray => ruby.to_symbol("gray").as_value(),
+        ratatui::style::Color::DarkGray => ruby.to_symbol("dark_gray").as_value(),
+        ratatui::style::Color::LightRed => ruby.to_symbol("light_red").as_value(),
+        ratatui::style::Color::LightGreen => ruby.to_symbol("light_green").as_value(),
+        ratatui::style::Color::LightYellow => ruby.to_symbol("light_yellow").as_value(),
+        ratatui::style::Color::LightBlue => ruby.to_symbol("light_blue").as_value(),
+        ratatui::style::Color::LightMagenta => ruby.to_symbol("light_magenta").as_value(),
+        ratatui::style::Color::LightCyan => ruby.to_symbol("light_cyan").as_value(),
+        ratatui::style::Color::White => ruby.to_symbol("white").as_value(),
+        ratatui::style::Color::Rgb(r, g, b) => ruby
+            .str_new(&(format!("#{r:02x}{g:02x}{b:02x}")))
+            .as_value(),
+        ratatui::style::Color::Indexed(i) => ruby.to_symbol(format!("indexed_{i}")).as_value(),
+    }
+}
+
+fn modifiers_to_value(modifier: ratatui::style::Modifier) -> Value {
+    let ruby = magnus::Ruby::get().unwrap();
+    let ary = ruby.ary_new();
+
+    if modifier.contains(ratatui::style::Modifier::BOLD) {
+        let _ = ary.push(ruby.str_new("bold"));
+    }
+    if modifier.contains(ratatui::style::Modifier::ITALIC) {
+        let _ = ary.push(ruby.str_new("italic"));
+    }
+    if modifier.contains(ratatui::style::Modifier::DIM) {
+        let _ = ary.push(ruby.str_new("dim"));
+    }
+    if modifier.contains(ratatui::style::Modifier::UNDERLINED) {
+        let _ = ary.push(ruby.str_new("underlined"));
+    }
+    if modifier.contains(ratatui::style::Modifier::REVERSED) {
+        let _ = ary.push(ruby.str_new("reversed"));
+    }
+    if modifier.contains(ratatui::style::Modifier::HIDDEN) {
+        let _ = ary.push(ruby.str_new("hidden"));
+    }
+    if modifier.contains(ratatui::style::Modifier::CROSSED_OUT) {
+        let _ = ary.push(ruby.str_new("crossed_out"));
+    }
+    if modifier.contains(ratatui::style::Modifier::SLOW_BLINK) {
+        let _ = ary.push(ruby.str_new("slow_blink"));
+    }
+    if modifier.contains(ratatui::style::Modifier::RAPID_BLINK) {
+        let _ = ary.push(ruby.str_new("rapid_blink"));
+    }
+
+    ary.as_value()
+}

data/ext/ratatui_ruby/src/text.rs

@@ -0,0 +1,178 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+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(Error::new(
+            ruby.exception_type_error(),
+            "expected String, Text::Span, Text::Line, or Array of Text::Lines/Spans",
+        )),
+    }
+}
+
+/// Parses a Ruby Span object into a ratatui Span.
+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(Error::new(
+            ruby.exception_type_error(),
+            "expected a Text::Span object",
+        ));
+    }
+
+    // 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.
+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", ())?;
+
+    if !class_name.contains("Line") {
+        return Err(Error::new(
+            ruby.exception_type_error(),
+            "expected a Text::Line object",
+        ));
+    }
+
+    // Extract spans from the Ruby Line
+    let spans_val: Value = value.funcall("spans", ())?;
+
+    if spans_val.is_nil() {
+        return Ok(Line::from(""));
+    }
+
+    let spans_array = magnus::RArray::from_value(spans_val).ok_or_else(|| {
+        Error::new(
+            ruby.exception_type_error(),
+            "expected array of Spans in Text::Line.spans",
+        )
+    })?;
+
+    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));
+            }
+        }
+    }
+
+    if spans.is_empty() {
+        Ok(Line::from(""))
+    } else {
+        Ok(Line::from(spans))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_parse_plain_string() {}
+}

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

@@ -1,40 +1,103 @@
 // 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::BarChart, Frame};
+use crate::style::{parse_bar_set, parse_block, parse_style};
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, RArray, Symbol, Value};
+use ratatui::{
+    layout::{Direction, Rect},
+    text::Line,
+    widgets::{Bar, BarChart, BarGroup},
+    Frame,
+};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
-    let data_val: magnus::RHash = node.funcall("data", ())?;
+    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 keys: magnus::RArray = data_val.funcall("keys", ())?;
-    let mut labels = Vec::new();
-    let mut data_vec = Vec::new();
-
-    for i in 0..keys.len() {
-        let key: Value = keys.entry(i as isize)?;
-        let val: u64 = data_val.funcall("[]", (key,))?;
-        let label: String = key.funcall("to_s", ())?;
-        labels.push(label);
-        data_vec.push(val);
-    }
-
-    let chart_data: Vec<(&str, u64)> = labels
-        .iter()
-        .zip(data_vec.iter())
-        .map(|(l, v)| (l.as_str(), *v))
-        .collect();
+    let direction = if direction_sym.to_string() == "horizontal" {
+        Direction::Horizontal
+    } else {
+        Direction::Vertical
+    };
 
     let mut bar_chart = BarChart::default()
-        .data(&chart_data)
         .bar_width(bar_width)
-        .bar_gap(bar_gap);
+        .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 label_str: String = if label_val.is_nil() {
+                String::new()
+            } else {
+                label_val.funcall("to_s", ())?
+            };
+            let label_ref = bump.alloc_str(&label_str) as &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() {
+                    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() {
+                    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 !label_ref.is_empty() {
+                group = group.label(Line::from(label_ref));
+            }
+            bar_chart = bar_chart.data(group);
+        }
+    }
 
     if !max_val.is_nil() {
         let max: u64 = u64::try_convert(max_val)?;
@@ -46,7 +109,19 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     if !block_val.is_nil() {
-        bar_chart = bar_chart.block(parse_block(block_val)?);
+        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)?);
     }
 
     frame.render_widget(bar_chart, area);

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

@@ -1,12 +1,41 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use crate::rendering::render_node;
 use crate::style::parse_block;
-use magnus::{Error, Value};
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, Value};
 use ratatui::{layout::Rect, widgets::Widget, Frame};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
-    let block = parse_block(node)?;
-    block.render(area, frame.buffer_mut());
+    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, frame.buffer_mut());
+
+    // 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(frame, inner, child) {
+                    eprintln!("Error rendering block child {i}: {e:?}");
+                }
+            }
+        }
+    }
+
     Ok(())
 }