ratatui_ruby 0.4.0 → 0.5.0

data/ext/ratatui_ruby/src/widgets/chart.rs

@@ -35,13 +35,15 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let mut data_storage: Vec<Vec<(f64, f64)>> = Vec::new();
 
     for i in 0..datasets_val.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 ds_val: Value = datasets_val.entry(index)?;
         let data_array: magnus::RArray = ds_val.funcall("data", ())?;
 
         let mut points = Vec::new();
         for j in 0..data_array.len() {
-            let index = isize::try_from(j).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            let index = isize::try_from(j)
+                .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
             let point_array_val: Value = data_array.entry(index)?;
             let point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
                 Error::new(ruby.exception_type_error(), "expected array for point")
@@ -54,7 +56,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     for (i, points) in data_storage.iter().enumerate() {
-        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 ds_val: Value = datasets_val.entry(index)?;
         let name: String = ds_val.funcall("name", ())?;
         let marker_sym: Symbol = ds_val.funcall("marker", ())?;
@@ -112,7 +115,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     if !hidden_legend_constraints_val.is_nil() {
-        let constraints_array: magnus::RArray = hidden_legend_constraints_val.funcall("to_a", ())?;
+        let constraints_array: magnus::RArray =
+            hidden_legend_constraints_val.funcall("to_a", ())?;
         if constraints_array.len() == 2 {
             let width_val: Value = constraints_array.entry(0)?;
             let height_val: Value = constraints_array.entry(1)?;
@@ -138,7 +142,8 @@ fn parse_axis(axis_val: Value) -> Result<Axis<'static>, Error> {
 
     let mut labels = Vec::new();
     for i in 0..labels_val.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 label: String = labels_val.entry(index)?;
         labels.push(Span::from(label));
     }
@@ -175,13 +180,15 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
     let mut data_storage: Vec<Vec<(f64, f64)>> = Vec::new();
 
     for i in 0..datasets_val.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 ds_val: Value = datasets_val.entry(index)?;
         let data_array: magnus::RArray = ds_val.funcall("data", ())?;
 
         let mut points = Vec::new();
         for j in 0..data_array.len() {
-            let index = isize::try_from(j).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+            let index = isize::try_from(j)
+                .map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
             let point_array_val: Value = data_array.entry(index)?;
             let point_array = magnus::RArray::from_value(point_array_val).ok_or_else(|| {
                 Error::new(ruby.exception_type_error(), "expected array for point")
@@ -194,7 +201,8 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
     }
 
     for (i, points) in data_storage.iter().enumerate() {
-        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 ds_val: Value = datasets_val.entry(index)?;
         let name: String = ds_val.funcall("name", ())?;
 
@@ -214,14 +222,16 @@ fn render_line_chart(frame: &mut Frame, area: Rect, node: Value) -> Result<(), E
 
     let mut x_labels = Vec::new();
     for i in 0..x_labels_val.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 label: String = x_labels_val.entry(index)?;
         x_labels.push(Span::from(label));
     }
 
     let mut y_labels = Vec::new();
     for i in 0..y_labels_val.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 label: String = y_labels_val.entry(index)?;
         y_labels.push(Span::from(label));
     }

data/ext/ratatui_ruby/src/widgets/layout.rs

@@ -42,7 +42,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
         if let Some(arr) = constraints_array {
             for i in 0..arr.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 constraint_obj: Value = arr.entry(index)?;
                 if let Ok(constraint) = parse_constraint(constraint_obj) {
                     ratatui_constraints.push(constraint);
@@ -53,7 +54,9 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         // If constraints don't match children, adjust or default
         if ratatui_constraints.len() != len {
             ratatui_constraints = (0..len)
-                .map(|_| Constraint::Percentage(100 / u16::try_from(len).unwrap_or(u16::MAX).max(1)))
+                .map(|_| {
+                    Constraint::Percentage(100 / u16::try_from(len).unwrap_or(u16::MAX).max(1))
+                })
                 .collect();
         }
 
@@ -64,7 +67,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
             .split(area);
 
         for i in 0..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 child: Value = children_array.entry(index)?;
             if let Err(e) = render_node(frame, chunks[i], child) {
                 eprintln!("Error rendering child {i}: {e:?}");
@@ -168,7 +172,8 @@ pub fn split_layout(
     // Parse constraints
     let mut ratatui_constraints = Vec::new();
     for i in 0..constraints.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 constraint_obj: Value = constraints.entry(index)?;
         if let Ok(constraint) = parse_constraint(constraint_obj) {
             ratatui_constraints.push(constraint);

data/ext/ratatui_ruby/src/widgets/list.rs

@@ -29,7 +29,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     let mut items: Vec<String> = Vec::new();
     for i in 0..items_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 item: String = items_array.entry(index)?;
         items.push(item);
     }
@@ -142,21 +143,41 @@ mod tests {
     fn test_repeat_highlight_symbol() {
         let items = vec!["Item 1", "Item 2"];
         let list_without_repeat = List::new(items.clone()).highlight_symbol(Line::from(">> "));
-        let list_with_repeat = List::new(items).highlight_symbol(Line::from(">> ")).repeat_highlight_symbol(true);
-        
+        let list_with_repeat = List::new(items)
+            .highlight_symbol(Line::from(">> "))
+            .repeat_highlight_symbol(true);
+
         let mut state = ListState::default();
         state.select(Some(0));
 
         let mut buf1 = Buffer::empty(Rect::new(0, 0, 10, 2));
         use ratatui::widgets::StatefulWidget;
-        StatefulWidget::render(list_without_repeat, Rect::new(0, 0, 10, 2), &mut buf1, &mut state);
+        StatefulWidget::render(
+            list_without_repeat,
+            Rect::new(0, 0, 10, 2),
+            &mut buf1,
+            &mut state,
+        );
 
         let mut buf2 = Buffer::empty(Rect::new(0, 0, 10, 2));
-        StatefulWidget::render(list_with_repeat, Rect::new(0, 0, 10, 2), &mut buf2, &mut state);
+        StatefulWidget::render(
+            list_with_repeat,
+            Rect::new(0, 0, 10, 2),
+            &mut buf2,
+            &mut state,
+        );
 
         // Both should render, but the behavior might differ based on content width
-        let content1 = buf1.content().iter().map(|c| c.symbol()).collect::<String>();
-        let content2 = buf2.content().iter().map(|c| c.symbol()).collect::<String>();
+        let content1 = buf1
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+        let content2 = buf2
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
         assert!(!content1.is_empty());
         assert!(!content2.is_empty());
     }
@@ -164,8 +185,10 @@ mod tests {
     #[test]
     fn test_scroll_padding() {
         let items = vec!["Item 1", "Item 2", "Item 3", "Item 4"];
-        let list = List::new(items).scroll_padding(1).highlight_symbol(Line::from(">> "));
-        
+        let list = List::new(items)
+            .scroll_padding(1)
+            .highlight_symbol(Line::from(">> "));
+
         let mut state = ListState::default();
         state.select(Some(1));
 

data/ext/ratatui_ruby/src/widgets/overlay.rs

@@ -12,7 +12,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for layers"))?;
 
     for i in 0..layers_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 layer: Value = layers_array.entry(index)?;
         if let Err(e) = render_node(frame, area, layer) {
             eprintln!("Error rendering overlay layer {i}: {e:?}");

data/ext/ratatui_ruby/src/widgets/paragraph.rs

@@ -12,7 +12,7 @@ use ratatui::{
 
 use crate::text::parse_text;
 
-fn create_paragraph<'a>(node: Value, bump: &'a Bump) -> Result<Paragraph<'a>, Error> {
+fn create_paragraph(node: Value, bump: &Bump) -> Result<Paragraph<'_>, Error> {
     let text_val: Value = node.funcall("text", ())?;
     let style_val: Value = node.funcall("style", ())?;
     let block_val: Value = node.funcall("block", ())?;

data/ext/ratatui_ruby/src/widgets/ratatui_logo.rs

@@ -1,27 +1,38 @@
-use magnus::{Error, Value};
-use ratatui::{layout::Rect, widgets::{RatatuiLogo, RatatuiLogoSize}, Frame};
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
 
-pub fn render(frame: &mut Frame, area: Rect, _node: Value) -> Result<(), Error> {
+use magnus::Value;
+use ratatui::{
+    layout::Rect,
+    widgets::{RatatuiLogo, RatatuiLogoSize},
+    Frame,
+};
+
+pub fn render(frame: &mut Frame, area: Rect, _node: Value) {
     // RatatuiLogo does not support custom styling (it has fixed colors).
     // It requires a size argument.
     let widget = RatatuiLogo::new(RatatuiLogoSize::Small);
     frame.render_widget(widget, area);
-    Ok(())
 }
 
 #[cfg(test)]
 mod tests {
-    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
     use super::*;
+    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
 
     #[test]
     fn test_render() {
         let mut buffer = Buffer::empty(Rect::new(0, 0, 50, 20));
         let widget = RatatuiLogo::new(RatatuiLogoSize::Small);
         widget.render(Rect::new(0, 0, 50, 20), &mut buffer);
-        
-        let content = buffer.content().iter().map(|c| c.symbol()).collect::<String>();
-        
+
+        let content = buffer
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+
         // The logo uses block characters for rendering
         assert!(content.contains('█'));
         assert!(!content.trim().is_empty());

data/ext/ratatui_ruby/src/widgets/ratatui_mascot.rs

@@ -1,11 +1,11 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
 use crate::style::parse_block;
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, Value};
-use ratatui::{
-    layout::Rect,
-    widgets::RatatuiMascot,
-    Frame,
-};
+use ratatui::{layout::Rect, widgets::RatatuiMascot, Frame};
 
 pub fn render_ratatui_mascot(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let block_val: Value = node.funcall("block", ())?;
@@ -26,19 +26,26 @@ pub fn render_ratatui_mascot(frame: &mut Frame, area: Rect, node: Value) -> Resu
 
 #[cfg(test)]
 mod tests {
-    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
     use super::*;
+    use ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
 
     #[test]
     fn test_render() {
         let mut buffer = Buffer::empty(Rect::new(0, 0, 50, 20));
         let widget = RatatuiMascot::new();
         widget.render(Rect::new(0, 0, 50, 20), &mut buffer);
-        
-        let content = buffer.content().iter().map(|c| c.symbol()).collect::<String>();
-        
+
+        let content = buffer
+            .content()
+            .iter()
+            .map(|c| c.symbol())
+            .collect::<String>();
+
         // The mascot uses block drawing characters
-        assert!(content.contains("█"), "Mascot rendering should contain block characters");
+        assert!(
+            content.contains("█"),
+            "Mascot rendering should contain block characters"
+        );
         assert!(!content.trim().is_empty());
     }
 }

data/ext/ratatui_ruby/src/widgets/scrollbar.rs

@@ -14,7 +14,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let content_length: usize = node.funcall("content_length", ())?;
     let position: usize = node.funcall("position", ())?;
     let orientation_sym: Symbol = node.funcall("orientation", ())?;
-    
+
     let thumb_symbol_val: Value = node.funcall("thumb_symbol", ())?;
     let thumb_style_val: Value = node.funcall("thumb_style", ())?;
     let track_symbol_val: Value = node.funcall("track_symbol", ())?;
@@ -32,7 +32,9 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     scrollbar = match orientation_sym.to_string().as_str() {
         "vertical_left" => scrollbar.orientation(ScrollbarOrientation::VerticalLeft),
-        "horizontal_bottom" | "horizontal" => scrollbar.orientation(ScrollbarOrientation::HorizontalBottom),
+        "horizontal_bottom" | "horizontal" => {
+            scrollbar.orientation(ScrollbarOrientation::HorizontalBottom)
+        }
         "horizontal_top" => scrollbar.orientation(ScrollbarOrientation::HorizontalTop),
         _ => scrollbar.orientation(ScrollbarOrientation::VerticalRight),
     };

data/ext/ratatui_ruby/src/widgets/sparkline.rs

@@ -1,10 +1,10 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use crate::style::{parse_block, parse_style, parse_bar_set};
+use crate::style::{parse_bar_set, parse_block, parse_style};
 use bumpalo::Bump;
 use magnus::{prelude::*, Error, RString, Value};
-use ratatui::{layout::Rect, widgets::Sparkline, widgets::RenderDirection, Frame};
+use ratatui::{layout::Rect, widgets::RenderDirection, widgets::Sparkline, Frame};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     let bump = Bump::new();
@@ -20,7 +20,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     let mut data_vec = Vec::new();
     for i in 0..data_val.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 val: Value = data_val.entry(index)?;
         if val.is_nil() {
             data_vec.push(None);
@@ -100,22 +101,24 @@ mod tests {
     fn test_sparkline_absent_value_symbol() {
         // Data with absent (None) and present values: [Some(5), None, Some(8), None]
         let data = vec![Some(5), None, Some(8), None];
-        let sparkline = Sparkline::default()
-            .data(&data)
-            .absent_value_symbol("-");
+        let sparkline = Sparkline::default().data(&data).absent_value_symbol("-");
         let mut buf = Buffer::empty(Rect::new(0, 0, 4, 1));
         sparkline.render(Rect::new(0, 0, 4, 1), &mut buf);
-        
+
         // Collect all rendered symbols
         let symbols: Vec<&str> = buf.content().iter().map(|c| c.symbol()).collect();
-        
+
         // Check that we have 4 cells rendered
-        assert_eq!(symbols.len(), 4, "Should have 4 cells rendered for 4 data points");
-        
+        assert_eq!(
+            symbols.len(),
+            4,
+            "Should have 4 cells rendered for 4 data points"
+        );
+
         // Absent values (None) should render as "-"
         assert_eq!(symbols[1], "-", "Second value (None) should render as dash");
         assert_eq!(symbols[3], "-", "Fourth value (None) should render as dash");
-        
+
         // Present values should not be dashes
         assert_ne!(symbols[0], "-", "First value (Some(5)) should not be dash");
         assert_ne!(symbols[2], "-", "Third value (Some(8)) should not be dash");

data/ext/ratatui_ruby/src/widgets/table.rs

@@ -33,7 +33,8 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
     let mut rows = Vec::new();
     for i in 0..rows_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 row_val: Value = rows_array.entry(index)?;
         rows.push(parse_row(row_val)?);
     }
@@ -120,7 +121,8 @@ fn parse_row(row_val: Value) -> Result<Row<'static>, Error> {
 
     let mut cells = Vec::new();
     for i in 0..row_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 cell_val: Value = row_array.entry(index)?;
         cells.push(parse_cell(cell_val)?);
     }
@@ -159,7 +161,8 @@ fn parse_cell(cell_val: Value) -> Result<Cell<'static>, Error> {
         if let Some(mods_array) = magnus::RArray::from_value(modifiers_val) {
             let ruby = magnus::Ruby::get().unwrap();
             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) = crate::style::parse_modifier_str(&mod_str) {
                     style = style.add_modifier(modifier);
@@ -177,7 +180,8 @@ fn parse_constraints(widths_array: magnus::RArray) -> Result<Vec<Constraint>, Er
     let ruby = magnus::Ruby::get().unwrap();
     let mut constraints = Vec::new();
     for i in 0..widths_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 constraint_obj: Value = widths_array.entry(index)?;
         let type_sym: Symbol = constraint_obj.funcall("type", ())?;
         let value_obj: Value = constraint_obj.funcall("value", ())?;

data/ext/ratatui_ruby/src/widgets/tabs.rs

@@ -15,7 +15,7 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
 
 use crate::text::parse_line;
 
-fn create_tabs<'a>(node: Value, bump: &'a Bump) -> Result<Tabs<'a>, Error> {
+fn create_tabs(node: Value, bump: &Bump) -> Result<Tabs<'_>, Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let titles_val: Value = node.funcall("titles", ())?;
     let selected_index: usize = node.funcall("selected_index", ())?;
@@ -30,7 +30,8 @@ fn create_tabs<'a>(node: Value, bump: &'a Bump) -> Result<Tabs<'a>, Error> {
 
     let mut titles = Vec::new();
     for i in 0..titles_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 val: Value = titles_array.entry(index)?;
         if let Ok(line) = parse_line(val) {
             titles.push(line);
@@ -81,10 +82,11 @@ pub fn width(node: Value) -> Result<usize, Error> {
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for titles"))?;
 
     let mut total_width = padding_left + padding_right;
-    
+
     let mut titles_count = 0;
     for i in 0..titles_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 val: Value = titles_array.entry(index)?;
         let line_width = if let Ok(line) = parse_line(val) {
             line.width()
@@ -97,11 +99,11 @@ pub fn width(node: Value) -> Result<usize, Error> {
     }
 
     if titles_count > 1 {
-        let divider_width = if !divider_val.is_nil() {
+        let divider_width = if divider_val.is_nil() {
+            1 // Default divider is "|"
+        } else {
             let d: String = divider_val.funcall("to_s", ())?;
             ratatui::text::Span::raw(d).width()
-        } else {
-            1 // Default divider is "|"
         };
         total_width += (titles_count - 1) * divider_width;
     }
@@ -134,10 +136,8 @@ mod tests {
     fn test_tabs_highlight_style() {
         let titles = vec![Line::from("Tab1"), Line::from("Tab2")];
         let highlight_style = Style::default().fg(Color::Red).add_modifier(Modifier::BOLD);
-        let tabs = Tabs::new(titles)
-            .select(0)
-            .highlight_style(highlight_style);
-        
+        let tabs = Tabs::new(titles).select(0).highlight_style(highlight_style);
+
         let mut buf = Buffer::empty(Rect::new(0, 0, 15, 1));
         tabs.render(Rect::new(0, 0, 15, 1), &mut buf);
 

data/lib/ratatui_ruby/cell.rb

@@ -67,7 +67,7 @@ module RatatuiRuby
     #   Cell.symbol("X") # => #<RatatuiRuby::Cell symbol="X">
     #
     def self.symbol(symbol)
-      new(symbol: symbol, fg: nil, bg: nil, modifiers: [])
+      new(symbol:, fg: nil, bg: nil, modifiers: [])
     end
 
     # Alias for Rubyists who prefer a shorter name.
@@ -149,7 +149,7 @@ module RatatuiRuby
       parts << "fg=#{fg.inspect}" if fg
       parts << "bg=#{bg.inspect}" if bg
       parts << "modifiers=#{modifiers.inspect}" unless modifiers.empty?
-      "#<#{self.class} #{parts.join(" ")}>"
+      "#<#{self.class} #{parts.join(' ')}>"
     end
 
     # Returns the cell's character.
@@ -160,7 +160,7 @@ module RatatuiRuby
     # Support for pattern matching.
     # Supports both <tt>:symbol</tt> and <tt>:char</tt> keys.
     def deconstruct_keys(keys)
-      { symbol: symbol, char: symbol, fg: fg, bg: bg, modifiers: modifiers }
+      { symbol:, char: symbol, fg:, bg:, modifiers: }
     end
   end
 end

data/lib/ratatui_ruby/event/key.rb

@@ -108,7 +108,7 @@ module RatatuiRuby
         if mods.empty?
           @code.to_sym
         else
-          "#{mods}_#{@code}".to_sym
+          :"#{mods}_#{@code}"
         end
       end
 

data/lib/ratatui_ruby/event/none.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class Event
+    # {Null object}[https://en.wikipedia.org/wiki/Null_object_pattern] for absent events.
+    #
+    # Event loops poll for input 60 times per second. Usually nothing is happening.
+    # If <tt>RatatuiRuby.poll_event</tt> returned <tt>nil</tt>, you would need
+    # nil-checks: <tt>event&.key?</tt>, <tt>next unless event</tt>.
+    #
+    # This class eliminates that friction. It responds to every predicate with
+    # <tt>false</tt>. Call <tt>none?</tt> to detect it explicitly. Pattern-match on
+    # <tt>type: :none</tt> for exhaustive dispatch.
+    #
+    # Use it to simplify your event loop. No guards. Optional `else` clauses.
+    #
+    # See Martin Fowler's {Special Case}[https://martinfowler.com/eaaCatalog/specialCase.html] pattern.
+    #
+    # === Predicate Example
+    #
+    #   event = RatatuiRuby.poll_event
+    #   break if event.ctrl_c?
+    #   redraw if event.none?
+    #
+    # === Pattern Matching Example
+    #
+    #   redraw if RatatuiRuby.poll_event in type: :none
+    class None < Event
+      # Returns true for None events.
+      def none?
+        true
+      end
+
+      # Deconstructs the event for pattern matching.
+      def deconstruct_keys(keys)
+        { type: :none }
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/event.rb

@@ -6,11 +6,63 @@
 module RatatuiRuby
   # Base class for all RatatuiRuby events.
   #
-  # Events are returned by RatatuiRuby.poll_event.
-  # All events support Ruby 3.0+ pattern matching via #deconstruct_keys.
+  # Events represent terminal input: keyboard, mouse, resize, paste, focus changes.
+  # Returned by RatatuiRuby.poll_event. All events support Ruby 3.0+ pattern matching.
   #
-  # See RatatuiRuby.poll_event
+  # == Event Types
+  #
+  # * <tt>Key</tt> — keyboard input
+  # * <tt>Mouse</tt> — mouse clicks, movement, wheel
+  # * <tt>Resize</tt> — terminal resized
+  # * <tt>Paste</tt> — clipboard paste
+  # * <tt>FocusGained</tt> — terminal gained focus
+  # * <tt>FocusLost</tt> — terminal lost focus
+  # * <tt>None</tt> — no event available (Null Object)
+  #
+  # == Pattern Matching (Exhaustive)
+  #
+  # Use <tt>case...in</tt> to dispatch on every possible event type. This ensures
+  # you handle every case without needing an +else+ clause:
+  #
+  #   case RatatuiRuby.poll_event
+  #   in { type: :key, code: "q" }
+  #     break
+  #   in { type: :key, code: code, modifiers: }
+  #     handle_key(code, modifiers)
+  #   in { type: :mouse, kind: "down", x:, y: }
+  #     handle_click(x, y)
+  #   in { type: :mouse, kind:, x:, y: }
+  #     # handle other mouse activities
+  #   in { type: :resize, width:, height: }
+  #     handle_resize(width, height)
+  #   in { type: :paste, content: }
+  #     handle_paste(content)
+  #   in { type: :focus_gained }
+  #     handle_focus_gain
+  #   in { type: :focus_lost }
+  #     handle_focus_loss
+  #   in { type: :none }
+  #     # Idle
+  #   end
+  #
+  # == Predicates
+  #
+  # Check event types with predicates without pattern matching:
+  #
+  #   event = RatatuiRuby.poll_event
+  #   if event.key?
+  #     puts "Key pressed"
+  #   elsif event.none?
+  #     # Idle
+  #   elsif event.mouse?
+  #     puts "Mouse event"
+  #   end
   class Event
+    # Returns true if this is a None event.
+    def none?
+      false
+    end
+
     # Returns true if this is a Key event.
     def key?
       false
@@ -67,10 +119,10 @@ module RatatuiRuby
     def deconstruct_keys(keys)
       {}
     end
-
   end
 end
 
+require_relative "event/none"
 require_relative "event/key"
 require_relative "event/mouse"
 require_relative "event/resize"