ratatui_ruby 0.3.1 → 0.5.0

data/ext/ratatui_ruby/src/style.rs

@@ -1,14 +1,58 @@
 // SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
 // SPDX-License-Identifier: AGPL-3.0-or-later
 
+use bumpalo::Bump;
 use magnus::{prelude::*, Error, Symbol, Value};
 use ratatui::{
+    layout::Alignment,
     style::{Color, Modifier, Style},
-    widgets::{Block, Borders},
+    symbols,
+    text::Line,
+    widgets::{Block, BorderType, Borders, Padding},
 };
 
 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 +63,49 @@ 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 +113,302 @@ pub fn parse_style(style_val: Value) -> Result<Style, Error> {
     Ok(style)
 }
 
-pub fn parse_block(block_val: Value) -> Result<Block<'static>, Error> {
+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 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 title: Value = block_val.funcall("title", ())?;
-    let borders_val: Value = block_val.funcall("borders", ())?;
-    let border_color: Value = block_val.funcall("border_color", ())?;
-
     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 let Ok(v) = block_val.funcall::<&str, _, Value>("title_style", ()) {
+        if !v.is_nil() {
+            block = block.title_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(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),
             }
-        } 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)?;
+        }
+    }
+
+    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)
+                };
+            }
+        }
+    }
+    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
 }