ratatui_ruby 0.3.1 → 0.4.0

data/ext/ratatui_ruby/src/rendering.rs

@@ -1,29 +1,39 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
-use crate::buffer::BufferWrapper;
+use crate::style::{parse_color_value, parse_modifier_str, parse_style};
 use crate::widgets;
-use magnus::{prelude::*, Error, Value};
-use ratatui::{layout::Rect, Frame};
+use magnus::{prelude::*, Error, RArray, Value};
+use ratatui::{buffer::Buffer, layout::Rect, style::Style, Frame};
 
 pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
     if node.respond_to("render", true)? {
-        let wrapper = BufferWrapper::new(frame.buffer_mut());
         let ruby = magnus::Ruby::get().unwrap();
         let ruby_area = {
             let module = ruby.define_module("RatatuiRuby")?;
             let class = module.const_get::<_, magnus::RClass>("Rect")?;
             class.funcall::<_, _, Value>("new", (area.x, area.y, area.width, area.height))?
         };
-        let wrapper_obj = ruby.obj_wrap(wrapper);
-        node.funcall::<_, _, Value>("render", (ruby_area, wrapper_obj))?;
+
+        // Call render with just the area (no buffer!)
+        let commands: Value = node.funcall("render", (ruby_area,))?;
+
+        // Process returned draw commands
+        if let Some(arr) = RArray::from_value(commands) {
+            for i in 0..arr.len() {
+                let ruby = magnus::Ruby::get().unwrap();
+                let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                let cmd: Value = arr.entry(index)?;
+                process_draw_command(frame.buffer_mut(), cmd)?;
+            }
+        }
         return Ok(());
     }
 
-    let class = node.class();
-    let class_name = unsafe { class.name() };
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { node.class().name() }.into_owned();
 
-    match class_name.as_ref() {
+    match class_name.as_str() {
         "RatatuiRuby::Paragraph" => widgets::paragraph::render(frame, area, node)?,
         "RatatuiRuby::Clear" => widgets::clear::render(frame, area, node)?,
         "RatatuiRuby::Cursor" => widgets::cursor::render(frame, area, node)?,
@@ -32,6 +42,7 @@ pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Err
         "RatatuiRuby::Layout" => widgets::layout::render(frame, area, node)?,
         "RatatuiRuby::List" => widgets::list::render(frame, area, node)?,
         "RatatuiRuby::Gauge" => widgets::gauge::render(frame, area, node)?,
+        "RatatuiRuby::LineGauge" => widgets::line_gauge::render(frame, area, node)?,
         "RatatuiRuby::Table" => widgets::table::render(frame, area, node)?,
         "RatatuiRuby::Block" => widgets::block::render(frame, area, node)?,
         "RatatuiRuby::Tabs" => widgets::tabs::render(frame, area, node)?,
@@ -41,9 +52,78 @@ pub fn render_node(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Err
         "RatatuiRuby::Calendar" => widgets::calendar::render(frame, area, node)?,
         "RatatuiRuby::Sparkline" => widgets::sparkline::render(frame, area, node)?,
         "RatatuiRuby::Chart" | "RatatuiRuby::LineChart" => {
-            widgets::chart::render(frame, area, node)?
+            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)?,
         _ => {}
     }
     Ok(())
 }
+
+fn process_draw_command(buffer: &mut Buffer, cmd: Value) -> Result<(), Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    // SAFETY: Immediate conversion to owned string avoids GC-unsafe borrowed reference.
+    let class_name = unsafe { cmd.class().name() }.into_owned();
+
+    match class_name.as_str() {
+        "RatatuiRuby::Draw::StringCmd" => {
+            let x: u16 = cmd.funcall("x", ())?;
+            let y: u16 = cmd.funcall("y", ())?;
+            let string: String = cmd.funcall("string", ())?;
+            let style_val: Value = cmd.funcall("style", ())?;
+            let style = parse_style(style_val)?;
+            buffer.set_string(x, y, string, style);
+        }
+        "RatatuiRuby::Draw::CellCmd" => {
+            let x: u16 = cmd.funcall("x", ())?;
+            let y: u16 = cmd.funcall("y", ())?;
+            let cell_val: Value = cmd.funcall("cell", ())?;
+
+            let area = buffer.area;
+            if x >= area.x + area.width || y >= area.y + area.height {
+                return Ok(());
+            }
+
+            let symbol: String = cell_val.funcall("char", ())?;
+            let fg_val: Value = cell_val.funcall("fg", ())?;
+            let bg_val: Value = cell_val.funcall("bg", ())?;
+            let modifiers_val: Value = cell_val.funcall("modifiers", ())?;
+
+            let mut style = Style::default();
+
+            if !fg_val.is_nil() {
+                if let Some(color) = parse_color_value(fg_val)? {
+                    style = style.fg(color);
+                }
+            }
+            if !bg_val.is_nil() {
+                if let Some(color) = parse_color_value(bg_val)? {
+                    style = style.bg(color);
+                }
+            }
+
+            if let Some(mods_array) = RArray::from_value(modifiers_val) {
+                for i in 0..mods_array.len() {
+                    let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                    let mod_str: String = mods_array.entry::<String>(index)?;
+                    if let Some(modifier) = parse_modifier_str(&mod_str) {
+                        style = style.add_modifier(modifier);
+                    }
+                }
+            }
+
+            if let Some(cell) = buffer.cell_mut((x, y)) {
+                cell.set_symbol(&symbol).set_style(style);
+            }
+        }
+        _ => {
+            return Err(Error::new(
+                ruby.exception_type_error(),
+                format!("Unknown draw command: {class_name}"),
+            ));
+        }
+    }
+
+    Ok(())
+}

data/ext/ratatui_ruby/src/style.rs

@@ -1,14 +1,54 @@
-// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
-// SPDX-License-Identifier: AGPL-3.0-or-later
-
 use magnus::{prelude::*, Error, Symbol, Value};
 use ratatui::{
     style::{Color, Modifier, Style},
-    widgets::{Block, Borders},
+    text::Line,
+    widgets::{Block, BorderType, Borders, Padding},
+    layout::Alignment,
+    symbols,
 };
+use bumpalo::Bump;
 
 pub fn parse_color(color_str: &str) -> Option<Color> {
-    color_str.parse::<Color>().ok()
+    // Try standard ratatui parsing first (named colors, indexed, etc.)
+    if let Ok(color) = color_str.parse::<Color>() {
+        return Some(color);
+    }
+    
+    // Try hex parsing manually: #RRGGBB
+    let hex_str = color_str.trim();
+    if hex_str.starts_with('#') && hex_str.len() == 7 {
+        if let Ok(hex_val) = u32::from_str_radix(&hex_str[1..], 16) {
+            let r = ((hex_val >> 16) & 0xFF) as u8;
+            let g = ((hex_val >> 8) & 0xFF) as u8;
+            let b = (hex_val & 0xFF) as u8;
+            return Some(Color::Rgb(r, g, b));
+        }
+    }
+    
+    None
+}
+
+pub fn parse_color_value(val: Value) -> Result<Option<Color>, Error> {
+    if val.is_nil() {
+        return Ok(None);
+    }
+    let s: String = val.funcall("to_s", ())?;
+    Ok(parse_color(&s))
+}
+
+pub fn parse_modifier_str(s: &str) -> Option<Modifier> {
+    match s {
+        "bold" => Some(Modifier::BOLD),
+        "italic" => Some(Modifier::ITALIC),
+        "dim" => Some(Modifier::DIM),
+        "reversed" => Some(Modifier::REVERSED),
+        "underlined" => Some(Modifier::UNDERLINED),
+        "slow_blink" => Some(Modifier::SLOW_BLINK),
+        "rapid_blink" => Some(Modifier::RAPID_BLINK),
+        "crossed_out" => Some(Modifier::CROSSED_OUT),
+        "hidden" => Some(Modifier::HIDDEN),
+        _ => None,
+    }
 }
 
 pub fn parse_style(style_val: Value) -> Result<Style, Error> {
@@ -19,44 +59,45 @@ pub fn parse_style(style_val: Value) -> Result<Style, Error> {
 
     let mut style = Style::default();
 
-    let fg: Value = style_val.funcall("fg", ())?;
+    let (fg, bg, modifiers_val) = if let Some(hash) = magnus::RHash::from_value(style_val) {
+        (
+            hash.lookup(ruby.to_symbol("fg")).unwrap_or_else(|_| ruby.qnil().as_value()),
+            hash.lookup(ruby.to_symbol("bg")).unwrap_or_else(|_| ruby.qnil().as_value()),
+            hash.lookup(ruby.to_symbol("modifiers")).unwrap_or_else(|_| ruby.qnil().as_value()),
+        )
+    } else {
+        (
+            style_val.funcall("fg", ())?,
+            style_val.funcall("bg", ())?,
+            style_val.funcall("modifiers", ())?,
+        )
+    };
+
     if !fg.is_nil() {
-        let fg_str: String = fg.funcall("to_s", ())?;
-        if let Some(color) = parse_color(&fg_str) {
-            style = style.fg(color);
+        if let Ok(fg_str) = fg.funcall::<_, _, String>("to_s", ()) {
+            if let Some(color) = parse_color(&fg_str) {
+                style = style.fg(color);
+            }
         }
     }
 
-    let bg: Value = style_val.funcall("bg", ())?;
     if !bg.is_nil() {
-        let bg_str: String = bg.funcall("to_s", ())?;
-        if let Some(color) = parse_color(&bg_str) {
-            style = style.bg(color);
+        if let Ok(bg_str) = bg.funcall::<_, _, String>("to_s", ()) {
+            if let Some(color) = parse_color(&bg_str) {
+                style = style.bg(color);
+            }
         }
     }
 
-    let modifiers_val: Value = style_val.funcall("modifiers", ())?;
     if !modifiers_val.is_nil() {
-        let modifiers_array = magnus::RArray::from_value(modifiers_val).ok_or_else(|| {
-            Error::new(
-                ruby.exception_type_error(),
-                "expected array for modifiers",
-            )
-        })?;
-
-        for i in 0..modifiers_array.len() {
-            let sym: Symbol = modifiers_array.entry(i as isize)?;
-            match sym.to_string().as_str() {
-                "bold" => style = style.add_modifier(Modifier::BOLD),
-                "italic" => style = style.add_modifier(Modifier::ITALIC),
-                "dim" => style = style.add_modifier(Modifier::DIM),
-                "reversed" => style = style.add_modifier(Modifier::REVERSED),
-                "underlined" => style = style.add_modifier(Modifier::UNDERLINED),
-                "slow_blink" => style = style.add_modifier(Modifier::SLOW_BLINK),
-                "rapid_blink" => style = style.add_modifier(Modifier::RAPID_BLINK),
-                "crossed_out" => style = style.add_modifier(Modifier::CROSSED_OUT),
-                "hidden" => style = style.add_modifier(Modifier::HIDDEN),
-                _ => {}
+        if let Some(modifiers_array) = magnus::RArray::from_value(modifiers_val) {
+            for i in 0..modifiers_array.len() {
+                let index = isize::try_from(i).map_err(|e| Error::new(ruby.exception_range_error(), e.to_string()))?;
+                if let Ok(sym) = modifiers_array.entry::<Symbol>(index) {
+                    if let Some(m) = parse_modifier_str(&sym.to_string()) {
+                        style = style.add_modifier(m);
+                    }
+                }
             }
         }
     }
@@ -64,87 +105,229 @@ pub fn parse_style(style_val: Value) -> Result<Style, Error> {
     Ok(style)
 }
 
-pub fn parse_block(block_val: Value) -> Result<Block<'static>, Error> {
-    if block_val.is_nil() {
-        return Ok(Block::default());
-    }
+pub fn parse_border_set<'a>(set_val: Value, bump: &'a Bump) -> Result<symbols::border::Set<'a>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let hash = magnus::RHash::from_value(set_val).ok_or_else(|| {
+        Error::new(ruby.exception_type_error(), "expected hash for border_set")
+    })?;
 
-    let title: Value = block_val.funcall("title", ())?;
-    let borders_val: Value = block_val.funcall("borders", ())?;
-    let border_color: Value = block_val.funcall("border_color", ())?;
+    let get_char = |key: &str| -> Result<Option<&'a str>, Error> {
+        let mut val: Value = hash.lookup(ruby.to_symbol(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+        if val.is_nil() {
+            val = hash.lookup(ruby.str_new(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+        }
+        if val.is_nil() {
+            Ok(None)
+        } else {
+            let s: String = val.funcall("to_s", ())?;
+            Ok(Some(bump.alloc_str(&s)))
+        }
+    };
+
+    let mut set = symbols::border::Set::default();
+    if let Some(s) = get_char("top_left")? { set.top_left = s; }
+    if let Some(s) = get_char("top_right")? { set.top_right = s; }
+    if let Some(s) = get_char("bottom_left")? { set.bottom_left = s; }
+    if let Some(s) = get_char("bottom_right")? { set.bottom_right = s; }
+    if let Some(s) = get_char("vertical_left")? { set.vertical_left = s; }
+    if let Some(s) = get_char("vertical_right")? { set.vertical_right = s; }
+    if let Some(s) = get_char("horizontal_top")? { set.horizontal_top = s; }
+    if let Some(s) = get_char("horizontal_bottom")? { set.horizontal_bottom = s; }
+
+    Ok(set)
+}
+
+pub fn parse_bar_set<'a>(set_val: Value, bump: &'a Bump) -> Result<symbols::bar::Set<'a>, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let hash = magnus::RHash::from_value(set_val).ok_or_else(|| {
+        Error::new(ruby.exception_type_error(), "expected hash for bar_set")
+    })?;
+
+    let get_char = |key: &str| -> Result<Option<&'a str>, Error> {
+        let mut val: Value = hash.lookup(ruby.to_symbol(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+        if val.is_nil() {
+            val = hash.lookup(ruby.str_new(key)).unwrap_or_else(|_| ruby.qnil().as_value());
+        }
+        if val.is_nil() {
+            Ok(None)
+        } else {
+            let s: String = val.funcall("to_s", ())?;
+            Ok(Some(bump.alloc_str(&s)))
+        }
+    };
+
+    let mut set = symbols::bar::Set::default();
+    if let Some(s) = get_char("empty")? { set.empty = s; }
+    if let Some(s) = get_char("one_eighth")? { set.one_eighth = s; }
+    if let Some(s) = get_char("one_quarter")? { set.one_quarter = s; }
+    if let Some(s) = get_char("three_eighths")? { set.three_eighths = s; }
+    if let Some(s) = get_char("half")? { set.half = s; }
+    if let Some(s) = get_char("five_eighths")? { set.five_eighths = s; }
+    if let Some(s) = get_char("three_quarters")? { set.three_quarters = s; }
+    if let Some(s) = get_char("seven_eighths")? { set.seven_eighths = s; }
+    if let Some(s) = get_char("full")? { set.full = s; }
+
+    Ok(set)
+}
+
+pub fn parse_block(block_val: Value, bump: &Bump) -> Result<Block<'_>, Error> {
+    if block_val.is_nil() { return Ok(Block::default()); }
 
     let mut block = Block::default();
+    if let Ok(v) = block_val.funcall::<&str, _, Value>("style", ()) {
+        if !v.is_nil() { block = block.style(parse_style(v)?); }
+    }
 
-    if !title.is_nil() {
-        let title_str: String = title.funcall("to_s", ())?;
-        block = block.title(title_str);
-    }
-
-    if !borders_val.is_nil() {
-        let mut ratatui_borders = Borders::NONE;
-        if let Some(sym) = Symbol::from_value(borders_val) {
-            match sym.to_string().as_str() {
-                "all" => ratatui_borders = Borders::ALL,
-                "top" => ratatui_borders = Borders::TOP,
-                "bottom" => ratatui_borders = Borders::BOTTOM,
-                "left" => ratatui_borders = Borders::LEFT,
-                "right" => ratatui_borders = Borders::RIGHT,
-                _ => {}
+    if let Ok(v) = block_val.funcall::<&str, _, Value>("title_style", ()) {
+        if !v.is_nil() { block = block.title_style(parse_style(v)?); }
+    }
+
+    if let Ok(title) = block_val.funcall::<&str, _, Value>("title", ()) {
+        if !title.is_nil() { 
+            let s: String = title.funcall("to_s", ())?;
+            block = block.title(Line::from(s));
+        }
+    }
+
+    if let Ok(v) = block_val.funcall::<&str, _, Value>("title_alignment", ()) {
+        if let Some(align_sym) = Symbol::from_value(v) {
+            match align_sym.to_string().as_str() {
+                "center" => block = block.title_alignment(Alignment::Center),
+                "right" => block = block.title_alignment(Alignment::Right),
+                _ => block = block.title_alignment(Alignment::Left),
+            }
+        }
+    }
+
+    block = parse_titles(block_val, block)?;
+    block = parse_borders(block_val, block, bump)?;
+    block = parse_padding(block_val, block);
+
+    Ok(block)
+}
+
+fn parse_titles(block_val: Value, mut block: Block<'_>) -> Result<Block<'_>, Error> {
+    if let Ok(titles_val) = block_val.funcall::<&str, _, Value>("titles", ()) {
+        if titles_val.is_nil() { return Ok(block); }
+        if let Some(titles_array) = magnus::RArray::from_value(titles_val) {
+            for i in 0..titles_array.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 title_item: Value = titles_array.entry(index)?;
+                let mut content = String::new();
+                let mut alignment = Alignment::Left;
+                let mut is_bottom = false;
+                let mut style = Style::default();
+
+                if let Some(hash) = magnus::RHash::from_value(title_item) {
+                    if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("content")) { 
+                        if !v.is_nil() { content = v.funcall("to_s", ())?; }
+                    }
+                    if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("alignment")) {
+                        if let Some(s) = Symbol::from_value(v) {
+                            match s.to_string().as_str() {
+                                "center" => alignment = Alignment::Center,
+                                "right" => alignment = Alignment::Right,
+                                _ => {}
+                            }
+                        }
+                    }
+                    if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("position")) {
+                        if let Some(s) = Symbol::from_value(v) {
+                            if s.to_string().as_str() == "bottom" { is_bottom = true; }
+                        }
+                    }
+                    if let Ok(v) = hash.lookup::<_, Value>(ruby.to_symbol("style")) { 
+                        if !v.is_nil() { style = parse_style(v)?; }
+                    }
+                } else {
+                    content = title_item.funcall("to_s", ())?;
+                }
+
+                let line = Line::from(content).alignment(alignment).style(style);
+                block = if is_bottom { block.title_bottom(line) } else { block.title_top(line) };
             }
-        } else if let Some(borders_array) = magnus::RArray::from_value(borders_val) {
-            for i in 0..borders_array.len() {
-                let sym: Symbol = borders_array.entry(i as isize)?;
+        }
+    }
+    Ok(block)
+}
+
+fn parse_borders<'a>(block_val: Value, mut block: Block<'a>, bump: &'a Bump) -> Result<Block<'a>, Error> {
+    if let Ok(borders_val) = block_val.funcall::<&str, _, Value>("borders", ()) {
+        if !borders_val.is_nil() {
+            let mut ratatui_borders = Borders::NONE;
+            if let Some(sym) = Symbol::from_value(borders_val) {
                 match sym.to_string().as_str() {
-                    "all" => ratatui_borders |= Borders::ALL,
-                    "top" => ratatui_borders |= Borders::TOP,
-                    "bottom" => ratatui_borders |= Borders::BOTTOM,
-                    "left" => ratatui_borders |= Borders::LEFT,
-                    "right" => ratatui_borders |= Borders::RIGHT,
+                    "all" => ratatui_borders = Borders::ALL,
+                    "top" => ratatui_borders = Borders::TOP,
+                    "bottom" => ratatui_borders = Borders::BOTTOM,
+                    "left" => ratatui_borders = Borders::LEFT,
+                    "right" => ratatui_borders = Borders::RIGHT,
                     _ => {}
                 }
+            } else if let Some(arr) = magnus::RArray::from_value(borders_val) {
+                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 sym: Symbol = arr.entry(index)?;
+                    match sym.to_string().as_str() {
+                        "all" => ratatui_borders |= Borders::ALL,
+                        "top" => ratatui_borders |= Borders::TOP,
+                        "bottom" => ratatui_borders |= Borders::BOTTOM,
+                        "left" => ratatui_borders |= Borders::LEFT,
+                        "right" => ratatui_borders |= Borders::RIGHT,
+                        _ => {}
+                    }
+                }
             }
+            block = block.borders(ratatui_borders);
         }
-        block = block.borders(ratatui_borders);
     }
 
-    if !border_color.is_nil() {
-        let color_str: String = border_color.funcall("to_s", ())?;
-        if let Some(color) = parse_color(&color_str) {
-            block = block.border_style(Style::default().fg(color));
+    if let Ok(v) = block_val.funcall::<&str, _, Value>("border_style", ()) {
+        if !v.is_nil() { block = block.border_style(parse_style(v)?); }
+        else if let Ok(color_val) = block_val.funcall::<&str, _, Value>("border_color", ()) {
+            if !color_val.is_nil() {
+                if let Ok(s) = color_val.funcall::<&str, _, String>("to_s", ()) {
+                    if let Some(c) = parse_color(&s) { block = block.border_style(Style::default().fg(c)); }
+                }
+            }
         }
     }
 
+    if let Ok(v) = block_val.funcall::<&str, _, Value>("border_set", ()) {
+        if !v.is_nil() { block = block.border_set(parse_border_set(v, bump)?); }
+        else if let Ok(v) = block_val.funcall::<&str, _, Value>("border_type", ()) {
+            if let Some(sym) = Symbol::from_value(v) {
+                match sym.to_string().as_str() {
+                    "rounded" => block = block.border_type(BorderType::Rounded),
+                    "double" => block = block.border_type(BorderType::Double),
+                    "thick" => block = block.border_type(BorderType::Thick),
+                    "quadrant_inside" => block = block.border_type(BorderType::QuadrantInside),
+                    "quadrant_outside" => block = block.border_type(BorderType::QuadrantOutside),
+                    _ => block = block.border_type(BorderType::Plain),
+                }
+            }
+        }
+    }
     Ok(block)
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_color() {
-        assert_eq!(parse_color("red"), Some(Color::Red));
-        assert_eq!(parse_color("blue"), Some(Color::Blue));
-        assert_eq!(parse_color("black"), Some(Color::Black));
-        assert_eq!(parse_color("white"), Some(Color::White));
-        assert_eq!(parse_color("green"), Some(Color::Green));
-        assert_eq!(parse_color("yellow"), Some(Color::Yellow));
-        assert_eq!(parse_color("magenta"), Some(Color::Magenta));
-        assert_eq!(parse_color("cyan"), Some(Color::Cyan));
-        assert_eq!(parse_color("gray"), Some(Color::Gray));
-        assert_eq!(parse_color("dark_gray"), Some(Color::DarkGray));
-        assert_eq!(parse_color("light_red"), Some(Color::LightRed));
-        assert_eq!(parse_color("light_green"), Some(Color::LightGreen));
-        assert_eq!(parse_color("light_yellow"), Some(Color::LightYellow));
-        assert_eq!(parse_color("light_blue"), Some(Color::LightBlue));
-        assert_eq!(parse_color("light_magenta"), Some(Color::LightMagenta));
-        assert_eq!(parse_color("light_cyan"), Some(Color::LightCyan));
-
-        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("#FF0000"), Some(Color::Rgb(255, 0, 0)));
-
-        assert_eq!(parse_color("invalid"), None);
-        assert_eq!(parse_color(""), None);
+fn parse_padding(block_val: Value, block: Block<'_>) -> Block<'_> {
+    if let Ok(padding_val) = block_val.funcall::<&str, _, Value>("padding", ()) {
+        if padding_val.is_nil() { return block; }
+        if let Ok(p) = u16::try_convert(padding_val) {
+            return block.padding(Padding::uniform(p));
+        }
+        if let Some(arr) = magnus::RArray::from_value(padding_val) {
+            if arr.len() == 4 {
+                let left: u16 = arr.entry(0).unwrap_or(0);
+                let right: u16 = arr.entry(1).unwrap_or(0);
+                let top: u16 = arr.entry(2).unwrap_or(0);
+                let bottom: u16 = arr.entry(3).unwrap_or(0);
+                return block.padding(Padding::new(left, right, top, bottom));
+            }
+        }
     }
+    block
 }