ratatui_ruby 1.4.0-x86_64-linux

data/ext/ratatui_ruby/src/style.rs

@@ -0,0 +1,469 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+//
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+use crate::errors::type_error_with_context;
+use bumpalo::Bump;
+use magnus::{prelude::*, Error, Symbol, Value};
+use ratatui::{
+    layout::Alignment,
+    style::{Color, Modifier, Style},
+    symbols,
+    text::Line,
+    widgets::{Block, BorderType, Borders, Padding},
+};
+
+use crate::text::parse_line;
+
+pub fn parse_color(color_str: &str) -> Option<Color> {
+    // 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> {
+    let ruby = magnus::Ruby::get().unwrap();
+    if style_val.is_nil() {
+        return Ok(Style::default());
+    }
+
+    let mut style = Style::default();
+
+    let (fg, bg, underline_color, modifiers_val, remove_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("underline_color"))
+                    .unwrap_or_else(|_| ruby.qnil().as_value()),
+                hash.lookup(ruby.to_symbol("modifiers"))
+                    .unwrap_or_else(|_| ruby.qnil().as_value()),
+                hash.lookup(ruby.to_symbol("remove_modifiers"))
+                    .unwrap_or_else(|_| ruby.qnil().as_value()),
+            )
+        } else {
+            (
+                style_val.funcall("fg", ())?,
+                style_val.funcall("bg", ())?,
+                style_val.funcall("underline_color", ())?,
+                style_val.funcall("modifiers", ())?,
+                style_val.funcall("remove_modifiers", ())?,
+            )
+        };
+
+    if !fg.is_nil() {
+        if let Ok(fg_str) = fg.funcall::<_, _, String>("to_s", ()) {
+            if let Some(color) = parse_color(&fg_str) {
+                style = style.fg(color);
+            }
+        }
+    }
+
+    if !bg.is_nil() {
+        if let Ok(bg_str) = bg.funcall::<_, _, String>("to_s", ()) {
+            if let Some(color) = parse_color(&bg_str) {
+                style = style.bg(color);
+            }
+        }
+    }
+
+    if !underline_color.is_nil() {
+        if let Ok(uc_str) = underline_color.funcall::<_, _, String>("to_s", ()) {
+            if let Some(color) = parse_color(&uc_str) {
+                style = style.underline_color(color);
+            }
+        }
+    }
+
+    if !modifiers_val.is_nil() {
+        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);
+                    }
+                }
+            }
+        }
+    }
+
+    if !remove_modifiers_val.is_nil() {
+        if let Some(remove_modifiers_array) = magnus::RArray::from_value(remove_modifiers_val) {
+            for i in 0..remove_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) = remove_modifiers_array.entry::<Symbol>(index) {
+                    if let Some(m) = parse_modifier_str(&sym.to_string()) {
+                        style = style.remove_modifier(m);
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(style)
+}
+
+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(|| type_error_with_context(&ruby, "expected hash for border_set", set_val))?;
+
+    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();
+
+    // Check if set_val is a symbol shortcut
+    if let Ok(sym) = magnus::Symbol::from_value(set_val)
+        .ok_or::<Error>(Error::new(ruby.exception_type_error(), ""))
+    {
+        let sym_str = sym.name().unwrap_or_default();
+        return match sym_str.as_ref() {
+            "nine_levels" => Ok(symbols::bar::NINE_LEVELS),
+            "three_levels" => Ok(symbols::bar::THREE_LEVELS),
+            _ => Err(Error::new(
+                ruby.exception_arg_error(),
+                format!("unknown bar_set symbol: :{sym_str}"),
+            )),
+        };
+    }
+
+    let hash = magnus::RHash::from_value(set_val).ok_or_else(|| {
+        type_error_with_context(&ruby, "expected symbol or hash for bar_set", set_val)
+    })?;
+
+    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 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 alignment = Alignment::Left;
+                let mut is_bottom = false;
+                let mut style = Style::default();
+                let mut line: Option<Line<'static>> = None;
+
+                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() {
+                            // First, try to parse as a Line object (preserves styling)
+                            if let Ok(parsed_line) = parse_line(v) {
+                                line = Some(parsed_line);
+                            } else {
+                                // Fallback to string
+                                let content: String = v.funcall("to_s", ())?;
+                                line = Some(Line::from(content));
+                            }
+                        }
+                    }
+                    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 {
+                    let content: String = title_item.funcall("to_s", ())?;
+                    line = Some(Line::from(content));
+                }
+
+                if let Some(mut l) = line {
+                    l = l.alignment(alignment);
+                    // Only apply style if the line doesn't already have styled spans
+                    if style != Style::default() {
+                        l = l.style(style);
+                    }
+                    block = if is_bottom {
+                        block.title_bottom(l)
+                    } else {
+                        block.title_top(l)
+                    };
+                }
+            }
+        }
+    }
+    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,
+                    _ => {}
+                }
+            } 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);
+        }
+    }
+
+    if let Ok(v) = block_val.funcall::<&str, _, Value>("border_style", ()) {
+        if !v.is_nil() {
+            block = block.border_style(parse_style(v)?);
+        }
+    }
+
+    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)
+}
+
+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
+}

data/ext/ratatui_ruby/src/terminal/capabilities.rs

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+//! Terminal capability detection functions.
+
+use magnus::{Error, Ruby};
+
+/// Returns color support level (8, 256, or `u16::MAX` for truecolor)
+///
+/// Wraps `crossterm::style::available_color_count()` which checks COLORTERM and TERM env vars.
+pub fn available_color_count() -> u16 {
+    ratatui::crossterm::style::available_color_count()
+}
+
+/// Query if terminal supports Kitty keyboard protocol
+///
+/// Note: This requires raw mode and may return errors in some environments.
+pub fn supports_keyboard_enhancement() -> Result<bool, Error> {
+    ratatui::crossterm::terminal::supports_keyboard_enhancement().map_err(|e| {
+        Error::new(
+            Ruby::get().unwrap().exception_runtime_error(),
+            e.to_string(),
+        )
+    })
+}
+
+/// Query terminal window size in characters and pixels
+///
+/// Wraps `crossterm::terminal::window_size()`. Returns
+/// Some((columns, rows, `pixel_width`, `pixel_height`)) or None if query fails.
+/// Note: Pixel dimensions may be 0 on some systems (marked as "unused" by Unix drivers,
+/// not implemented on Windows).
+pub fn terminal_window_size() -> Option<(u16, u16, u16, u16)> {
+    match ratatui::crossterm::terminal::window_size() {
+        Ok(size) => Some((size.columns, size.rows, size.width, size.height)),
+        Err(_) => None,
+    }
+}
+
+/// Globally override `NO_COLOR` detection
+///
+/// Wraps `crossterm::style::force_color_output()`. When enabled, color output will
+/// be forced even if `NO_COLOR` is set. Useful for `--color=always` flags.
+pub fn force_color_output(enable: bool) {
+    ratatui::crossterm::style::force_color_output(enable);
+}