ratatui_ruby 0.3.1 → 0.5.0

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

@@ -0,0 +1,40 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+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);
+}
+
+#[cfg(test)]
+mod tests {
+    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>();
+
+        // The logo uses block characters for rendering
+        assert!(content.contains('█'));
+        assert!(!content.trim().is_empty());
+    }
+}

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

@@ -0,0 +1,51 @@
+// 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};
+
+pub fn render_ratatui_mascot(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let block_val: Value = node.funcall("block", ())?;
+
+    let mut inner_area = area;
+
+    if !block_val.is_nil() {
+        let bump = Bump::new();
+        let block = parse_block(block_val, &bump)?;
+        inner_area = block.inner(area);
+        frame.render_widget(block, area);
+    }
+
+    let widget = RatatuiMascot::new();
+    frame.render_widget(widget, inner_area);
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    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>();
+
+        // The mascot uses block drawing characters
+        assert!(
+            content.contains("█"),
+            "Mascot rendering should contain block characters"
+        );
+        assert!(!content.trim().is_empty());
+    }
+}

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

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::parse_block;
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, Value};
 use ratatui::{
     layout::Rect,
@@ -13,24 +14,77 @@ 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: String = node.funcall("thumb_symbol", ())?;
+
+    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", ())?;
+    let track_style_val: Value = node.funcall("track_style", ())?;
+    let begin_symbol_val: Value = node.funcall("begin_symbol", ())?;
+    let begin_style_val: Value = node.funcall("begin_style", ())?;
+    let end_symbol_val: Value = node.funcall("end_symbol", ())?;
+    let end_style_val: Value = node.funcall("end_style", ())?;
+    let style_val: Value = node.funcall("style", ())?;
+
     let block_val: Value = node.funcall("block", ())?;
 
     let mut state = ScrollbarState::new(content_length).position(position);
-    let mut scrollbar = Scrollbar::default().thumb_symbol(&thumb_symbol);
+    let mut scrollbar = Scrollbar::default();
 
     scrollbar = match orientation_sym.to_string().as_str() {
-        "horizontal" => scrollbar.orientation(ScrollbarOrientation::HorizontalBottom),
+        "vertical_left" => scrollbar.orientation(ScrollbarOrientation::VerticalLeft),
+        "horizontal_bottom" | "horizontal" => {
+            scrollbar.orientation(ScrollbarOrientation::HorizontalBottom)
+        }
+        "horizontal_top" => scrollbar.orientation(ScrollbarOrientation::HorizontalTop),
         _ => scrollbar.orientation(ScrollbarOrientation::VerticalRight),
     };
 
-    if !block_val.is_nil() {
-        let block = parse_block(block_val)?;
+    // Hoisted strings to extend lifetime
+    let thumb_str: String;
+    let track_str: String;
+    let begin_str: String;
+    let end_str: String;
+
+    if !thumb_symbol_val.is_nil() {
+        thumb_str = thumb_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.thumb_symbol(&thumb_str);
+    }
+    if !thumb_style_val.is_nil() {
+        scrollbar = scrollbar.thumb_style(crate::style::parse_style(thumb_style_val)?);
+    }
+    if !track_symbol_val.is_nil() {
+        track_str = track_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.track_symbol(Some(&track_str));
+    }
+    if !track_style_val.is_nil() {
+        scrollbar = scrollbar.track_style(crate::style::parse_style(track_style_val)?);
+    }
+    if !begin_symbol_val.is_nil() {
+        begin_str = begin_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.begin_symbol(Some(&begin_str));
+    }
+    if !begin_style_val.is_nil() {
+        scrollbar = scrollbar.begin_style(crate::style::parse_style(begin_style_val)?);
+    }
+    if !end_symbol_val.is_nil() {
+        end_str = end_symbol_val.funcall("to_s", ())?;
+        scrollbar = scrollbar.end_symbol(Some(&end_str));
+    }
+    if !end_style_val.is_nil() {
+        scrollbar = scrollbar.end_style(crate::style::parse_style(end_style_val)?);
+    }
+    if !style_val.is_nil() {
+        scrollbar = scrollbar.style(crate::style::parse_style(style_val)?);
+    }
+
+    if block_val.is_nil() {
+        frame.render_stateful_widget(scrollbar, area, &mut state);
+    } else {
+        let bump = Bump::new();
+        let block = parse_block(block_val, &bump)?;
         let inner_area = block.inner(area);
         frame.render_widget(block, area);
         frame.render_stateful_widget(scrollbar, inner_area, &mut state);
-    } else {
-        frame.render_stateful_widget(scrollbar, area, &mut state);
     }
     Ok(())
 }

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

@@ -1,20 +1,34 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use crate::style::{parse_block, parse_style};
-use magnus::{prelude::*, Error, Value};
-use ratatui::{layout::Rect, widgets::Sparkline, Frame};
+use crate::style::{parse_bar_set, parse_block, parse_style};
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, RString, Value};
+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();
+    let ruby = magnus::Ruby::get().unwrap();
     let data_val: magnus::RArray = node.funcall("data", ())?;
     let max_val: Value = node.funcall("max", ())?;
     let style_val: Value = node.funcall("style", ())?;
     let block_val: Value = node.funcall("block", ())?;
+    let direction_val: Value = node.funcall("direction", ())?;
+    let absent_value_symbol_val: Value = node.funcall("absent_value_symbol", ())?;
+    let absent_value_style_val: Value = node.funcall("absent_value_style", ())?;
+    let bar_set_val: Value = node.funcall("bar_set", ())?;
 
     let mut data_vec = Vec::new();
     for i in 0..data_val.len() {
-        let val: u64 = data_val.entry(i as isize)?;
-        data_vec.push(val);
+        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);
+        } else {
+            let num: u64 = u64::try_convert(val)?;
+            data_vec.push(Some(num));
+        }
     }
 
     let mut sparkline = Sparkline::default().data(&data_vec);
@@ -29,7 +43,33 @@ pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     }
 
     if !block_val.is_nil() {
-        sparkline = sparkline.block(parse_block(block_val)?);
+        sparkline = sparkline.block(parse_block(block_val, &bump)?);
+    }
+
+    if !direction_val.is_nil() {
+        let direction_sym: RString = direction_val.funcall("to_s", ())?;
+        let direction_str = direction_sym.to_string()?;
+        let direction = match direction_str.as_str() {
+            "right_to_left" => RenderDirection::RightToLeft,
+            _ => RenderDirection::LeftToRight,
+        };
+        sparkline = sparkline.direction(direction);
+    }
+
+    if !absent_value_symbol_val.is_nil() {
+        let symbol_str: String = String::try_convert(absent_value_symbol_val)?;
+        // Only use the first character if multiple are provided
+        if let Some(first_char) = symbol_str.chars().next() {
+            sparkline = sparkline.absent_value_symbol(first_char);
+        }
+    }
+
+    if !absent_value_style_val.is_nil() {
+        sparkline = sparkline.absent_value_style(parse_style(absent_value_style_val)?);
+    }
+
+    if !bar_set_val.is_nil() {
+        sparkline = sparkline.bar_set(parse_bar_set(bar_set_val, &bump)?);
     }
 
     frame.render_widget(sparkline, area);
@@ -56,4 +96,31 @@ mod tests {
         let bars = buf.content().iter().filter(|c| c.symbol() != " ").count();
         assert_eq!(bars, 4);
     }
+
+    #[test]
+    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 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"
+        );
+
+        // 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

@@ -2,116 +2,226 @@
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
 use crate::style::{parse_block, parse_style};
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, Value};
 use ratatui::{
-    layout::{Constraint, Rect},
-    widgets::{Cell, Row, Table, TableState},
+    layout::{Constraint, Flex, Rect},
+    widgets::{Cell, HighlightSpacing, Row, Table, TableState},
     Frame,
 };
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
     let ruby = magnus::Ruby::get().unwrap();
     let header_val: Value = node.funcall("header", ())?;
-    let rows_val: Value = node.funcall("rows", ())?;
-    let rows_array = magnus::RArray::from_value(rows_val)
+    let footer_val: Value = node.funcall("footer", ())?;
+    let rows_value: Value = node.funcall("rows", ())?;
+    let rows_array = magnus::RArray::from_value(rows_value)
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for rows"))?;
     let widths_val: Value = node.funcall("widths", ())?;
     let widths_array = magnus::RArray::from_value(widths_val)
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for widths"))?;
     let highlight_style_val: Value = node.funcall("highlight_style", ())?;
+    let column_highlight_style_val: Value = node.funcall("column_highlight_style", ())?;
+    let cell_highlight_style_val: Value = node.funcall("cell_highlight_style", ())?;
     let highlight_symbol_val: Value = node.funcall("highlight_symbol", ())?;
     let selected_row_val: Value = node.funcall("selected_row", ())?;
+    let selected_column_val: Value = node.funcall("selected_column", ())?;
     let block_val: Value = node.funcall("block", ())?;
+    let flex_sym: Symbol = node.funcall("flex", ())?;
+    let highlight_spacing_sym: Symbol = node.funcall("highlight_spacing", ())?;
 
     let mut rows = Vec::new();
     for i in 0..rows_array.len() {
-        let row_val: Value = rows_array.entry(i as isize)?;
-        let row_array = magnus::RArray::from_value(row_val)
-            .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for row"))?;
-
-        let mut cells = Vec::new();
-        for j in 0..row_array.len() {
-            let cell_val: Value = row_array.entry(j as isize)?;
-            let class = cell_val.class();
-            let class_name = unsafe { class.name() };
-
-            if class_name.as_ref() == "RatatuiRuby::Paragraph" {
-                let text: String = cell_val.funcall("text", ())?;
-                let style_val: Value = cell_val.funcall("style", ())?;
-                let cell_style = parse_style(style_val)?;
-                cells.push(Cell::from(text).style(cell_style));
-            } else if class_name.as_ref() == "RatatuiRuby::Style" {
-                cells.push(Cell::from("").style(parse_style(cell_val)?));
-            } else {
-                let cell_str: String = cell_val.funcall("to_s", ())?;
-                cells.push(Cell::from(cell_str));
-            }
-        }
-        rows.push(Row::new(cells));
+        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)?);
     }
 
-    let mut constraints = Vec::new();
-    for i in 0..widths_array.len() {
-        let constraint_obj: Value = widths_array.entry(i as isize)?;
-        let type_sym: Symbol = constraint_obj.funcall("type", ())?;
-        let value: u16 = constraint_obj.funcall("value", ())?;
+    let constraints = parse_constraints(widths_array)?;
 
-        match type_sym.to_string().as_str() {
-            "length" => constraints.push(Constraint::Length(value)),
-            "percentage" => constraints.push(Constraint::Percentage(value)),
-            "min" => constraints.push(Constraint::Min(value)),
-            _ => {}
-        }
-    }
+    let flex = match flex_sym.to_string().as_str() {
+        "start" => Flex::Start,
+        "center" => Flex::Center,
+        "end" => Flex::End,
+        "space_between" => Flex::SpaceBetween,
+        "space_around" => Flex::SpaceAround,
+        "space_evenly" => Flex::SpaceEvenly,
+        _ => Flex::Legacy,
+    };
 
-    let mut table = Table::new(rows, constraints);
+    let mut table = Table::new(rows, constraints).flex(flex);
+
+    let highlight_spacing = match highlight_spacing_sym.to_string().as_str() {
+        "always" => HighlightSpacing::Always,
+        "never" => HighlightSpacing::Never,
+        _ => HighlightSpacing::WhenSelected,
+    };
+    table = table.highlight_spacing(highlight_spacing);
 
     if !header_val.is_nil() {
-        let header_array = magnus::RArray::from_value(header_val).ok_or_else(|| {
-            Error::new(ruby.exception_type_error(), "expected array for header")
-        })?;
-        let mut header_cells = Vec::new();
-        for i in 0..header_array.len() {
-            let cell_val: Value = header_array.entry(i as isize)?;
-            let class = cell_val.class();
-            let class_name = unsafe { class.name() };
-
-            if class_name.as_ref() == "RatatuiRuby::Paragraph" {
-                let text: String = cell_val.funcall("text", ())?;
-                let style_val: Value = cell_val.funcall("style", ())?;
-                let cell_style = parse_style(style_val)?;
-                header_cells.push(Cell::from(text).style(cell_style));
-            } else {
-                let cell_str: String = cell_val.funcall("to_s", ())?;
-                header_cells.push(Cell::from(cell_str));
-            }
-        }
-        table = table.header(Row::new(header_cells));
+        table = table.header(parse_row(header_val)?);
+    }
+
+    if !footer_val.is_nil() {
+        table = table.footer(parse_row(footer_val)?);
     }
 
     if !block_val.is_nil() {
-        table = table.block(parse_block(block_val)?);
+        table = table.block(parse_block(block_val, &bump)?);
     }
 
     if !highlight_style_val.is_nil() {
         table = table.row_highlight_style(parse_style(highlight_style_val)?);
     }
 
+    if !column_highlight_style_val.is_nil() {
+        table = table.column_highlight_style(parse_style(column_highlight_style_val)?);
+    }
+
+    if !cell_highlight_style_val.is_nil() {
+        table = table.cell_highlight_style(parse_style(cell_highlight_style_val)?);
+    }
+
     if !highlight_symbol_val.is_nil() {
         let symbol: String = highlight_symbol_val.funcall("to_s", ())?;
         table = table.highlight_symbol(symbol);
     }
 
+    let style_val: Value = node.funcall("style", ())?;
+    if !style_val.is_nil() {
+        table = table.style(parse_style(style_val)?);
+    }
+
+    let column_spacing_val: Value = node.funcall("column_spacing", ())?;
+    if !column_spacing_val.is_nil() {
+        let spacing: u16 = column_spacing_val.funcall("to_int", ())?;
+        table = table.column_spacing(spacing);
+    }
+
     let mut state = TableState::default();
     if !selected_row_val.is_nil() {
         let index: usize = selected_row_val.funcall("to_int", ())?;
         state.select(Some(index));
     }
+    if !selected_column_val.is_nil() {
+        let index: usize = selected_column_val.funcall("to_int", ())?;
+        state.select_column(Some(index));
+    }
 
     frame.render_stateful_widget(table, area, &mut state);
     Ok(())
 }
 
+fn parse_row(row_val: Value) -> Result<Row<'static>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let row_array = magnus::RArray::from_value(row_val)
+        .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for row"))?;
+
+    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 cell_val: Value = row_array.entry(index)?;
+        cells.push(parse_cell(cell_val)?);
+    }
+    Ok(Row::new(cells))
+}
+
+fn parse_cell(cell_val: Value) -> Result<Cell<'static>, Error> {
+    let class = cell_val.class();
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { class.name() }.into_owned();
+
+    if class_name == "RatatuiRuby::Paragraph" {
+        let text: String = cell_val.funcall("text", ())?;
+        let style_val: Value = cell_val.funcall("style", ())?;
+        let cell_style = parse_style(style_val)?;
+        Ok(Cell::from(text).style(cell_style))
+    } else if class_name == "RatatuiRuby::Style" {
+        Ok(Cell::from("").style(parse_style(cell_val)?))
+    } else if class_name == "RatatuiRuby::Cell" {
+        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 = ratatui::style::Style::default();
+        if !fg_val.is_nil() {
+            if let Some(color) = crate::style::parse_color_value(fg_val)? {
+                style = style.fg(color);
+            }
+        }
+        if !bg_val.is_nil() {
+            if let Some(color) = crate::style::parse_color_value(bg_val)? {
+                style = style.bg(color);
+            }
+        }
+        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 mod_str: String = mods_array.entry::<String>(index)?;
+                if let Some(modifier) = crate::style::parse_modifier_str(&mod_str) {
+                    style = style.add_modifier(modifier);
+                }
+            }
+        }
+        Ok(Cell::from(symbol).style(style))
+    } else {
+        let cell_str: String = cell_val.funcall("to_s", ())?;
+        Ok(Cell::from(cell_str))
+    }
+}
+
+fn parse_constraints(widths_array: magnus::RArray) -> Result<Vec<Constraint>, Error> {
+    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 constraint_obj: Value = widths_array.entry(index)?;
+        let type_sym: Symbol = constraint_obj.funcall("type", ())?;
+        let value_obj: Value = constraint_obj.funcall("value", ())?;
+
+        match type_sym.to_string().as_str() {
+            "length" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Length(val));
+            }
+            "percentage" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Percentage(val));
+            }
+            "min" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Min(val));
+            }
+            "max" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Max(val));
+            }
+            "fill" => {
+                let val = u16::try_convert(value_obj)?;
+                constraints.push(Constraint::Fill(val));
+            }
+            "ratio" => {
+                if let Some(arr) = magnus::RArray::from_value(value_obj) {
+                    if arr.len() == 2 {
+                        let n = u32::try_convert(arr.entry(0)?)?;
+                        let d = u32::try_convert(arr.entry(1)?)?;
+                        constraints.push(Constraint::Ratio(n, d));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    Ok(constraints)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -122,14 +232,17 @@ mod tests {
     fn test_table_rendering() {
         let rows = vec![Row::new(vec!["C1", "C2"])];
         let table = Table::new(rows, [Constraint::Length(3), Constraint::Length(3)])
-            .header(Row::new(vec!["H1", "H2"]));
-        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 2));
-        Widget::render(table, Rect::new(0, 0, 10, 2), &mut buf);
+            .header(Row::new(vec!["H1", "H2"]))
+            .footer(Row::new(vec!["F1", "F2"]));
+        let mut buf = Buffer::empty(Rect::new(0, 0, 10, 3));
+        Widget::render(table, Rect::new(0, 0, 10, 3), &mut buf);
 
         let content = buf.content().iter().map(|c| c.symbol()).collect::<String>();
         // Check for presence of header and row content
         assert!(content.contains("H1"));
         assert!(content.contains("H2"));
+        assert!(content.contains("F1"));
+        assert!(content.contains("F2"));
         assert!(content.contains("C1"));
         assert!(content.contains("C2"));
     }