ratatui_ruby 1.4.0-x86_64-linux

data/ext/ratatui_ruby/src/frame.rs

@@ -0,0 +1,241 @@
+// 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 crate::widgets;
+use magnus::{prelude::*, Error, Value};
+use ratatui::layout::Rect;
+use ratatui::Frame;
+use std::cell::UnsafeCell;
+use std::ptr::NonNull;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+
+/// 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
+///
+/// The `active` flag provides runtime safety by preventing use after the draw
+/// callback completes. Without this, a user could store the frame and cause
+/// undefined behavior by accessing it after the underlying pointer is invalid.
+#[magnus::wrap(class = "RatatuiRuby::Frame")]
+pub struct RubyFrame {
+    /// Pointer to the underlying frame. Valid only during the draw callback.
+    inner: UnsafeCell<NonNull<Frame<'static>>>,
+    /// Shared flag to invalidate the frame when the block finishes.
+    /// Set to `true` during draw, `false` immediately after yield returns.
+    active: Arc<AtomicBool>,
+}
+
+// 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.
+    ///
+    /// # Arguments
+    ///
+    /// * `frame` - Mutable reference to the underlying Ratatui frame
+    /// * `active` - Shared atomic flag that controls frame validity
+    ///
+    /// # 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
+    /// 3. The `active` flag is set to `false` after the draw callback completes
+    pub fn new(frame: &mut Frame<'_>, active: Arc<AtomicBool>) -> 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),
+            active,
+        }
+    }
+
+    /// Checks that the frame is still valid for use.
+    ///
+    /// Returns `Ok(())` if the frame can be used, or an error if the draw
+    /// callback has already completed.
+    fn ensure_active(&self) -> Result<(), Error> {
+        if self.active.load(Ordering::Relaxed) {
+            Ok(())
+        } else {
+            let ruby = magnus::Ruby::get().unwrap();
+            let module = ruby.define_module("RatatuiRuby")?;
+            let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+            let error_class = error_base.const_get("Safety")?;
+            Err(Error::new(
+                error_class,
+                "Frame cannot be used outside of the draw block",
+            ))
+        }
+    }
+
+    /// Returns the terminal area as a Ruby `RatatuiRuby::Rect`.
+    ///
+    /// This mirrors `frame.area()` in Rust Ratatui.
+    pub fn area(&self) -> Result<Value, Error> {
+        self.ensure_active()?;
+        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.
+        // The ensure_active() check above guarantees we're still in the callback.
+        let area = unsafe { (*self.inner.get()).as_ref().area() };
+
+        // Create a Ruby Layout::Rect object
+        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("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> {
+        self.ensure_active()?;
+
+        // 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
+        // 4. ensure_active() above guarantees we're still in the callback
+        let frame = unsafe { (*self.inner.get()).as_mut() };
+
+        // Special case: Cursor widget requires Frame.set_cursor_position
+        // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+        let widget_class = unsafe { widget.class().name() }.into_owned();
+        if widget_class == "RatatuiRuby::Widgets::Cursor" {
+            let cursor_x: u16 = widget.funcall("x", ())?;
+            let cursor_y: u16 = widget.funcall("y", ())?;
+            frame.set_cursor_position((rect.x + cursor_x, rect.y + cursor_y));
+            return Ok(());
+        }
+
+        // Delegate to the existing render_node function
+        rendering::render_node(frame.buffer_mut(), rect, widget)
+    }
+
+    /// Renders a stateful widget at the specified area.
+    ///
+    /// This mirrors `frame.render_stateful_widget(widget, area, &mut state)` in Rust Ratatui.
+    /// The State object is the single source of truth for selection and offset.
+    /// Widget properties (`selected_index`, `selected_row`, `offset`) are ignored.
+    ///
+    /// # Arguments
+    ///
+    /// * `widget` - A Ruby widget object (e.g., `RatatuiRuby::List`)
+    /// * `area` - A Ruby `Rect`
+    /// * `state` - A Ruby state object (e.g., `RatatuiRuby::ListState`)
+    pub fn render_stateful_widget(
+        &self,
+        widget: Value,
+        area: Value,
+        state: Value,
+    ) -> Result<(), Error> {
+        self.ensure_active()?;
+        let ruby = magnus::Ruby::get().unwrap();
+
+        // 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.
+        let frame = unsafe { (*self.inner.get()).as_mut() };
+
+        // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+        let widget_class = unsafe { widget.class().name() }.into_owned();
+        // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+        let state_class = unsafe { state.class().name() }.into_owned();
+
+        match (widget_class.as_str(), state_class.as_str()) {
+            ("RatatuiRuby::Widgets::List", "RatatuiRuby::ListState") => {
+                let buffer = frame.buffer_mut();
+                widgets::list::render_stateful(buffer, rect, widget, state)
+            }
+            ("RatatuiRuby::Widgets::Table", "RatatuiRuby::TableState") => {
+                let buffer = frame.buffer_mut();
+                widgets::table::render_stateful(buffer, rect, widget, state)
+            }
+            ("RatatuiRuby::Widgets::Scrollbar", "RatatuiRuby::ScrollbarState") => {
+                let buffer = frame.buffer_mut();
+                widgets::scrollbar::render_stateful(buffer, rect, widget, state)
+            }
+            _ => Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("Unsupported widget/state combination: {widget_class} with {state_class}"),
+            )),
+        }
+    }
+
+    /// Sets the cursor position in the terminal.
+    ///
+    /// This mirrors `frame.set_cursor_position((x, y))` in Rust Ratatui.
+    /// Use this for text input fields to show the cursor at the correct location.
+    ///
+    /// # Arguments
+    ///
+    /// * `x` - Column position (0-indexed from left)
+    /// * `y` - Row position (0-indexed from top)
+    pub fn set_cursor_position(&self, x: u16, y: u16) -> Result<(), Error> {
+        self.ensure_active()?;
+
+        // SAFETY: The frame pointer is valid for the duration of the draw callback.
+        // ensure_active() above guarantees we're still in the callback.
+        let frame = unsafe { (*self.inner.get()).as_mut() };
+        frame.set_cursor_position((x, y));
+        Ok(())
+    }
+}

data/ext/ratatui_ruby/src/lib.rs

@@ -0,0 +1,343 @@
+// 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)]
+#![allow(clippy::non_std_lazy_statics)]
+
+mod color;
+mod errors;
+mod events;
+mod frame;
+mod rendering;
+mod string_width;
+mod style;
+mod terminal; // New module with TerminalQuery trait
+mod text;
+mod widgets;
+
+use frame::RubyFrame;
+use magnus::{function, method, Error, Module, Object, Ruby, Value};
+use terminal::{init_terminal, restore_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",
+        ));
+    }
+
+    // Nested draw() calls are not allowed - would deadlock
+    if terminal::is_in_draw_mode() {
+        let module = ruby.define_module("RatatuiRuby")?;
+        let error_base = module.const_get::<_, magnus::RClass>("Error")?;
+        let error_class = error_base.const_get("Invariant")?;
+        return Err(Error::new(
+            error_class,
+            "draw cannot be called during another draw (nested draws not allowed)",
+        ));
+    }
+
+    // Use lend_for_draw which handles snapshot capture/cleanup automatically
+    let result = terminal::lend_for_draw(|wrapper| {
+        let ruby = magnus::Ruby::get().expect("Ruby must be initialized");
+        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 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
+                active.store(false, std::sync::atomic::Ordering::Relaxed);
+            } else if let Some(tree_value) = tree {
+                // Legacy API: render tree to full area
+                let area = f.area();
+                if let Err(e) = rendering::render_node(f.buffer_mut(), area, tree_value) {
+                    render_error = Some(e);
+                }
+            }
+        };
+
+        match wrapper {
+            terminal::TerminalWrapper::Crossterm(term) => {
+                let module = ruby.define_module("RatatuiRuby").unwrap();
+                let error_base = module.const_get::<_, magnus::RClass>("Error").unwrap();
+                let error_class = error_base.const_get("Terminal").unwrap();
+                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").unwrap();
+                let error_base = module.const_get::<_, magnus::RClass>("Error").unwrap();
+                let error_class = error_base.const_get("Terminal").unwrap();
+                term.draw(&mut draw_callback)
+                    .map_err(|e| Error::new(error_class, e.to_string()))?;
+            }
+        }
+
+        if let Some(e) = render_error {
+            return Err(e);
+        }
+
+        Ok(())
+    });
+
+    result.unwrap_or_else(|| {
+        eprintln!("Terminal is None!");
+        Ok(())
+    })
+}
+
+// Storage for the last panic info, to be retrieved and printed after terminal restore.
+thread_local! {
+    static LAST_PANIC: std::cell::RefCell<Option<String>> = const { std::cell::RefCell::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}");
+        LAST_PANIC.with(|p| {
+            *p.borrow_mut() = 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> {
+    LAST_PANIC.with(|p| p.borrow_mut().take())
+}
+
+/// 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");
+}
+
+/// Register the Terminal class with FFI methods.
+fn register_terminal_class(ruby: &Ruby, m: magnus::RModule) -> Result<(), Error> {
+    let terminal_class = m.define_class("Terminal", ruby.class_object())?;
+    terminal_class.define_singleton_method(
+        "_init_test_terminal_instance",
+        function!(terminal::init_test_terminal_instance, 4),
+    )?;
+    terminal_class.define_singleton_method(
+        "_get_terminal_size_instance",
+        function!(terminal::get_terminal_size_instance, 1),
+    )?;
+    terminal_class.define_singleton_method(
+        "_available_color_count",
+        function!(terminal::available_color_count, 0),
+    )?;
+    terminal_class.define_singleton_method(
+        "_supports_keyboard_enhancement",
+        function!(terminal::supports_keyboard_enhancement, 0),
+    )?;
+    terminal_class.define_singleton_method(
+        "_terminal_window_size",
+        function!(terminal::terminal_window_size, 0),
+    )?;
+    terminal_class.define_singleton_method(
+        "_force_color_output",
+        function!(terminal::force_color_output, 1),
+    )?;
+    Ok(())
+}
+
+#[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))?;
+    m.define_module_function("_all_key_codes", function!(events::all_key_codes, 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(
+        "set_cursor_position",
+        function!(terminal::set_cursor_position, 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))?;
+    m.define_module_function(
+        "_get_terminal_area",
+        function!(terminal::get_terminal_area, 0),
+    )?;
+    m.define_module_function(
+        "_get_terminal_size",
+        function!(terminal::get_terminal_size, 0),
+    )?;
+    m.define_module_function("_insert_before", function!(terminal::insert_before, 2))?;
+    m.define_module_function(
+        "_get_viewport_type",
+        function!(terminal::get_viewport_type, 0),
+    )?;
+    m.define_module_function("_frame_count", function!(terminal::frame_count, 0))?;
+
+    // Register Terminal class with instance-specific FFI methods
+    register_terminal_class(&ruby, m)?;
+
+    // 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/lib_header.rs

@@ -0,0 +1,11 @@
+// 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::non_std_lazy_statics)]