ratatui_ruby 0.4.0 → 0.5.0

data/ext/ratatui_ruby/src/events.rs

@@ -28,10 +28,13 @@ pub fn inject_test_event(event_type: String, data: magnus::RHash) -> Result<(),
     Ok(())
 }
 
-fn parse_key_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
-    let code_val: Value = data.get(ruby.to_symbol("code")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'code' in key event")
-    })?;
+fn parse_key_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
+    let code_val: Value = data
+        .get(ruby.to_symbol("code"))
+        .ok_or_else(|| Error::new(ruby.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" => ratatui::crossterm::event::KeyCode::Up,
@@ -59,13 +62,18 @@ fn parse_key_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::
         }
     }
 
-    Ok(ratatui::crossterm::event::Event::Key(ratatui::crossterm::event::KeyEvent::new(code, modifiers)))
+    Ok(ratatui::crossterm::event::Event::Key(
+        ratatui::crossterm::event::KeyEvent::new(code, modifiers),
+    ))
 }
 
-fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
-    let kind_val: Value = data.get(ruby.to_symbol("kind")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'kind' in mouse event")
-    })?;
+fn parse_mouse_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
+    let kind_val: Value = data
+        .get(ruby.to_symbol("kind"))
+        .ok_or_else(|| Error::new(ruby.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(ruby.to_symbol("button")) {
@@ -79,14 +87,14 @@ fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui
         ratatui::crossterm::event::MouseButton::Left
     };
 
-    let x_val: Value = data.get(ruby.to_symbol("x")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'x' in mouse event")
-    })?;
+    let x_val: Value = data
+        .get(ruby.to_symbol("x"))
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "Missing 'x' in mouse event"))?;
     let x: u16 = u16::try_convert(x_val)?;
 
-    let y_val: Value = data.get(ruby.to_symbol("y")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'y' in mouse event")
-    })?;
+    let y_val: Value = data
+        .get(ruby.to_symbol("y"))
+        .ok_or_else(|| Error::new(ruby.exception_arg_error(), "Missing 'y' in mouse event"))?;
     let y: u16 = u16::try_convert(y_val)?;
 
     let kind = match kind_str.as_str() {
@@ -98,7 +106,12 @@ fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui
         "scroll_up" => ratatui::crossterm::event::MouseEventKind::ScrollUp,
         "scroll_left" => ratatui::crossterm::event::MouseEventKind::ScrollLeft,
         "scroll_right" => ratatui::crossterm::event::MouseEventKind::ScrollRight,
-        _ => return Err(Error::new(ruby.exception_arg_error(), format!("Unknown mouse kind: {kind_str}"))),
+        _ => {
+            return Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("Unknown mouse kind: {kind_str}"),
+            ))
+        }
     };
 
     let mut modifiers = ratatui::crossterm::event::KeyModifiers::empty();
@@ -114,26 +127,48 @@ fn parse_mouse_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui
         }
     }
 
-    Ok(ratatui::crossterm::event::Event::Mouse(ratatui::crossterm::event::MouseEvent { kind, column: x, row: y, modifiers }))
+    Ok(ratatui::crossterm::event::Event::Mouse(
+        ratatui::crossterm::event::MouseEvent {
+            kind,
+            column: x,
+            row: y,
+            modifiers,
+        },
+    ))
 }
 
-fn parse_resize_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
+fn parse_resize_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
     let width_val: Value = data.get(ruby.to_symbol("width")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'width' in resize event")
+        Error::new(
+            ruby.exception_arg_error(),
+            "Missing 'width' in resize event",
+        )
     })?;
     let width: u16 = u16::try_convert(width_val)?;
 
     let height_val: Value = data.get(ruby.to_symbol("height")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'height' in resize event")
+        Error::new(
+            ruby.exception_arg_error(),
+            "Missing 'height' in resize event",
+        )
     })?;
     let height: u16 = u16::try_convert(height_val)?;
 
     Ok(ratatui::crossterm::event::Event::Resize(width, height))
 }
 
-fn parse_paste_event(data: magnus::RHash, ruby: &magnus::Ruby) -> Result<ratatui::crossterm::event::Event, Error> {
+fn parse_paste_event(
+    data: magnus::RHash,
+    ruby: &magnus::Ruby,
+) -> Result<ratatui::crossterm::event::Event, Error> {
     let content_val: Value = data.get(ruby.to_symbol("content")).ok_or_else(|| {
-        Error::new(ruby.exception_arg_error(), "Missing 'content' in paste event")
+        Error::new(
+            ruby.exception_arg_error(),
+            "Missing 'content' in paste event",
+        )
     })?;
     let content: String = String::try_convert(content_val)?;
     Ok(ratatui::crossterm::event::Event::Paste(content))
@@ -159,7 +194,10 @@ pub fn poll_event(ruby: &magnus::Ruby) -> Result<Value, Error> {
 
     let is_test_mode = {
         let term_lock = crate::terminal::TERMINAL.lock().unwrap();
-        matches!(term_lock.as_ref(), Some(crate::terminal::TerminalWrapper::Test(_)))
+        matches!(
+            term_lock.as_ref(),
+            Some(crate::terminal::TerminalWrapper::Test(_))
+        )
     };
 
     if is_test_mode {
@@ -209,10 +247,27 @@ fn handle_key_event(key: ratatui::crossterm::event::KeyEvent) -> Result<Value, E
     };
     hash.aset(ruby.to_symbol("code"), code)?;
     let mut modifiers = Vec::new();
-    if key.modifiers.contains(ratatui::crossterm::event::KeyModifiers::CONTROL) { modifiers.push("ctrl"); }
-    if key.modifiers.contains(ratatui::crossterm::event::KeyModifiers::ALT) { modifiers.push("alt"); }
-    if key.modifiers.contains(ratatui::crossterm::event::KeyModifiers::SHIFT) { modifiers.push("shift"); }
-    if !modifiers.is_empty() { hash.aset(ruby.to_symbol("modifiers"), modifiers)?; }
+    if key
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::CONTROL)
+    {
+        modifiers.push("ctrl");
+    }
+    if key
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::ALT)
+    {
+        modifiers.push("alt");
+    }
+    if key
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::SHIFT)
+    {
+        modifiers.push("shift");
+    }
+    if !modifiers.is_empty() {
+        hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
+    }
     Ok(hash.into_value_with(&ruby))
 }
 
@@ -224,14 +279,29 @@ fn handle_mouse_event(event: ratatui::crossterm::event::MouseEvent) -> Result<Va
         ratatui::crossterm::event::MouseEventKind::Down(btn) => ("down", btn),
         ratatui::crossterm::event::MouseEventKind::Up(btn) => ("up", btn),
         ratatui::crossterm::event::MouseEventKind::Drag(btn) => ("drag", btn),
-        ratatui::crossterm::event::MouseEventKind::Moved => ("moved", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollDown => ("scroll_down", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollUp => ("scroll_up", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollLeft => ("scroll_left", ratatui::crossterm::event::MouseButton::Left),
-        ratatui::crossterm::event::MouseEventKind::ScrollRight => ("scroll_right", ratatui::crossterm::event::MouseButton::Left),
+        ratatui::crossterm::event::MouseEventKind::Moved => {
+            ("moved", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollDown => {
+            ("scroll_down", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollUp => {
+            ("scroll_up", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollLeft => {
+            ("scroll_left", ratatui::crossterm::event::MouseButton::Left)
+        }
+        ratatui::crossterm::event::MouseEventKind::ScrollRight => {
+            ("scroll_right", ratatui::crossterm::event::MouseButton::Left)
+        }
     };
     hash.aset(ruby.to_symbol("kind"), ruby.to_symbol(kind))?;
-    if matches!(event.kind, ratatui::crossterm::event::MouseEventKind::Down(_) | ratatui::crossterm::event::MouseEventKind::Up(_) | ratatui::crossterm::event::MouseEventKind::Drag(_)) {
+    if matches!(
+        event.kind,
+        ratatui::crossterm::event::MouseEventKind::Down(_)
+            | ratatui::crossterm::event::MouseEventKind::Up(_)
+            | ratatui::crossterm::event::MouseEventKind::Drag(_)
+    ) {
         let btn_sym = match button {
             ratatui::crossterm::event::MouseButton::Left => "left",
             ratatui::crossterm::event::MouseButton::Right => "right",
@@ -244,9 +314,24 @@ fn handle_mouse_event(event: ratatui::crossterm::event::MouseEvent) -> Result<Va
     hash.aset(ruby.to_symbol("x"), event.column)?;
     hash.aset(ruby.to_symbol("y"), event.row)?;
     let mut modifiers = Vec::new();
-    if event.modifiers.contains(ratatui::crossterm::event::KeyModifiers::CONTROL) { modifiers.push("ctrl"); }
-    if event.modifiers.contains(ratatui::crossterm::event::KeyModifiers::ALT) { modifiers.push("alt"); }
-    if event.modifiers.contains(ratatui::crossterm::event::KeyModifiers::SHIFT) { modifiers.push("shift"); }
+    if event
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::CONTROL)
+    {
+        modifiers.push("ctrl");
+    }
+    if event
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::ALT)
+    {
+        modifiers.push("alt");
+    }
+    if event
+        .modifiers
+        .contains(ratatui::crossterm::event::KeyModifiers::SHIFT)
+    {
+        modifiers.push("shift");
+    }
     hash.aset(ruby.to_symbol("modifiers"), modifiers)?;
     Ok(hash.into_value_with(&ruby))
 }

data/ext/ratatui_ruby/src/frame.rs

@@ -0,0 +1,115 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! Frame wrapper for exposing Ratatui's Frame to Ruby.
+//!
+//! This module provides `RubyFrame`, a struct that wraps `ratatui::Frame` and exposes
+//! it to Ruby via Magnus. It enables explicit widget placement through `render_widget`,
+//! aligning `RatatuiRuby` with native Rust Ratatui patterns.
+//!
+//! # Safety
+//!
+//! `RubyFrame` uses raw pointer casting to store a `Frame` reference with an erased
+//! lifetime. This is safe because:
+//! 1. `RubyFrame` is only created within `Terminal::draw()` callbacks
+//! 2. `RubyFrame` is never returned from or stored beyond the callback scope
+//! 3. The Ruby block receiving `RubyFrame` completes before the callback returns
+//!
+//! The `'static` lifetime is a lie, but a safe one within these constraints.
+
+use crate::rendering;
+use magnus::{prelude::*, Error, Value};
+use ratatui::layout::Rect;
+use ratatui::Frame;
+use std::cell::UnsafeCell;
+use std::ptr::NonNull;
+
+/// A wrapper around Ratatui's `Frame` that can be exposed to Ruby.
+///
+/// This struct uses raw pointers to hold a mutable reference to the frame,
+/// which is valid only for the duration of the draw callback.
+///
+/// # Safety
+///
+/// We implement `Send` manually because:
+/// 1. `RubyFrame` is only created and used within a single `Terminal::draw()` callback
+/// 2. The Ruby VM is single-threaded (GVL), so the frame pointer is never accessed
+///    from multiple threads simultaneously
+/// 3. `RubyFrame` never escapes the draw callback scope
+#[magnus::wrap(class = "RatatuiRuby::Frame")]
+pub struct RubyFrame {
+    /// Pointer to the underlying frame. Valid only during the draw callback.
+    inner: UnsafeCell<NonNull<Frame<'static>>>,
+}
+
+// SAFETY: RubyFrame is only used within Terminal::draw() callbacks, which are
+// single-threaded. The Ruby VM's GVL ensures no concurrent access.
+unsafe impl Send for RubyFrame {}
+
+impl RubyFrame {
+    /// Creates a new `RubyFrame` wrapping the given frame reference.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that:
+    /// 1. The `RubyFrame` does not outlive the frame reference
+    /// 2. No other mutable references to the frame exist while `RubyFrame` is in use
+    pub fn new(frame: &mut Frame<'_>) -> Self {
+        // SAFETY: We cast the frame pointer to 'static lifetime. This is safe because:
+        // - RubyFrame is only used within Terminal::draw() callbacks
+        // - The Ruby block completes before the callback returns
+        // - No reference to RubyFrame escapes the callback scope
+        let ptr = NonNull::from(frame);
+        let static_ptr: NonNull<Frame<'static>> =
+            // SAFETY: Lifetime erasure is safe within the draw callback scope.
+            // The frame pointer remains valid for the entire callback duration.
+            unsafe { std::mem::transmute(ptr) };
+
+        Self {
+            inner: UnsafeCell::new(static_ptr),
+        }
+    }
+
+    /// Returns the terminal area as a Ruby `RatatuiRuby::Rect`.
+    ///
+    /// This mirrors `frame.area()` in Rust Ratatui.
+    pub fn area(&self) -> Result<Value, Error> {
+        let ruby = magnus::Ruby::get().unwrap();
+
+        // SAFETY: The frame pointer is valid for the duration of the draw callback.
+        // We only read from the frame, which is safe with an immutable reference.
+        let area = unsafe { (*self.inner.get()).as_ref().area() };
+
+        // Create a Ruby Rect object
+        let module = ruby.define_module("RatatuiRuby")?;
+        let class = module.const_get::<_, magnus::RClass>("Rect")?;
+        class.funcall("new", (area.x, area.y, area.width, area.height))
+    }
+
+    /// Renders a widget at the specified area.
+    ///
+    /// This mirrors `frame.render_widget(widget, area)` in Rust Ratatui.
+    ///
+    /// # Arguments
+    ///
+    /// * `widget` - A Ruby widget object (e.g., `RatatuiRuby::Paragraph`)
+    /// * `area` - A Ruby `Rect` or hash-like object with `x`, `y`, `width`, `height`
+    pub fn render_widget(&self, widget: Value, area: Value) -> Result<(), Error> {
+        // Parse the Ruby area into a Rust Rect
+        let x: u16 = area.funcall("x", ())?;
+        let y: u16 = area.funcall("y", ())?;
+        let width: u16 = area.funcall("width", ())?;
+        let height: u16 = area.funcall("height", ())?;
+        let rect = Rect::new(x, y, width, height);
+
+        // SAFETY: The frame pointer is valid for the duration of the draw callback.
+        // We take a mutable reference which is safe because:
+        // 1. RubyFrame is only used within Terminal::draw() callbacks
+        // 2. Ruby's GVL ensures single-threaded access
+        // 3. No other code holds a reference to the frame during this call
+        let frame = unsafe { (*self.inner.get()).as_mut() };
+
+        // Delegate to the existing render_node function
+        rendering::render_node(frame, rect, widget)
+    }
+}

data/ext/ratatui_ruby/src/lib.rs

@@ -11,36 +11,83 @@
 #![allow(clippy::module_name_repetitions)]
 
 mod events;
+mod frame;
 mod rendering;
 mod style;
 mod terminal;
 mod text;
 mod widgets;
 
-use magnus::{function, Error, Module, Object, Value};
+use frame::RubyFrame;
+use magnus::{function, method, Error, Module, Object, Ruby, Value};
 use terminal::{init_terminal, restore_terminal, TERMINAL};
 
-fn draw(tree: Value) -> Result<(), Error> {
-    let ruby = magnus::Ruby::get().unwrap();
+/// 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 = None;
+    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
+            let ruby_frame = RubyFrame::new(f);
+            if let Err(e) = ruby.yield_value::<_, Value>(ruby_frame) {
+                render_error = Some(e);
+            }
+        } 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) => {
-                term.draw(|f| {
-                    if let Err(e) = rendering::render_node(f, f.area(), tree) {
-                        render_error = Some(e);
-                    }
-                })
-                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+                term.draw(&mut draw_callback)
+                    .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
             }
             terminal::TerminalWrapper::Test(term) => {
-                term.draw(|f| {
-                    if let Err(e) = rendering::render_node(f, f.area(), tree) {
-                        render_error = Some(e);
-                    }
-                })
-                .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
+                term.draw(&mut draw_callback)
+                    .map_err(|e| Error::new(ruby.exception_runtime_error(), e.to_string()))?;
             }
         }
     } else {
@@ -59,11 +106,14 @@ 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, 2))?;
     m.define_module_function("restore_terminal", function!(restore_terminal, 0))?;
-    m.define_module_function("draw", function!(draw, 1))?;
+    m.define_module_function("_draw", function!(draw, -1))?;
+
+    // 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))?;
     m.define_module_function("_poll_event", function!(events::poll_event, 0))?;
     m.define_module_function("inject_test_event", function!(events::inject_test_event, 2))?;
     m.define_module_function("clear_events", function!(events::clear_events, 0))?;
@@ -81,19 +131,22 @@ fn init() -> Result<(), Error> {
         "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("_get_cell_at", function!(terminal::get_cell_at, 2))?;
     m.define_module_function("resize_terminal", function!(terminal::resize_terminal, 2))?;
 
     // Register Layout.split on the Layout class
     let layout_class = m.const_get::<_, magnus::RClass>("Layout")?;
     layout_class.define_singleton_method("_split", function!(widgets::layout::split_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))?;
+    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))?;

data/ext/ratatui_ruby/src/rendering.rs

@@ -22,7 +22,8 @@ pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Err
         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 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(frame.buffer_mut(), cmd)?;
             }
@@ -54,8 +55,10 @@ pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Err
         "RatatuiRuby::Chart" | "RatatuiRuby::LineChart" => {
             widgets::chart::render(frame, area, node)?;
         }
-        "RatatuiRuby::RatatuiLogo" => widgets::ratatui_logo::render(frame, area, node)?,
-        "RatatuiRuby::RatatuiMascot" => widgets::ratatui_mascot::render_ratatui_mascot(frame, area, node)?,
+        "RatatuiRuby::RatatuiLogo" => widgets::ratatui_logo::render(frame, area, node),
+        "RatatuiRuby::RatatuiMascot" => {
+            widgets::ratatui_mascot::render_ratatui_mascot(frame, area, node)?;
+        }
         _ => {}
     }
     Ok(())
@@ -105,7 +108,8 @@ fn process_draw_command(buffer: &mut Buffer, cmd: Value) -> Result<(), Error> {
 
             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 index = isize::try_from(i)
+                        .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
                     let mod_str: String = mods_array.entry::<String>(index)?;
                     if let Some(modifier) = parse_modifier_str(&mod_str) {
                         style = style.add_modifier(modifier);