ratatui_ruby 1.4.0-x86_64-linux

data/ext/ratatui_ruby/src/rendering.rs

@@ -0,0 +1,158 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::style::{parse_color_value, parse_modifier_str, parse_style};
+use crate::widgets;
+use magnus::{prelude::*, Error, RArray, Value};
+use ratatui::{buffer::Buffer, layout::Rect, style::Style, widgets::Widget};
+
+pub fn render_node(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    if node.respond_to("render", true)? {
+        let ruby = magnus::Ruby::get().unwrap();
+        let ruby_area = {
+            let module = ruby.define_module("RatatuiRuby")?;
+            let layout_mod = module.const_get::<_, magnus::RModule>("Layout")?;
+            let class = layout_mod.const_get::<_, magnus::RClass>("Rect")?;
+            class.funcall::<_, _, Value>("new", (area.x, area.y, area.width, area.height))?
+        };
+
+        // Call render with just the area (no buffer!)
+        let commands: Value = node.funcall("render", (ruby_area,))?;
+
+        // Process returned draw commands
+        if let Some(arr) = RArray::from_value(commands) {
+            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 cmd: Value = arr.entry(index)?;
+                process_draw_command(buffer, cmd)?;
+            }
+        }
+        return Ok(());
+    }
+
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { node.class().name() }.into_owned();
+
+    // Special case: Cursor widget requires Frame, not just Buffer
+    // For now, we skip it in buffer-only contexts (like insert_before)
+    // Frame-based callers should check for Cursor and handle it specially
+    if class_name.as_str() == "RatatuiRuby::Widgets::Cursor" {
+        // No-op for buffer-only rendering
+        // Frame-based rendering should use Frame.set_cursor_position directly
+        return Ok(());
+    }
+
+    match class_name.as_str() {
+        "RatatuiRuby::Widgets::Paragraph" => widgets::paragraph::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Clear" => widgets::clear::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Overlay" => widgets::overlay::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Center" => widgets::center::render(buffer, area, node)?,
+        "RatatuiRuby::Layout::Layout" => widgets::layout::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::List" => widgets::list::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Gauge" => widgets::gauge::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::LineGauge" => widgets::line_gauge::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Table" => widgets::table::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Block" => widgets::block::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Tabs" => widgets::tabs::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Scrollbar" => widgets::scrollbar::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::BarChart" => widgets::barchart::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Canvas" => widgets::canvas::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Calendar" => widgets::calendar::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Sparkline" => widgets::sparkline::render(buffer, area, node)?,
+        "RatatuiRuby::Widgets::Chart" => {
+            widgets::chart::render(buffer, area, node)?;
+        }
+        "RatatuiRuby::Widgets::RatatuiLogo" => widgets::ratatui_logo::render(buffer, area, node),
+        "RatatuiRuby::Widgets::RatatuiMascot" => {
+            widgets::ratatui_mascot::render_ratatui_mascot(buffer, area, node)?;
+        }
+        // Text primitives can also be rendered directly as widgets
+        "RatatuiRuby::Text::Line" => {
+            let line = crate::text::parse_line(node)?;
+            line.render(area, buffer);
+        }
+        "RatatuiRuby::Text::Span" => {
+            let span = crate::text::parse_span(node)?;
+            span.render(area, buffer);
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+pub fn render_widget_to_buffer(buffer: &mut Buffer, area: Rect, node: Value) -> Result<(), Error> {
+    // Just delegate to render_node since it now works with Buffer
+    render_node(buffer, area, node)
+}
+
+fn process_draw_command(buffer: &mut Buffer, cmd: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { cmd.class().name() }.into_owned();
+
+    match class_name.as_str() {
+        "RatatuiRuby::Draw::StringCmd" => {
+            let x: u16 = cmd.funcall("x", ())?;
+            let y: u16 = cmd.funcall("y", ())?;
+            let string: String = cmd.funcall("string", ())?;
+            let style_val: Value = cmd.funcall("style", ())?;
+            let style = parse_style(style_val)?;
+            buffer.set_string(x, y, string, style);
+        }
+        "RatatuiRuby::Draw::CellCmd" => {
+            let x: u16 = cmd.funcall("x", ())?;
+            let y: u16 = cmd.funcall("y", ())?;
+            let cell_val: Value = cmd.funcall("cell", ())?;
+
+            let area = buffer.area;
+            if x >= area.x + area.width || y >= area.y + area.height {
+                return Ok(());
+            }
+
+            let symbol: String = cell_val.funcall("char", ())?;
+            let fg_val: Value = cell_val.funcall("fg", ())?;
+            let bg_val: Value = cell_val.funcall("bg", ())?;
+            let modifiers_val: Value = cell_val.funcall("modifiers", ())?;
+
+            let mut style = Style::default();
+
+            if !fg_val.is_nil() {
+                if let Some(color) = parse_color_value(fg_val)? {
+                    style = style.fg(color);
+                }
+            }
+            if !bg_val.is_nil() {
+                if let Some(color) = parse_color_value(bg_val)? {
+                    style = style.bg(color);
+                }
+            }
+
+            if let Some(mods_array) = RArray::from_value(modifiers_val) {
+                for i in 0..mods_array.len() {
+                    let index = isize::try_from(i)
+                        .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                    let mod_val: Value = mods_array.entry(index)?;
+                    // Accept both symbols and strings (DWIM)
+                    let mod_str: String = mod_val.funcall("to_s", ())?;
+                    if let Some(modifier) = parse_modifier_str(&mod_str) {
+                        style = style.add_modifier(modifier);
+                    }
+                }
+            }
+
+            if let Some(cell) = buffer.cell_mut((x, y)) {
+                cell.set_symbol(&symbol).set_style(style);
+            }
+        }
+        _ => {
+            return Err(Error::new(
+                ruby.exception_type_error(),
+                format!("Unknown draw command: {class_name}"),
+            ));
+        }
+    }
+
+    Ok(())
+}

data/ext/ratatui_ruby/src/string_width.rs

@@ -0,0 +1,101 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use magnus::{prelude::*, Error, Value};
+
+/// Calculate the display width of a string in terminal cells.
+///
+/// Handles unicode correctly, including:
+/// - Regular ASCII characters: 1 cell each
+/// - CJK characters: 2 cells each (full-width)
+/// - Emoji: typically 2 cells each (varies by terminal)
+/// - Combining marks and zero-width characters: 0 cells
+///
+/// This uses the same `unicode-width` crate that Ratatui uses internally.
+///
+/// Returns the total display width in cells (not bytes or characters).
+pub fn text_width(string: Value) -> Result<usize, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+
+    let s: String = String::try_convert(string).map_err(|_| {
+        Error::new(
+            ruby.exception_type_error(),
+            "expected a String or object that converts to String",
+        )
+    })?;
+
+    // Use unicode_width's width calculation.
+    // This is the same mechanism Ratatui uses internally for Paragraph.line_width().
+    let width = s
+        .chars()
+        .map(|c| unicode_width::UnicodeWidthChar::width(c).unwrap_or(0))
+        .sum();
+
+    Ok(width)
+}
+
+#[cfg(test)]
+mod tests {
+    use unicode_width::UnicodeWidthChar;
+
+    fn measure_width(s: &str) -> usize {
+        s.chars()
+            .map(|c| UnicodeWidthChar::width(c).unwrap_or(0))
+            .sum()
+    }
+
+    #[test]
+    fn test_ascii_width() {
+        // ASCII is 1 cell per character
+        assert_eq!(measure_width("hello"), 5);
+        assert_eq!(measure_width("Hello, World!"), 13);
+    }
+
+    #[test]
+    fn test_emoji_width() {
+        // Emoji typically take 2 cells
+        // 👍 is U+1F44D THUMBS UP SIGN, width 2
+        assert_eq!(measure_width("👍"), 2);
+        // 🌍 is U+1F30D EARTH GLOBE EUROPE-AFRICA, width 2
+        assert_eq!(measure_width("🌍"), 2);
+        // "Hello 👍" = 5 + 1 + 2 = 8
+        assert_eq!(measure_width("Hello 👍"), 8);
+    }
+
+    #[test]
+    fn test_cjk_width() {
+        // CJK characters are full-width, 2 cells each
+        // 你 (U+4F60) is width 2
+        assert_eq!(measure_width("你"), 2);
+        // 好 (U+597D) is width 2
+        assert_eq!(measure_width("好"), 2);
+        // "你好" should be 4
+        assert_eq!(measure_width("你好"), 4);
+    }
+
+    #[test]
+    fn test_mixed_width() {
+        // "a你b好" = 1 + 2 + 1 + 2 = 6
+        assert_eq!(measure_width("a你b好"), 6);
+    }
+
+    #[test]
+    fn test_empty_string() {
+        assert_eq!(measure_width(""), 0);
+    }
+
+    #[test]
+    fn test_spaces_and_punctuation() {
+        // Regular ASCII space and punctuation are 1 cell each
+        assert_eq!(measure_width("a b c"), 5);
+        assert_eq!(measure_width("!!!"), 3);
+    }
+
+    #[test]
+    fn test_combining_marks() {
+        // Zero-width marks don't add to width
+        // "a" + combining acute accent (U+0301)
+        let combining = "a\u{0301}";
+        assert_eq!(measure_width(combining), 1);
+    }
+}