ratatui_ruby 0.1.0

data/ext/ratatui_ruby/src/terminal.rs

@@ -0,0 +1,131 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::Error;
+use ratatui::{
+    backend::{CrosstermBackend, TestBackend},
+    Terminal,
+};
+use std::io;
+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
+}
+
+lazy_static::lazy_static! {
+    pub static ref TERMINAL: Mutex<Option<TerminalWrapper>> = Mutex::new(None);
+}
+
+pub fn init_terminal() -> Result<(), Error> {
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if term_lock.is_none() {
+        crossterm::terminal::enable_raw_mode()
+            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        let mut stdout = io::stdout();
+        crossterm::execute!(
+            stdout,
+            crossterm::terminal::EnterAlternateScreen,
+            crossterm::event::EnableMouseCapture
+        )
+        .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        let backend = CrosstermBackend::new(stdout);
+        let terminal = Terminal::new(backend)
+            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        *term_lock = Some(TerminalWrapper::Crossterm(terminal));
+    }
+    Ok(())
+}
+
+pub fn init_test_terminal(width: u16, height: u16) -> Result<(), Error> {
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if term_lock.is_none() {
+        let backend = TestBackend::new(width, height);
+        let terminal = Terminal::new(backend)
+            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        *term_lock = Some(TerminalWrapper::Test(terminal));
+    }
+    Ok(())
+}
+
+pub fn restore_terminal() -> Result<(), Error> {
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if let Some(TerminalWrapper::Crossterm(mut terminal)) = term_lock.take() {
+        let _ = crossterm::terminal::disable_raw_mode();
+        let _ = crossterm::execute!(
+            terminal.backend_mut(),
+            crossterm::terminal::LeaveAlternateScreen,
+            crossterm::event::DisableMouseCapture
+        );
+    }
+    Ok(())
+}
+
+pub fn get_buffer_content() -> Result<String, Error> {
+    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 {
+            for x in 0..area.width {
+                let cell = buffer.get(x, y);
+                result.push_str(cell.symbol());
+            }
+            result.push('\n');
+        }
+        Ok(result)
+    } else {
+        Err(Error::new(
+            magnus::exception::runtime_error(),
+            "Terminal is not initialized as TestBackend",
+        ))
+    }
+}
+
+pub fn get_cursor_position() -> Result<Option<(u16, u16)>, Error> {
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if let Some(TerminalWrapper::Test(terminal)) = term_lock.as_mut() {
+        let pos = terminal
+            .get_cursor()
+            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        Ok(Some(pos))
+    } else {
+        Err(Error::new(
+            magnus::exception::runtime_error(),
+            "Terminal is not initialized as TestBackend",
+        ))
+    }
+}
+
+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::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(
+                        magnus::exception::runtime_error(),
+                        e.to_string(),
+                    ));
+                }
+            }
+        }
+    }
+    Ok(())
+}

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

@@ -0,0 +1,73 @@
+// 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};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let data_val: magnus::RHash = node.funcall("data", ())?;
+    let bar_width: u16 = node.funcall("bar_width", ())?;
+    let bar_gap: u16 = node.funcall("bar_gap", ())?;
+    let max_val: Value = node.funcall("max", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    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 mut bar_chart = BarChart::default()
+        .data(&chart_data)
+        .bar_width(bar_width)
+        .bar_gap(bar_gap);
+
+    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)?);
+    }
+
+    frame.render_widget(bar_chart, area);
+    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,12 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::parse_block;
+use magnus::{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());
+    Ok(())
+}

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

@@ -0,0 +1,146 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_block, parse_color};
+use magnus::{prelude::*, Error, RArray, Symbol, Value};
+use ratatui::{
+    symbols::Marker,
+    widgets::canvas::{Canvas, Circle, Line, Map, MapResolution, Rectangle},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: ratatui::layout::Rect, node: Value) -> Result<(), Error> {
+    let shapes_val: RArray = node.funcall("shapes", ())?;
+    let x_bounds_val: RArray = node.funcall("x_bounds", ())?;
+    let y_bounds_val: RArray = node.funcall("y_bounds", ())?;
+    let marker_sym: Symbol = node.funcall("marker", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let x_bounds: [f64; 2] = [x_bounds_val.entry::<f64>(0)?, x_bounds_val.entry::<f64>(1)?];
+    let y_bounds: [f64; 2] = [y_bounds_val.entry::<f64>(0)?, y_bounds_val.entry::<f64>(1)?];
+
+    let marker = match marker_sym.to_string().as_str() {
+        "dot" => Marker::Dot,
+        "block" => Marker::Block,
+        "bar" => Marker::Bar,
+        _ => Marker::Braille,
+    };
+
+    let mut canvas = Canvas::default()
+        .x_bounds(x_bounds)
+        .y_bounds(y_bounds)
+        .marker(marker);
+
+    if !block_val.is_nil() {
+        canvas = canvas.block(parse_block(block_val)?);
+    }
+
+    let canvas = canvas.paint(|ctx| {
+        for shape_val in shapes_val.each() {
+            let shape_val = shape_val.unwrap();
+            let class = shape_val.class();
+            let class_name = unsafe { class.name() };
+
+            match class_name.as_ref() {
+                "RatatuiRuby::Line" => {
+                    let x1: f64 = shape_val.funcall("x1", ()).unwrap_or(0.0);
+                    let y1: f64 = shape_val.funcall("y1", ()).unwrap_or(0.0);
+                    let x2: f64 = shape_val.funcall("x2", ()).unwrap_or(0.0);
+                    let y2: f64 = shape_val.funcall("y2", ()).unwrap_or(0.0);
+                    let color_val: Value = shape_val.funcall("color", ()).unwrap();
+                    let color =
+                        parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
+                    ctx.draw(&Line {
+                        x1,
+                        y1,
+                        x2,
+                        y2,
+                        color,
+                    });
+                }
+                "RatatuiRuby::Rectangle" => {
+                    let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
+                    let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
+                    let width: f64 = shape_val.funcall("width", ()).unwrap_or(0.0);
+                    let height: f64 = shape_val.funcall("height", ()).unwrap_or(0.0);
+                    let color_val: Value = shape_val.funcall("color", ()).unwrap();
+                    let color =
+                        parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
+                    ctx.draw(&Rectangle {
+                        x,
+                        y,
+                        width,
+                        height,
+                        color,
+                    });
+                }
+                "RatatuiRuby::Circle" => {
+                    let x: f64 = shape_val.funcall("x", ()).unwrap_or(0.0);
+                    let y: f64 = shape_val.funcall("y", ()).unwrap_or(0.0);
+                    let radius: f64 = shape_val.funcall("radius", ()).unwrap_or(0.0);
+                    let color_val: Value = shape_val.funcall("color", ()).unwrap();
+                    let color =
+                        parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
+                    ctx.draw(&Circle {
+                        x,
+                        y,
+                        radius,
+                        color,
+                    });
+                }
+                "RatatuiRuby::Map" => {
+                    let color_val: Value = shape_val.funcall("color", ()).unwrap();
+                    let color =
+                        parse_color(&color_val.to_string()).unwrap_or(ratatui::style::Color::Reset);
+                    let resolution_sym: Symbol = shape_val.funcall("resolution", ()).unwrap();
+                    let resolution = match resolution_sym.to_string().as_str() {
+                        "high" => MapResolution::High,
+                        _ => MapResolution::Low,
+                    };
+                    ctx.draw(&Map { color, resolution });
+                }
+                _ => {}
+            }
+        }
+    });
+
+    frame.render_widget(canvas, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::layout::Rect;
+    use ratatui::widgets::Widget;
+
+    #[test]
+    fn test_canvas_rendering() {
+        let canvas = Canvas::default()
+            .x_bounds([0.0, 10.0])
+            .y_bounds([0.0, 10.0])
+            .marker(Marker::Braille)
+            .paint(|ctx| {
+                ctx.draw(&Line {
+                    x1: 0.0,
+                    y1: 0.0,
+                    x2: 10.0,
+                    y2: 10.0,
+                    color: ratatui::style::Color::Red,
+                });
+            });
+        let mut buf = Buffer::empty(Rect::new(0, 0, 5, 5));
+        canvas.render(Rect::new(0, 0, 5, 5), &mut buf);
+
+        // Verify that some Braille characters are rendered
+        let mut found_braille = false;
+        for cell in buf.content() {
+            if !cell.symbol().trim().is_empty() {
+                found_braille = true;
+                break;
+            }
+        }
+        assert!(found_braille, "Canvas should render Braille characters");
+    }
+}

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

@@ -0,0 +1,81 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::rendering::render_node;
+use magnus::{prelude::*, Error, Value};
+use ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    widgets::Clear,
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let child: Value = node.funcall("child", ())?;
+    let width_percent: u16 = node.funcall("width_percent", ())?;
+    let height_percent: u16 = node.funcall("height_percent", ())?;
+
+    let popup_layout = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Percentage((100 - height_percent) / 2),
+            Constraint::Percentage(height_percent),
+            Constraint::Percentage((100 - height_percent) / 2),
+        ])
+        .split(area);
+
+    let vertical_center_area = popup_layout[1];
+
+    let popup_layout_horizontal = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([
+            Constraint::Percentage((100 - width_percent) / 2),
+            Constraint::Percentage(width_percent),
+            Constraint::Percentage((100 - width_percent) / 2),
+        ])
+        .split(vertical_center_area);
+
+    let center_area = popup_layout_horizontal[1];
+
+    frame.render_widget(Clear, center_area);
+    render_node(frame, center_area, child)?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+
+    use ratatui::layout::{Constraint, Direction, Layout, Rect};
+
+    #[test]
+    fn test_center_logic() {
+        let area = Rect::new(0, 0, 100, 100);
+        let width_percent = 50;
+        let height_percent = 50;
+
+        let popup_layout = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Percentage((100 - height_percent) / 2),
+                Constraint::Percentage(height_percent),
+                Constraint::Percentage((100 - height_percent) / 2),
+            ])
+            .split(area);
+        let vertical_center = popup_layout[1];
+
+        // Vertical check
+        assert_eq!(vertical_center.height, 50);
+
+        let popup_layout_horizontal = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([
+                Constraint::Percentage((100 - width_percent) / 2),
+                Constraint::Percentage(width_percent),
+                Constraint::Percentage((100 - width_percent) / 2),
+            ])
+            .split(vertical_center);
+        let center = popup_layout_horizontal[1];
+
+        // Horizontal check
+        assert_eq!(center.width, 50);
+    }
+}

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

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::{prelude::*, Error, Value};
+use ratatui::{layout::Rect, Frame};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let x: u16 = node.funcall("x", ())?;
+    let y: u16 = node.funcall("y", ())?;
+    frame.set_cursor(area.x + x, area.y + y);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+
+    use ratatui::layout::Rect;
+
+    #[test]
+    fn test_cursor_math() {
+        let area = Rect::new(10, 10, 50, 50);
+        let x = 5;
+        let y = 5;
+        let abs_x = area.x + x;
+        let abs_y = area.y + y;
+        assert_eq!(abs_x, 15);
+        assert_eq!(abs_y, 15);
+    }
+}

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

@@ -0,0 +1,50 @@
+// 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::Gauge, Frame};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let ratio: f64 = node.funcall("ratio", ())?;
+    let label_val: Value = node.funcall("label", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut gauge = Gauge::default().ratio(ratio);
+
+    if !label_val.is_nil() {
+        let label_str: String = label_val.funcall("to_s", ())?;
+        gauge = gauge.label(label_str);
+    }
+
+    if !style_val.is_nil() {
+        gauge = gauge.gauge_style(parse_style(style_val)?);
+    }
+
+    if !block_val.is_nil() {
+        gauge = gauge.block(parse_block(block_val)?);
+    }
+
+    frame.render_widget(gauge, area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::buffer::Buffer;
+    use ratatui::widgets::{Gauge, Widget};
+
+    #[test]
+    fn test_gauge_rendering() {
+        let gauge = Gauge::default().ratio(0.5).label("50%");
+        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 1));
+        gauge.render(Rect::new(0, 0, 10, 1), &mut buf);
+        // Gauge renders block characters
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+        // Should contain label
+        assert!(buf.content().iter().any(|c| c.symbol() == "5"));
+        assert!(buf.content().iter().any(|c| c.symbol() == "%"));
+    }
+}

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

@@ -0,0 +1,82 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::rendering::render_node;
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::{
+    layout::{Constraint, Direction, Layout, Rect},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let direction_sym: Symbol = node.funcall("direction", ())?;
+    let children_val: Value = node.funcall("children", ())?;
+    let children_array = magnus::RArray::from_value(children_val)
+        .ok_or_else(|| Error::new(magnus::exception::type_error(), "expected array"))?;
+
+    let constraints_val: Value = node.funcall("constraints", ())?;
+    let constraints_array = magnus::RArray::from_value(constraints_val);
+
+    let direction = if direction_sym.to_string() == "vertical" {
+        Direction::Vertical
+    } else {
+        Direction::Horizontal
+    };
+
+    let len = children_array.len();
+    if len > 0 {
+        let mut ratatui_constraints = Vec::new();
+
+        if let Some(arr) = constraints_array {
+            for i in 0..arr.len() {
+                let constraint_obj: Value = arr.entry(i as isize)?;
+                let type_sym: Symbol = constraint_obj.funcall("type", ())?;
+                let value: u16 = constraint_obj.funcall("value", ())?;
+
+                match type_sym.to_string().as_str() {
+                    "length" => ratatui_constraints.push(Constraint::Length(value)),
+                    "percentage" => ratatui_constraints.push(Constraint::Percentage(value)),
+                    "min" => ratatui_constraints.push(Constraint::Min(value)),
+                    _ => {}
+                }
+            }
+        }
+
+        // If constraints don't match children, adjust or default
+        if ratatui_constraints.len() != len {
+            ratatui_constraints = (0..len)
+                .map(|_| Constraint::Percentage(100 / (len as u16).max(1)))
+                .collect();
+        }
+
+        let chunks = Layout::default()
+            .direction(direction)
+            .constraints(ratatui_constraints)
+            .split(area);
+
+        for i in 0..len {
+            let child: Value = children_array.entry(i as isize)?;
+            if let Err(e) = render_node(frame, chunks[i], child) {
+                eprintln!("Error rendering child {}: {:?}", i, e);
+            }
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+
+    use ratatui::layout::{Constraint, Direction, Layout, Rect};
+
+    #[test]
+    fn test_layout_logic() {
+        let area = Rect::new(0, 0, 100, 100);
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
+            .split(area);
+        assert_eq!(chunks.len(), 2);
+        assert_eq!(chunks[0].height, 50);
+    }
+}