ratatui_ruby 0.1.0

data/ext/ratatui_ruby/extconf.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("ratatui_ruby/ratatui_ruby") do |r|
+  # Optional: Force release profile if needed, but defaults are usually good
+  # r.profile = ENV.fetch("RB_SYS_CARGO_PROFILE", :release).to_sym
+end

data/ext/ratatui_ruby/src/events.rs

@@ -0,0 +1,279 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::{Error, IntoValue, Symbol, TryConvert, Value};
+use std::sync::Mutex;
+
+lazy_static::lazy_static! {
+    static ref EVENT_QUEUE: Mutex<Vec<crossterm::event::Event>> = Mutex::new(Vec::new());
+}
+
+pub fn inject_test_event(event_type: String, data: magnus::RHash) -> Result<(), Error> {
+    let event = match event_type.as_str() {
+        "key" => {
+            let code_val: Value = data.get(Symbol::new("code")).ok_or_else(|| {
+                Error::new(
+                    magnus::exception::arg_error(),
+                    "Missing 'code' in key event",
+                )
+            })?;
+            let code_str: String = String::try_convert(code_val)?;
+            let code = match code_str.as_str() {
+                "up" => crossterm::event::KeyCode::Up,
+                "down" => crossterm::event::KeyCode::Down,
+                "left" => crossterm::event::KeyCode::Left,
+                "right" => crossterm::event::KeyCode::Right,
+                "enter" => crossterm::event::KeyCode::Enter,
+                "esc" => crossterm::event::KeyCode::Esc,
+                "backspace" => crossterm::event::KeyCode::Backspace,
+                "tab" => crossterm::event::KeyCode::Tab,
+                c if c.len() == 1 => crossterm::event::KeyCode::Char(c.chars().next().unwrap()),
+                _ => crossterm::event::KeyCode::Null,
+            };
+
+            let mut modifiers = crossterm::event::KeyModifiers::empty();
+            if let Some(mods_val) = data.get(Symbol::new("modifiers")) {
+                let mods: Vec<String> = Vec::try_convert(mods_val)?;
+                for m in mods {
+                    match m.as_str() {
+                        "ctrl" => modifiers |= crossterm::event::KeyModifiers::CONTROL,
+                        "alt" => modifiers |= crossterm::event::KeyModifiers::ALT,
+                        "shift" => modifiers |= crossterm::event::KeyModifiers::SHIFT,
+                        _ => {}
+                    }
+                }
+            }
+
+            crossterm::event::Event::Key(crossterm::event::KeyEvent::new(code, modifiers))
+        }
+        "mouse" => {
+            let kind_val: Value = data.get(Symbol::new("kind")).ok_or_else(|| {
+                Error::new(
+                    magnus::exception::arg_error(),
+                    "Missing 'kind' in mouse event",
+                )
+            })?;
+            let kind_str: String = String::try_convert(kind_val)?;
+
+            let button = if let Some(btn_val) = data.get(Symbol::new("button")) {
+                let button_str: String = String::try_convert(btn_val)?;
+                match button_str.as_str() {
+                    "right" => crossterm::event::MouseButton::Right,
+                    "middle" => crossterm::event::MouseButton::Middle,
+                    _ => crossterm::event::MouseButton::Left,
+                }
+            } else {
+                crossterm::event::MouseButton::Left
+            };
+
+            let x_val: Value = data.get(Symbol::new("x")).ok_or_else(|| {
+                Error::new(magnus::exception::arg_error(), "Missing 'x' in mouse event")
+            })?;
+            let x: u16 = u16::try_convert(x_val)?;
+
+            let y_val: Value = data.get(Symbol::new("y")).ok_or_else(|| {
+                Error::new(magnus::exception::arg_error(), "Missing 'y' in mouse event")
+            })?;
+            let y: u16 = u16::try_convert(y_val)?;
+
+            let kind = match kind_str.as_str() {
+                "down" => crossterm::event::MouseEventKind::Down(button),
+                "up" => crossterm::event::MouseEventKind::Up(button),
+                "drag" => crossterm::event::MouseEventKind::Drag(button),
+                "moved" => crossterm::event::MouseEventKind::Moved,
+                "scroll_down" => crossterm::event::MouseEventKind::ScrollDown,
+                "scroll_up" => crossterm::event::MouseEventKind::ScrollUp,
+                "scroll_left" => crossterm::event::MouseEventKind::ScrollLeft,
+                "scroll_right" => crossterm::event::MouseEventKind::ScrollRight,
+                _ => {
+                    return Err(Error::new(
+                        magnus::exception::arg_error(),
+                        format!("Unknown mouse kind: {}", kind_str),
+                    ))
+                }
+            };
+
+            let mut modifiers = crossterm::event::KeyModifiers::empty();
+            if let Some(mods_val) = data.get(Symbol::new("modifiers")) {
+                let mods: Vec<String> = Vec::try_convert(mods_val)?;
+                for m in mods {
+                    match m.as_str() {
+                        "ctrl" => modifiers |= crossterm::event::KeyModifiers::CONTROL,
+                        "alt" => modifiers |= crossterm::event::KeyModifiers::ALT,
+                        "shift" => modifiers |= crossterm::event::KeyModifiers::SHIFT,
+                        _ => {}
+                    }
+                }
+            }
+
+            crossterm::event::Event::Mouse(crossterm::event::MouseEvent {
+                kind,
+                column: x,
+                row: y,
+                modifiers,
+            })
+        }
+        _ => {
+            return Err(Error::new(
+                magnus::exception::arg_error(),
+                format!("Unknown event type: {}", event_type),
+            ))
+        }
+    };
+
+    EVENT_QUEUE.lock().unwrap().push(event);
+    Ok(())
+}
+
+pub fn poll_event() -> Result<Value, Error> {
+    let event = {
+        let mut queue = EVENT_QUEUE.lock().unwrap();
+        if !queue.is_empty() {
+            Some(queue.remove(0))
+        } else {
+            None
+        }
+    };
+
+    if let Some(e) = event {
+        return handle_event(e);
+    }
+
+    // Check if we are in test mode. If so, don't poll crossterm.
+    let is_test_mode = {
+        let term_lock = crate::terminal::TERMINAL.lock().unwrap();
+        matches!(term_lock.as_ref(), Some(crate::terminal::TerminalWrapper::Test(_)))
+    };
+
+    if is_test_mode {
+        return Ok(magnus::value::qnil().into_value());
+    }
+
+    if crossterm::event::poll(std::time::Duration::from_millis(16))
+        .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?
+    {
+        let event = crossterm::event::read()
+            .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+        handle_event(event)
+    } else {
+        Ok(magnus::value::qnil().into_value())
+    }
+}
+
+fn handle_event(event: crossterm::event::Event) -> Result<Value, Error> {
+    match event {
+        crossterm::event::Event::Key(key) => {
+            if key.kind == crossterm::event::KeyEventKind::Press {
+                let hash = magnus::RHash::new();
+                hash.aset(Symbol::new("type"), Symbol::new("key"))?;
+
+                let code = match key.code {
+                    crossterm::event::KeyCode::Char(c) => c.to_string(),
+                    crossterm::event::KeyCode::Up => "up".to_string(),
+                    crossterm::event::KeyCode::Down => "down".to_string(),
+                    crossterm::event::KeyCode::Left => "left".to_string(),
+                    crossterm::event::KeyCode::Right => "right".to_string(),
+                    crossterm::event::KeyCode::Enter => "enter".to_string(),
+                    crossterm::event::KeyCode::Esc => "esc".to_string(),
+                    crossterm::event::KeyCode::Backspace => "backspace".to_string(),
+                    crossterm::event::KeyCode::Tab => "tab".to_string(),
+                    _ => "unknown".to_string(),
+                };
+                hash.aset(Symbol::new("code"), code)?;
+
+                let mut modifiers = Vec::new();
+                if key
+                    .modifiers
+                    .contains(crossterm::event::KeyModifiers::CONTROL)
+                {
+                    modifiers.push("ctrl");
+                }
+                if key.modifiers.contains(crossterm::event::KeyModifiers::ALT) {
+                    modifiers.push("alt");
+                }
+                if key
+                    .modifiers
+                    .contains(crossterm::event::KeyModifiers::SHIFT)
+                {
+                    modifiers.push("shift");
+                }
+                if !modifiers.is_empty() {
+                    hash.aset(Symbol::new("modifiers"), modifiers)?;
+                }
+
+                return Ok(hash.into_value());
+            }
+        }
+        crossterm::event::Event::Mouse(event) => {
+            let hash = magnus::RHash::new();
+            hash.aset(Symbol::new("type"), Symbol::new("mouse"))?;
+
+            let (kind, button) = match event.kind {
+                crossterm::event::MouseEventKind::Down(btn) => ("down", btn),
+                crossterm::event::MouseEventKind::Up(btn) => ("up", btn),
+                crossterm::event::MouseEventKind::Drag(btn) => ("drag", btn),
+                crossterm::event::MouseEventKind::Moved => {
+                    ("moved", crossterm::event::MouseButton::Left)
+                } // button is ignored for moved
+                crossterm::event::MouseEventKind::ScrollDown => {
+                    ("scroll_down", crossterm::event::MouseButton::Left)
+                } // button is ignored for scroll
+                crossterm::event::MouseEventKind::ScrollUp => {
+                    ("scroll_up", crossterm::event::MouseButton::Left)
+                } // button is ignored for scroll
+                crossterm::event::MouseEventKind::ScrollLeft => {
+                    ("scroll_left", crossterm::event::MouseButton::Left)
+                } // button is ignored for scroll
+                crossterm::event::MouseEventKind::ScrollRight => {
+                    ("scroll_right", crossterm::event::MouseButton::Left)
+                } // button is ignored for scroll
+            };
+
+            hash.aset(Symbol::new("kind"), Symbol::new(kind))?;
+
+            if matches!(
+                event.kind,
+                crossterm::event::MouseEventKind::Down(_)
+                    | crossterm::event::MouseEventKind::Up(_)
+                    | crossterm::event::MouseEventKind::Drag(_)
+            ) {
+                let btn_sym = match button {
+                    crossterm::event::MouseButton::Left => "left",
+                    crossterm::event::MouseButton::Right => "right",
+                    crossterm::event::MouseButton::Middle => "middle",
+                };
+                hash.aset(Symbol::new("button"), Symbol::new(btn_sym))?;
+            } else {
+                hash.aset(Symbol::new("button"), Symbol::new("none"))?;
+            }
+
+            hash.aset(Symbol::new("x"), event.column)?;
+            hash.aset(Symbol::new("y"), event.row)?;
+
+            let mut modifiers = Vec::new();
+            if event
+                .modifiers
+                .contains(crossterm::event::KeyModifiers::CONTROL)
+            {
+                modifiers.push("ctrl");
+            }
+            if event
+                .modifiers
+                .contains(crossterm::event::KeyModifiers::ALT)
+            {
+                modifiers.push("alt");
+            }
+            if event
+                .modifiers
+                .contains(crossterm::event::KeyModifiers::SHIFT)
+            {
+                modifiers.push("shift");
+            }
+            hash.aset(Symbol::new("modifiers"), modifiers)?;
+
+            return Ok(hash.into_value());
+        }
+        _ => {}
+    }
+    Ok(magnus::value::qnil().into_value())
+}

data/ext/ratatui_ruby/src/lib.rs

@@ -0,0 +1,105 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+mod events;
+mod rendering;
+mod style;
+mod terminal;
+mod widgets;
+
+use magnus::{define_module, function, Error, Value};
+use terminal::{init_terminal, restore_terminal, TERMINAL};
+
+fn draw(tree: Value) -> Result<(), Error> {
+    let mut term_lock = TERMINAL.lock().unwrap();
+    if let Some(wrapper) = term_lock.as_mut() {
+        match wrapper {
+            terminal::TerminalWrapper::Crossterm(term) => {
+                term.draw(|f| {
+                    if let Err(e) = rendering::render_node(f, f.size(), tree) {
+                        eprintln!("Render error: {:?}", e);
+                    }
+                })
+                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+            }
+            terminal::TerminalWrapper::Test(term) => {
+                term.draw(|f| {
+                    if let Err(e) = rendering::render_node(f, f.size(), tree) {
+                        eprintln!("Render error: {:?}", e);
+                    }
+                })
+                .map_err(|e| Error::new(magnus::exception::runtime_error(), e.to_string()))?;
+            }
+        }
+    } else {
+        eprintln!("Terminal is None!");
+    }
+    Ok(())
+}
+
+#[magnus::init]
+fn init() -> Result<(), Error> {
+    let m = define_module("RatatuiRuby")?;
+    m.define_module_function("init_terminal", function!(init_terminal, 0))?;
+    m.define_module_function("restore_terminal", function!(restore_terminal, 0))?;
+    m.define_module_function("draw", function!(draw, 1))?;
+    m.define_module_function("poll_event", function!(events::poll_event, 0))?;
+    m.define_module_function("inject_test_event", function!(events::inject_test_event, 2))?;
+
+    // Test backend helpers
+    m.define_module_function(
+        "init_test_terminal",
+        function!(terminal::init_test_terminal, 2),
+    )?;
+    m.define_module_function(
+        "get_buffer_content",
+        function!(terminal::get_buffer_content, 0),
+    )?;
+    m.define_module_function(
+        "get_cursor_position",
+        function!(terminal::get_cursor_position, 0),
+    )?;
+    m.define_module_function("resize_terminal", function!(terminal::resize_terminal, 2))?;
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use ratatui::layout::Rect;
+    use ratatui::style::Color;
+    use ratatui::widgets::Widget;
+    use ratatui::widgets::{Chart, Dataset, Sparkline};
+
+    #[test]
+    fn test_parse_color() {
+        // We can test this through the style module directly now
+        use crate::style::parse_color;
+        assert_eq!(parse_color("red"), Some(Color::Red));
+        assert_eq!(parse_color("blue"), Some(Color::Blue));
+        assert_eq!(parse_color("#ffffff"), Some(Color::Rgb(255, 255, 255)));
+        assert_eq!(parse_color("#000000"), Some(Color::Rgb(0, 0, 0)));
+        assert_eq!(parse_color("invalid"), None);
+    }
+
+    #[test]
+    fn test_sparkline_render() {
+        let mut buf = ratatui::buffer::Buffer::empty(Rect::new(0, 0, 10, 1));
+        let data = vec![1, 2, 3];
+        let sparkline = Sparkline::default().data(&data);
+        sparkline.render(Rect::new(0, 0, 10, 1), &mut buf);
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+    }
+
+    #[test]
+    fn test_line_chart_render() {
+        let mut buf = ratatui::buffer::Buffer::empty(Rect::new(0, 0, 20, 10));
+        let data = vec![(0.0, 0.0), (1.0, 1.0)];
+        let datasets = vec![Dataset::default().data(&data)];
+        let chart = Chart::new(datasets)
+            .x_axis(ratatui::widgets::Axis::default().bounds([0.0, 1.0]))
+            .y_axis(ratatui::widgets::Axis::default().bounds([0.0, 1.0]));
+        chart.render(Rect::new(0, 0, 20, 10), &mut buf);
+        assert!(buf.content().iter().any(|c| c.symbol() != " "));
+    }
+}

data/ext/ratatui_ruby/src/rendering.rs

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::widgets;
+use magnus::{prelude::*, Error, Value};
+use ratatui::{layout::Rect, Frame};
+
+pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let class = node.class();
+    let class_name = unsafe { class.name() };
+
+    match class_name.as_ref() {
+        "RatatuiRuby::Paragraph" => widgets::paragraph::render(frame, area, node)?,
+        "RatatuiRuby::Cursor" => widgets::cursor::render(frame, area, node)?,
+        "RatatuiRuby::Overlay" => widgets::overlay::render(frame, area, node)?,
+        "RatatuiRuby::Center" => widgets::center::render(frame, area, node)?,
+        "RatatuiRuby::Layout" => widgets::layout::render(frame, area, node)?,
+        "RatatuiRuby::List" => widgets::list::render(frame, area, node)?,
+        "RatatuiRuby::Gauge" => widgets::gauge::render(frame, area, node)?,
+        "RatatuiRuby::Table" => widgets::table::render(frame, area, node)?,
+        "RatatuiRuby::Block" => widgets::block::render(frame, area, node)?,
+        "RatatuiRuby::Tabs" => widgets::tabs::render(frame, area, node)?,
+        "RatatuiRuby::Scrollbar" => widgets::scrollbar::render(frame, area, node)?,
+        "RatatuiRuby::BarChart" => widgets::barchart::render(frame, area, node)?,
+        "RatatuiRuby::Canvas" => widgets::canvas::render(frame, area, node)?,
+        "RatatuiRuby::Sparkline" => widgets::sparkline::render(frame, area, node)?,
+        "RatatuiRuby::LineChart" => widgets::linechart::render(frame, area, node)?,
+        _ => {}
+    }
+    Ok(())
+}

data/ext/ratatui_ruby/src/style.rs

@@ -0,0 +1,149 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::{
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders},
+};
+
+pub fn parse_color(color_str: &str) -> Option<Color> {
+    color_str.parse::<Color>().ok()
+}
+
+pub fn parse_style(style_val: Value) -> Result<Style, Error> {
+    if style_val.is_nil() {
+        return Ok(Style::default());
+    }
+
+    let mut style = Style::default();
+
+    let fg: Value = style_val.funcall("fg", ())?;
+    if !fg.is_nil() {
+        let fg_str: String = fg.funcall("to_s", ())?;
+        if let Some(color) = parse_color(&fg_str) {
+            style = style.fg(color);
+        }
+    }
+
+    let bg: Value = style_val.funcall("bg", ())?;
+    if !bg.is_nil() {
+        let bg_str: String = bg.funcall("to_s", ())?;
+        if let Some(color) = parse_color(&bg_str) {
+            style = style.bg(color);
+        }
+    }
+
+    let modifiers_val: Value = style_val.funcall("modifiers", ())?;
+    if !modifiers_val.is_nil() {
+        let modifiers_array = magnus::RArray::from_value(modifiers_val).ok_or_else(|| {
+            Error::new(
+                magnus::exception::type_error(),
+                "expected array for modifiers",
+            )
+        })?;
+
+        for i in 0..modifiers_array.len() {
+            let sym: Symbol = modifiers_array.entry(i as isize)?;
+            match sym.to_string().as_str() {
+                "bold" => style = style.add_modifier(Modifier::BOLD),
+                "italic" => style = style.add_modifier(Modifier::ITALIC),
+                "dim" => style = style.add_modifier(Modifier::DIM),
+                "reversed" => style = style.add_modifier(Modifier::REVERSED),
+                "underlined" => style = style.add_modifier(Modifier::UNDERLINED),
+                "slow_blink" => style = style.add_modifier(Modifier::SLOW_BLINK),
+                "rapid_blink" => style = style.add_modifier(Modifier::RAPID_BLINK),
+                "crossed_out" => style = style.add_modifier(Modifier::CROSSED_OUT),
+                "hidden" => style = style.add_modifier(Modifier::HIDDEN),
+                _ => {}
+            }
+        }
+    }
+
+    Ok(style)
+}
+
+pub fn parse_block(block_val: Value) -> Result<Block<'static>, Error> {
+    if block_val.is_nil() {
+        return Ok(Block::default());
+    }
+
+    let title: Value = block_val.funcall("title", ())?;
+    let borders_val: Value = block_val.funcall("borders", ())?;
+    let border_color: Value = block_val.funcall("border_color", ())?;
+
+    let mut block = Block::default();
+
+    if !title.is_nil() {
+        let title_str: String = title.funcall("to_s", ())?;
+        block = block.title(title_str);
+    }
+
+    if !borders_val.is_nil() {
+        let mut ratatui_borders = Borders::NONE;
+        if let Some(sym) = Symbol::from_value(borders_val) {
+            match sym.to_string().as_str() {
+                "all" => ratatui_borders = Borders::ALL,
+                "top" => ratatui_borders = Borders::TOP,
+                "bottom" => ratatui_borders = Borders::BOTTOM,
+                "left" => ratatui_borders = Borders::LEFT,
+                "right" => ratatui_borders = Borders::RIGHT,
+                _ => {}
+            }
+        } else if let Some(borders_array) = magnus::RArray::from_value(borders_val) {
+            for i in 0..borders_array.len() {
+                let sym: Symbol = borders_array.entry(i as isize)?;
+                match sym.to_string().as_str() {
+                    "all" => ratatui_borders |= Borders::ALL,
+                    "top" => ratatui_borders |= Borders::TOP,
+                    "bottom" => ratatui_borders |= Borders::BOTTOM,
+                    "left" => ratatui_borders |= Borders::LEFT,
+                    "right" => ratatui_borders |= Borders::RIGHT,
+                    _ => {}
+                }
+            }
+        }
+        block = block.borders(ratatui_borders);
+    }
+
+    if !border_color.is_nil() {
+        let color_str: String = border_color.funcall("to_s", ())?;
+        if let Some(color) = parse_color(&color_str) {
+            block = block.border_style(Style::default().fg(color));
+        }
+    }
+
+    Ok(block)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_color() {
+        assert_eq!(parse_color("red"), Some(Color::Red));
+        assert_eq!(parse_color("blue"), Some(Color::Blue));
+        assert_eq!(parse_color("black"), Some(Color::Black));
+        assert_eq!(parse_color("white"), Some(Color::White));
+        assert_eq!(parse_color("green"), Some(Color::Green));
+        assert_eq!(parse_color("yellow"), Some(Color::Yellow));
+        assert_eq!(parse_color("magenta"), Some(Color::Magenta));
+        assert_eq!(parse_color("cyan"), Some(Color::Cyan));
+        assert_eq!(parse_color("gray"), Some(Color::Gray));
+        assert_eq!(parse_color("dark_gray"), Some(Color::DarkGray));
+        assert_eq!(parse_color("light_red"), Some(Color::LightRed));
+        assert_eq!(parse_color("light_green"), Some(Color::LightGreen));
+        assert_eq!(parse_color("light_yellow"), Some(Color::LightYellow));
+        assert_eq!(parse_color("light_blue"), Some(Color::LightBlue));
+        assert_eq!(parse_color("light_magenta"), Some(Color::LightMagenta));
+        assert_eq!(parse_color("light_cyan"), Some(Color::LightCyan));
+
+        assert_eq!(parse_color("#ffffff"), Some(Color::Rgb(255, 255, 255)));
+        assert_eq!(parse_color("#000000"), Some(Color::Rgb(0, 0, 0)));
+        assert_eq!(parse_color("#FF0000"), Some(Color::Rgb(255, 0, 0)));
+
+        assert_eq!(parse_color("invalid"), None);
+        assert_eq!(parse_color(""), None);
+    }
+}