ratatui_ruby 1.0.0.pre.beta.2 → 1.0.0.pre.beta.3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratatui_ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.beta.2
+  version: 1.0.0.pre.beta.3
 platform: ruby
 authors:
 - Kerrick Long
@@ -604,14 +604,16 @@ files:
 - ext/ratatui_ruby/src/events.rs
 - ext/ratatui_ruby/src/frame.rs
 - ext/ratatui_ruby/src/lib.rs
-- ext/ratatui_ruby/src/lib.rs.bak
 - ext/ratatui_ruby/src/rendering.rs
-- ext/ratatui_ruby/src/rendering.rs.bak
 - ext/ratatui_ruby/src/string_width.rs
 - ext/ratatui_ruby/src/style.rs
-- ext/ratatui_ruby/src/terminal.rs
-- ext/ratatui_ruby/src/terminal.rs.bak
-- ext/ratatui_ruby/src/terminal.rs.orig
+- ext/ratatui_ruby/src/terminal/init.rs
+- ext/ratatui_ruby/src/terminal/mod.rs
+- ext/ratatui_ruby/src/terminal/mutations.rs
+- ext/ratatui_ruby/src/terminal/queries.rs
+- ext/ratatui_ruby/src/terminal/query.rs
+- ext/ratatui_ruby/src/terminal/storage.rs
+- ext/ratatui_ruby/src/terminal/wrapper.rs
 - ext/ratatui_ruby/src/text.rs
 - ext/ratatui_ruby/src/widgets/barchart.rs
 - ext/ratatui_ruby/src/widgets/block.rs

data/ext/ratatui_ruby/src/lib.rs.bak

@@ -1,286 +0,0 @@
-// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
-// Require SAFETY comments on all unsafe blocks
-#![warn(clippy::undocumented_unsafe_blocks)]
-// Enable pedantic lints for stricter code quality
-#![warn(clippy::pedantic)]
-// Allow certain pedantic lints that are too noisy for FFI code
-#![allow(clippy::missing_errors_doc)]
-#![allow(clippy::missing_panics_doc)]
-#![allow(clippy::module_name_repetitions)]
-
-mod color;
-mod errors;
-mod events;
-mod frame;
-mod rendering;
-mod string_width;
-mod style;
-mod terminal;
-mod text;
-mod widgets;
-
-use frame::RubyFrame;
-use magnus::{function, method, Error, Module, Object, Ruby, Value};
-use terminal::{init_terminal, restore_terminal, TERMINAL};
-
-/// Draw to the terminal.
-///
-/// Supports two calling conventions:
-/// - Legacy: `RatatuiRuby.draw(tree)` - Renders a widget tree to the full terminal area
-/// - New: `RatatuiRuby.draw { |frame| ... }` - Yields a Frame for explicit widget placement
-fn draw(args: &[Value]) -> Result<(), Error> {
-    let ruby = Ruby::get().unwrap();
-
-    // Parse arguments: check for optional tree argument
-    let tree: Option<Value> = if args.is_empty() {
-        None
-    } else if args.len() == 1 {
-        Some(args[0])
-    } else {
-        return Err(Error::new(
-            ruby.exception_arg_error(),
-            format!(
-                "wrong number of arguments (given {}, expected 0..1)",
-                args.len()
-            ),
-        ));
-    };
-    let block_given = ruby.block_given();
-
-    // Validate: must have either tree or block, but not both
-    if tree.is_some() && block_given {
-        return Err(Error::new(
-            ruby.exception_arg_error(),
-            "Cannot provide both a tree and a block to draw",
-        ));
-    }
-    if tree.is_none() && !block_given {
-        return Err(Error::new(
-            ruby.exception_arg_error(),
-            "Must provide either a tree or a block to draw",
-        ));
-    }
-
-    let mut term_lock = TERMINAL.lock().unwrap();
-    let mut render_error: Option<Error> = None;
-
-    // Helper closure to execute the draw callback logic for either terminal type
-    let mut draw_callback = |f: &mut ratatui::Frame<'_>| {
-        if block_given {
-            // New API: yield RubyFrame to block
-            // Create validity flag — set to true while the block is executing
-            let active = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(true));
-
-            let ruby_frame = RubyFrame::new(f, active.clone());
-            if let Err(e) = ruby.yield_value::<_, Value>(ruby_frame) {
-                render_error = Some(e);
-            }
-
-            // Invalidate frame immediately after block returns
-            // This prevents use-after-free if user stored the frame object
-            active.store(false, std::sync::atomic::Ordering::Relaxed);
-        } else if let Some(tree_value) = tree {
-            // Legacy API: render tree to full area
-            if let Err(e) = rendering::render_node(f, f.area(), tree_value) {
-                render_error = Some(e);
-            }
-        }
-    };
-
-    if let Some(wrapper) = term_lock.as_mut() {
-        match wrapper {
-            terminal::TerminalWrapper::Crossterm(term) => {
-                let module = ruby.define_module("RatatuiRuby")?;
-                let error_base = module.const_get::<_, magnus::RClass>("Error")?;
-                let error_class = error_base.const_get("Terminal")?;
-                term.draw(&mut draw_callback)
-                    .map_err(|e| Error::new(error_class, e.to_string()))?;
-            }
-            terminal::TerminalWrapper::Test(term) => {
-                let module = ruby.define_module("RatatuiRuby")?;
-                let error_base = module.const_get::<_, magnus::RClass>("Error")?;
-                let error_class = error_base.const_get("Terminal")?;
-                term.draw(&mut draw_callback)
-                    .map_err(|e| Error::new(error_class, e.to_string()))?;
-            }
-        }
-    } else {
-        eprintln!("Terminal is None!");
-    }
-
-    if let Some(e) = render_error {
-        return Err(e);
-    }
-
-    Ok(())
-}
-
-/// Storage for the last panic info, to be retrieved and printed after terminal restore.
-static LAST_PANIC: std::sync::Mutex<Option<String>> = std::sync::Mutex::new(None);
-
-/// Enables Rust backtraces and installs a custom panic hook.
-///
-/// The panic hook stores the backtrace info instead of printing immediately.
-/// This allows Ruby to retrieve and print it after terminal restoration,
-/// preventing output from being lost on the alternate screen.
-fn enable_rust_backtrace(_ruby: &magnus::Ruby) {
-    std::env::set_var("RUST_BACKTRACE", "1");
-    std::panic::set_hook(Box::new(|info| {
-        let backtrace = std::backtrace::Backtrace::force_capture();
-        let message = format!("Rust panic: {info}\n{backtrace}");
-        if let Ok(mut guard) = LAST_PANIC.lock() {
-            *guard = Some(message);
-        }
-    }));
-}
-
-/// Returns the last panic info (if any) and clears it.
-///
-/// Call this after terminal restoration to get deferred panic output.
-fn get_last_panic(_ruby: &magnus::Ruby) -> Option<String> {
-    if let Ok(mut guard) = LAST_PANIC.lock() {
-        guard.take()
-    } else {
-        None
-    }
-}
-
-/// Intentionally panics to test backtrace output.
-///
-/// Only use this for debugging/testing the backtrace feature.
-fn test_panic(_ruby: &magnus::Ruby) {
-    panic!("Test panic triggered by RatatuiRuby._test_panic");
-}
-
-#[magnus::init]
-fn init() -> Result<(), Error> {
-    let ruby = magnus::Ruby::get().unwrap();
-    let m = ruby.define_module("RatatuiRuby")?;
-
-    m.define_module_function("_init_terminal", function!(init_terminal, 4))?;
-    m.define_module_function("_restore_terminal", function!(restore_terminal, 0))?;
-    m.define_module_function("_draw", function!(draw, -1))?;
-    m.define_module_function(
-        "_enable_rust_backtrace",
-        function!(enable_rust_backtrace, 0),
-    )?;
-    m.define_module_function("_test_panic", function!(test_panic, 0))?;
-    m.define_module_function("_get_last_panic", function!(get_last_panic, 0))?;
-
-    // Register Frame class
-    let frame_class = m.define_class("Frame", ruby.class_object())?;
-    frame_class.define_method("area", method!(RubyFrame::area, 0))?;
-    frame_class.define_method("render_widget", method!(RubyFrame::render_widget, 2))?;
-    frame_class.define_method(
-        "render_stateful_widget",
-        method!(RubyFrame::render_stateful_widget, 3),
-    )?;
-    frame_class.define_method(
-        "set_cursor_position",
-        method!(RubyFrame::set_cursor_position, 2),
-    )?;
-    m.define_module_function("_poll_event", function!(events::poll_event, 1))?;
-    m.define_module_function("inject_test_event", function!(events::inject_test_event, 2))?;
-    m.define_module_function("clear_events", function!(events::clear_events, 0))?;
-
-    // Register State classes
-    widgets::list_state::register(&ruby, m)?;
-    widgets::table_state::register(&ruby, m)?;
-    widgets::scrollbar_state::register(&ruby, m)?;
-
-    // Test backend helpers
-    m.define_module_function(
-        "_init_test_terminal",
-        function!(terminal::init_test_terminal, 4),
-    )?;
-    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("_get_cell_at", function!(terminal::get_cell_at, 2))?;
-    m.define_module_function("resize_terminal", function!(terminal::resize_terminal, 2))?;
-    m.define_module_function(
-        "_get_terminal_area",
-        function!(terminal::get_terminal_area, 0),
-    )?;
-    m.define_module_function(
-        "_insert_before",
-        function!(terminal::insert_before, 2),
-    )?;
-
-    // Register Layout.split on the Layout::Layout class (inside the Layout module)
-    let layout_mod = m.const_get::<_, magnus::RModule>("Layout")?;
-    let layout_class = layout_mod.const_get::<_, magnus::RClass>("Layout")?;
-    layout_class.define_singleton_method("_split", function!(widgets::layout::split_layout, 4))?;
-    layout_class.define_singleton_method(
-        "_split_with_spacers",
-        function!(widgets::layout::split_with_spacers_layout, 4),
-    )?;
-
-    // Paragraph metrics
-    m.define_module_function(
-        "_paragraph_line_count",
-        function!(widgets::paragraph::line_count, 2),
-    )?;
-    m.define_module_function(
-        "_paragraph_line_width",
-        function!(widgets::paragraph::line_width, 1),
-    )?;
-
-    // Tabs metrics
-    m.define_module_function("_tabs_width", function!(widgets::tabs::width, 1))?;
-
-    // Text measurement
-    m.define_module_function("_text_width", function!(string_width::text_width, 1))?;
-
-    // Color conversion
-    color::register(&ruby, m)?;
-
-    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.bak

@@ -1,152 +0,0 @@
-// 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, Frame};
-
-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();
-
-    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::Cursor" => widgets::cursor::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)?;
-            use ratatui::widgets::Widget;
-            line.render(area, buffer);
-        }
-        "RatatuiRuby::Text::Span" => {
-            let span = crate::text::parse_span(node)?;
-            use ratatui::widgets::Widget;
-            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(())
-}