ratatui_ruby 0.3.1 → 0.4.0

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

@@ -2,38 +2,118 @@
 // 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, text::Line, widgets::Tabs, Frame};
 
 pub fn render(frame: &mut Frame, area: Rect, node: Value) -> Result<(), Error> {
+    let bump = Bump::new();
+    let tabs = create_tabs(node, &bump)?;
+    frame.render_widget(tabs, area);
+    Ok(())
+}
+
+use crate::text::parse_line;
+
+fn create_tabs<'a>(node: Value, bump: &'a Bump) -> Result<Tabs<'a>, Error> {
     let ruby = magnus::Ruby::get().unwrap();
     let titles_val: Value = node.funcall("titles", ())?;
     let selected_index: usize = node.funcall("selected_index", ())?;
     let block_val: Value = node.funcall("block", ())?;
+    let divider_val: Value = node.funcall("divider", ())?;
+    let highlight_style_val: Value = node.funcall("highlight_style", ())?;
+    let padding_left: usize = node.funcall("padding_left", ())?;
+    let padding_right: usize = node.funcall("padding_right", ())?;
 
     let titles_array = magnus::RArray::from_value(titles_val)
         .ok_or_else(|| Error::new(ruby.exception_type_error(), "expected array for titles"))?;
 
     let mut titles = Vec::new();
     for i in 0..titles_array.len() {
-        let title: String = titles_array.entry(i as isize)?;
-        titles.push(Line::from(title));
+        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);
+        } else {
+            let s: String = String::try_convert(val)?;
+            titles.push(Line::from(s));
+        }
     }
 
     let mut tabs = Tabs::new(titles).select(selected_index);
 
+    if !divider_val.is_nil() {
+        let divider: String = divider_val.funcall("to_s", ())?;
+        tabs = tabs.divider(divider);
+    }
+
+    if !highlight_style_val.is_nil() {
+        let style = crate::style::parse_style(highlight_style_val)?;
+        tabs = tabs.highlight_style(style);
+    }
+
+    let style_val: Value = node.funcall("style", ())?;
+    if !style_val.is_nil() {
+        tabs = tabs.style(crate::style::parse_style(style_val)?);
+    }
+
     if !block_val.is_nil() {
-        tabs = tabs.block(parse_block(block_val)?);
+        tabs = tabs.block(parse_block(block_val, bump)?);
     }
 
-    frame.render_widget(tabs, area);
-    Ok(())
+    if padding_left > 0 || padding_right > 0 {
+        let left_str = " ".repeat(padding_left);
+        let right_str = " ".repeat(padding_right);
+        tabs = tabs.padding(left_str, right_str);
+    }
+
+    Ok(tabs)
+}
+
+pub fn width(node: Value) -> Result<usize, Error> {
+    let ruby = magnus::Ruby::get().unwrap();
+    let titles_val: Value = node.funcall("titles", ())?;
+    let divider_val: Value = node.funcall("divider", ())?;
+    let padding_left: usize = node.funcall("padding_left", ())?;
+    let padding_right: usize = node.funcall("padding_right", ())?;
+
+    let titles_array = magnus::RArray::from_value(titles_val)
+        .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 val: Value = titles_array.entry(index)?;
+        let line_width = if let Ok(line) = parse_line(val) {
+            line.width()
+        } else {
+            let s: String = String::try_convert(val)?;
+            ratatui::text::Span::raw(s).width()
+        };
+        total_width += line_width;
+        titles_count += 1;
+    }
+
+    if titles_count > 1 {
+        let divider_width = if !divider_val.is_nil() {
+            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;
+    }
+
+    Ok(total_width)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use ratatui::buffer::Buffer;
+    use ratatui::style::{Color, Modifier, Style};
     use ratatui::text::Line;
     use ratatui::widgets::{Tabs, Widget};
 
@@ -49,4 +129,24 @@ mod tests {
         assert!(content.contains("Tab2"));
         assert!(content.contains('|'));
     }
+
+    #[test]
+    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 mut buf = Buffer::empty(Rect::new(0, 0, 15, 1));
+        tabs.render(Rect::new(0, 0, 15, 1), &mut buf);
+
+        // Check the first cell of the first tab (which is selected)
+        // " Tab1 "
+        // Index 1 should be 'T' with Red+Bold
+        let cell = &buf.content()[1];
+        assert_eq!(cell.symbol(), "T");
+        assert_eq!(cell.fg, Color::Red);
+        assert!(cell.modifier.contains(Modifier::BOLD));
+    }
 }

data/lib/ratatui_ruby/cell.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # Represents a single cell in the terminal buffer.
+  #
+  # A terminal grid is made of cells. Each cell contains a character (symbol) and styling (colors, modifiers).
+  # When testing, you often need to verify that a specific cell renders correctly.
+  #
+  # This object encapsulates that state. It provides predicate methods for modifiers, making assertions readable.
+  #
+  # Use it to inspect the visual state of your application in tests.
+  #
+  # === Examples
+  #
+  #   cell = RatatuiRuby.get_cell_at(0, 0)
+  #   cell.char   # => "H"
+  #   cell.fg     # => :red
+  #   cell.bold?  # => true
+  #
+  class Cell
+    # The character displayed in the cell.
+    #
+    # Named to match Ratatui's Cell::symbol() method.
+    attr_reader :symbol
+
+    # Alias for Rubyists who prefer a shorter name.
+    alias char symbol
+
+    # The foreground color of the cell (e.g., :red, :blue, "#ff0000").
+    attr_reader :fg
+
+    # The background color of the cell (e.g., :black, nil).
+    attr_reader :bg
+
+    # The list of active modifiers (e.g., ["bold", "italic"]).
+    attr_reader :modifiers
+
+    # Returns an empty cell (space character, no styles).
+    #
+    # === Example
+    #
+    #   Cell.empty # => #<RatatuiRuby::Cell char=" ">
+    #
+    def self.empty
+      new(symbol: " ", fg: nil, bg: nil, modifiers: [])
+    end
+
+    # Returns a default cell (alias for empty).
+    #
+    # === Example
+    #
+    #   Cell.default # => #<RatatuiRuby::Cell char=" ">
+    #
+    def self.default
+      empty
+    end
+
+    # Returns a cell with a specific character and no styles.
+    #
+    # [symbol] String (single character).
+    #
+    # === Example
+    #
+    #   Cell.symbol("X") # => #<RatatuiRuby::Cell symbol="X">
+    #
+    def self.symbol(symbol)
+      new(symbol: symbol, fg: nil, bg: nil, modifiers: [])
+    end
+
+    # Alias for Rubyists who prefer a shorter name.
+    def self.char(char)
+      symbol(char)
+    end
+
+    # Creates a new Cell.
+    #
+    # [symbol] String (single character). Aliased as <tt>char:</tt>.
+    # [fg] Symbol or String (nullable).
+    # [bg] Symbol or String (nullable).
+    # [modifiers] Array of Strings.
+    def initialize(symbol: nil, char: nil, fg: nil, bg: nil, modifiers: [])
+      @symbol = symbol || char || " "
+      @fg = fg
+      @bg = bg
+      @modifiers = modifiers.freeze
+      freeze
+    end
+
+    # Returns true if the cell has the bold modifier.
+    def bold?
+      modifiers.include?("bold")
+    end
+
+    # Returns true if the cell has the dim modifier.
+    def dim?
+      modifiers.include?("dim")
+    end
+
+    # Returns true if the cell has the italic modifier.
+    def italic?
+      modifiers.include?("italic")
+    end
+
+    # Returns true if the cell has the underlined modifier.
+    def underlined?
+      modifiers.include?("underlined")
+    end
+
+    # Returns true if the cell has the slow_blink modifier.
+    def slow_blink?
+      modifiers.include?("slow_blink")
+    end
+
+    # Returns true if the cell has the rapid_blink modifier.
+    def rapid_blink?
+      modifiers.include?("rapid_blink")
+    end
+
+    # Returns true if the cell has the reversed modifier.
+    def reversed?
+      modifiers.include?("reversed")
+    end
+
+    # Returns true if the cell has the hidden modifier.
+    def hidden?
+      modifiers.include?("hidden")
+    end
+
+    # Returns true if the cell has the crossed_out modifier.
+    def crossed_out?
+      modifiers.include?("crossed_out")
+    end
+
+    # Checks equality with another Cell.
+    def ==(other)
+      other.is_a?(Cell) &&
+        char == other.char &&
+        fg == other.fg &&
+        bg == other.bg &&
+        modifiers == other.modifiers
+    end
+
+    # Returns a string representation of the cell.
+    def inspect
+      parts = ["symbol=#{symbol.inspect}"]
+      parts << "fg=#{fg.inspect}" if fg
+      parts << "bg=#{bg.inspect}" if bg
+      parts << "modifiers=#{modifiers.inspect}" unless modifiers.empty?
+      "#<#{self.class} #{parts.join(" ")}>"
+    end
+
+    # Returns the cell's character.
+    def to_s
+      symbol
+    end
+
+    # 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 }
+    end
+  end
+end

data/lib/ratatui_ruby/event/focus_gained.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class Event
+    # Signals that the application is now active.
+    #
+    # The user interacts with many windows. Your application needs to know when it has their attention.
+    #
+    # This event confirms visibility. It fires when the terminal window moves to the foreground.
+    #
+    # Use it to resume paused activities. Restart animations. Refresh data. The user is watching.
+    #
+    # Only supported by some terminals (e.g. iTerm2, Kitty, newer xterm).
+    #
+    # === Example
+    #
+    #   if event.focus_gained?
+    #     puts "Focus gained"
+    #   end
+    class FocusGained < Event
+      # Returns true for FocusGained events.
+      #
+      #   event.focus_gained? # => true
+      #   event.key?          # => false
+      def focus_gained?
+        true
+      end
+
+      # Deconstructs the event for pattern matching.
+      #
+      #   case event
+      #   in type: :focus_gained
+      #     puts "Application gained focus"
+      #   end
+      def deconstruct_keys(keys)
+        { type: :focus_gained }
+      end
+
+      ##
+      # Compares this event with another for equality.
+      def ==(other)
+        other.is_a?(FocusGained)
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/event/focus_lost.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class Event
+    # Signals that the application is in the background.
+    #
+    # The user has switched context. Your application is no longer the primary focus.
+    #
+    # This event warns of inactivity. It fires when the terminal window loses focus.
+    #
+    # Respond by conserving resources. Pause animations. Stop heavy polling. dim the UI to
+    # indicate a background state.
+    #
+    # Only supported by some terminals (e.g. iTerm2, Kitty, newer xterm).
+    #
+    # === Example
+    #
+    #   if event.focus_lost?
+    #     puts "Focus lost"
+    #   end
+    class FocusLost < Event
+      # Returns true for FocusLost events.
+      #
+      #   event.focus_lost? # => true
+      #   event.key?        # => false
+      def focus_lost?
+        true
+      end
+
+      # Deconstructs the event for pattern matching.
+      #
+      #   case event
+      #   in type: :focus_lost
+      #     puts "Application lost focus"
+      #   end
+      def deconstruct_keys(keys)
+        { type: :focus_lost }
+      end
+
+      ##
+      # Compares this event with another for equality.
+      def ==(other)
+        other.is_a?(FocusLost)
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/event/key.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class Event
+    # Captures a keyboard interaction.
+    #
+    # The keyboard is the primary interface for your terminal application. Raw key codes are often cryptic,
+    # and handling modifiers manually is error-prone.
+    #
+    # This event creates clarity. It encapsulates the interaction, providing a normalized +code+ and
+    # a list of active +modifiers+.
+    #
+    # Compare it directly to strings or symbols for rapid development, or use pattern matching for
+    # complex control schemes.
+    #
+    # === Examples
+    #
+    # Using predicates:
+    #   if event.key? && event.ctrl? && event.code == "c"
+    #     exit
+    #   end
+    #
+    # Using symbol comparison:
+    #   if event == :ctrl_c
+    #     exit
+    #   end
+    #
+    # Using pattern matching:
+    #   case event
+    #   in type: :key, code: "c", modifiers: ["ctrl"]
+    #     exit
+    #   end
+    class Key < Event
+      # The key code (e.g., <tt>"a"</tt>, <tt>"enter"</tt>, <tt>"up"</tt>).
+      #
+      #   puts event.code # => "enter"
+      attr_reader :code
+
+      # List of active modifiers (<tt>"ctrl"</tt>, <tt>"alt"</tt>, <tt>"shift"</tt>).
+      #
+      #   puts event.modifiers # => ["ctrl", "shift"]
+      attr_reader :modifiers
+
+      # Returns true for Key events.
+      #
+      #   event.key?    # => true
+      #   event.mouse?  # => false
+      #   event.resize? # => false
+      def key?
+        true
+      end
+
+      # Creates a new Key event.
+      #
+      # [code]
+      #   The key code (String).
+      # [modifiers]
+      #   List of modifiers (Array<String>).
+      def initialize(code:, modifiers: [])
+        @code = code
+        @modifiers = modifiers.sort
+      end
+
+      # Compares the event with another object.
+      #
+      # - If +other+ is a +Symbol+, compares against #to_sym.
+      # - If +other+ is a +String+, compares against #to_s.
+      # - Otherwise, performs standard equality check.
+      # - Otherwise, compares internal state (code + modifiers).
+      def ==(other)
+        case other
+        when Symbol
+          to_sym == other
+        when String
+          to_s == other
+        when Key
+          code == other.code && modifiers == other.modifiers
+        else
+          super
+        end
+      end
+
+      # Converts the event to a Symbol representation.
+      #
+      # The format is <tt>[modifiers_]code</tt>. Modifiers are sorted alphabetically (alt, ctrl, shift)
+      # and joined by underscores.
+      #
+      # === Supported Keys
+      #
+      # [Standard]
+      #   <tt>:enter</tt>, <tt>:backspace</tt>, <tt>:tab</tt>, <tt>:esc</tt>, <tt>:page_up</tt>, <tt>:page_down</tt>, <tt>:home</tt>, <tt>:end</tt>, <tt>:delete</tt>, <tt>:insert</tt>, <tt>:f1</tt>..<tt>:f12</tt>
+      # [Navigation]
+      #   <tt>:up</tt>, <tt>:down</tt>, <tt>:left</tt>, <tt>:right</tt>
+      # [Characters]
+      #   <tt>:a</tt>, <tt>:b</tt>, <tt>:1</tt>, <tt>:space</tt>, etc.
+      #
+      # === Modifier Examples
+      #
+      # * <tt>:ctrl_c</tt>
+      # * <tt>:alt_enter</tt>
+      # * <tt>:shift_left</tt>
+      # * <tt>:ctrl_alt_delete</tt>
+      def to_sym
+        mods = @modifiers.join("_")
+        if mods.empty?
+          @code.to_sym
+        else
+          "#{mods}_#{@code}".to_sym
+        end
+      end
+
+      # Converts the event to its String representation.
+      #
+      # [Printable Characters]
+      #   Returns the character itself (e.g., <tt>"a"</tt>, <tt>"1"</tt>, <tt>" "</tt>).
+      # [Special Keys]
+      #   Returns an empty string (e.g., <tt>"enter"</tt>, <tt>"up"</tt>, <tt>"f1"</tt> all return <tt>""</tt>).
+      # [Modifiers]
+      #   Returns the character if printable, ignoring modifiers unless they alter the character code itself.
+      #   Note that <tt>ctrl+c</tt> typically returns <tt>"c"</tt> as the code, so +to_s+ will return <tt>"c"</tt>.
+      def to_s
+        if text?
+          @code
+        else
+          ""
+        end
+      end
+
+      # Returns inspection string.
+      def inspect
+        "#<#{self.class} code=#{@code.inspect} modifiers=#{@modifiers.inspect}>"
+      end
+
+      # Returns true if CTRL is held.
+      def ctrl?
+        @modifiers.include?("ctrl")
+      end
+
+      # Returns true if ALT is held.
+      def alt?
+        @modifiers.include?("alt")
+      end
+
+      # Returns true if SHIFT is held.
+      def shift?
+        @modifiers.include?("shift")
+      end
+
+      # Returns true if the key represents a single printable character.
+      #
+      #   RatatuiRuby::Event::Key.new(code: "a").text?       # => true
+      #   RatatuiRuby::Event::Key.new(code: "enter").text?   # => false
+      #   RatatuiRuby::Event::Key.new(code: "space").text?   # => false ("space" is not 1 char, " " is)
+      def text?
+        @code.length == 1
+      end
+
+      # Returns the key as a printable character (if applicable).
+      #
+      # [Printable Characters]
+      #   Returns the character itself (e.g., <tt>"a"</tt>, <tt>"1"</tt>, <tt>" "</tt>).
+      # [Special Keys]
+      #   Returns an empty string (e.g., <tt>"enter"</tt>, <tt>"up"</tt>, <tt>"f1"</tt>).
+      #
+      # This is equivalent to +to_s+.
+      #
+      #   RatatuiRuby::Event::Key.new(code: "a").char      # => "a"
+      #   RatatuiRuby::Event::Key.new(code: "enter").char  # => ""
+      def char
+        to_s
+      end
+
+      # Supports dynamic key predicate methods via method_missing.
+      #
+      # Allows convenient checking for specific keys or key combinations:
+      #
+      #   event.ctrl_c?     # => true if Ctrl+C
+      #   event.enter?      # => true if Enter
+      #   event.shift_up?   # => true if Shift+Up
+      #   event.q?          # => true if "q"
+      #
+      # The method name is converted to a symbol and compared against the event.
+      # This works for any key code or modifier+key combination.
+      def method_missing(name, *args, &block)
+        if name.to_s.end_with?("?")
+          key_sym = name.to_s[0...-1].to_sym
+          return self == key_sym
+        end
+        super
+      end
+
+      # Declares that this class responds to dynamic predicate methods.
+      def respond_to_missing?(name, *args)
+        name.to_s.end_with?("?") || super
+      end
+
+      # Deconstructs the event for pattern matching.
+      #
+      #   case event
+      #   in type: :key, code: "c", modifiers: ["ctrl"]
+      #     puts "Ctrl+C pressed"
+      #   end
+      def deconstruct_keys(keys)
+        { type: :key, code: @code, modifiers: @modifiers }
+      end
+    end
+  end
+end