mui 0.2.0 → 0.4.0

data/lib/mui/key_notation_parser.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Mui
+  # Parser for Vim-style key notation strings
+  # Converts notation like "<Leader>gd", "<C-x><C-s>", "<Space>w" to internal key arrays
+  module KeyNotationParser
+    # Special key mappings (case-insensitive)
+    SPECIAL_KEYS = {
+      "space" => " ",
+      "tab" => "\t",
+      "s-tab" => :shift_tab,
+      "btab" => :shift_tab,
+      "cr" => "\r",
+      "enter" => "\r",
+      "return" => "\r",
+      "esc" => "\e",
+      "escape" => "\e",
+      "bs" => "\x7f",
+      "backspace" => "\x7f",
+      "del" => "\x7f",
+      "delete" => "\x7f",
+      "lt" => "<",
+      "gt" => ">",
+      "bar" => "|",
+      "bslash" => "\\",
+      "leader" => :leader
+    }.freeze
+
+    # Ctrl key mappings (a-z and some special characters)
+    CTRL_CHARS = {
+      "@" => 0,  # NUL
+      "a" => 1,
+      "b" => 2,
+      "c" => 3,
+      "d" => 4,
+      "e" => 5,
+      "f" => 6,
+      "g" => 7,
+      "h" => 8,  # Also backspace
+      "i" => 9,  # Also tab
+      "j" => 10, # Also newline
+      "k" => 11,
+      "l" => 12,
+      "m" => 13, # Also carriage return
+      "n" => 14,
+      "o" => 15,
+      "p" => 16,
+      "q" => 17,
+      "r" => 18,
+      "s" => 19,
+      "t" => 20,
+      "u" => 21,
+      "v" => 22,
+      "w" => 23,
+      "x" => 24,
+      "y" => 25,
+      "z" => 26,
+      "[" => 27, # Also escape
+      "\\" => 28,
+      "]" => 29,
+      "^" => 30,
+      "_" => 31
+    }.freeze
+
+    class << self
+      # Parse a key notation string into an array of keys
+      # @param notation [String] Key notation (e.g., "<Leader>gd", "<C-x><C-s>")
+      # @return [Array<String, Symbol>] Array of normalized keys
+      def parse(notation)
+        return [] if notation.nil? || notation.empty?
+
+        tokens = []
+        scanner = StringScanner.new(notation)
+
+        until scanner.eos?
+          if scanner.scan(/<([^>]+)>/)
+            # Special key notation <...>
+            tokens << parse_special(scanner[1])
+          else
+            # Regular character
+            char = scanner.getch
+            tokens << char if char
+          end
+        end
+
+        tokens
+      end
+
+      # Parse a special key notation (content inside < >)
+      # @param name [String] Special key name (e.g., "C-x", "Leader", "Space")
+      # @return [String, Symbol] Normalized key
+      def parse_special(name)
+        return :leader if name.casecmp?("leader")
+
+        # Check SPECIAL_KEYS first (handles <S-Tab>, <btab>, etc.)
+        normalized_name = name.downcase
+        return SPECIAL_KEYS[normalized_name] if SPECIAL_KEYS.key?(normalized_name)
+
+        # Handle Ctrl key: <C-x>, <Ctrl-x>, <C-X>
+        return parse_ctrl_key(::Regexp.last_match(2)) if name =~ /\A(c|ctrl)-(.+)\z/i
+
+        # Handle Shift key: <S-x>, <Shift-x>
+        return parse_shift_key(::Regexp.last_match(2)) if name =~ /\A(s|shift)-(.+)\z/i
+
+        # Unknown special key - return as-is
+        name
+      end
+
+      # Normalize an input key (from terminal) to internal representation
+      # @param key [Integer, String] Raw key input
+      # @return [String, nil] Normalized key string, or nil if invalid
+      def normalize_input_key(key)
+        case key
+        when String
+          key
+        when Integer
+          normalize_integer_key(key)
+        end
+      end
+
+      private
+
+      def parse_ctrl_key(char)
+        char_lower = char.downcase
+        code = CTRL_CHARS[char_lower]
+        code ? code.chr : char
+      end
+
+      def parse_shift_key(char)
+        # Shift typically produces uppercase for letters
+        char.length == 1 ? char.upcase : char
+      end
+
+      def normalize_integer_key(key)
+        case key
+        when KeyCode::ENTER_CR, KeyCode::ENTER_LF
+          "\r"
+        when KeyCode::ESCAPE
+          "\e"
+        when KeyCode::TAB
+          "\t"
+        when 353 # Curses::KEY_BTAB (Shift+Tab)
+          :shift_tab
+        when KeyCode::BACKSPACE
+          "\x7f"
+        when 0..31
+          # Control characters - convert to the character they represent
+          key.chr
+        when KeyCode::PRINTABLE_MIN..KeyCode::PRINTABLE_MAX
+          key.chr(Encoding::UTF_8)
+        end
+      rescue RangeError
+        nil
+      end
+    end
+  end
+end

data/lib/mui/key_sequence.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Mui
+  # Represents a sequence of keys for key mapping
+  # Parses Vim-style notation and provides normalization for matching
+  class KeySequence
+    attr_reader :keys, :notation
+
+    # @param notation [String] Key notation string (e.g., "<Leader>gd", "<C-x><C-s>")
+    def initialize(notation)
+      @notation = notation
+      @keys = KeyNotationParser.parse(notation)
+    end
+
+    # Normalize the key sequence by expanding :leader to actual leader key
+    # @param leader_key [String] The actual leader key (e.g., "\\", " ")
+    # @return [Array<String>] Array of normalized key strings
+    def normalize(leader_key)
+      @keys.map { |k| k == :leader ? leader_key : k }
+    end
+
+    # Get the length of the key sequence
+    # @return [Integer] Number of keys in the sequence
+    def length
+      @keys.length
+    end
+
+    # Check if this sequence contains a leader key
+    # @return [Boolean]
+    def leader?
+      @keys.include?(:leader)
+    end
+
+    # Check if this is a single key sequence
+    # @return [Boolean]
+    def single_key?
+      @keys.length == 1
+    end
+
+    # Check equality with another KeySequence
+    # @param other [KeySequence]
+    # @return [Boolean]
+    def ==(other)
+      return false unless other.is_a?(KeySequence)
+
+      @keys == other.keys
+    end
+
+    alias eql? ==
+
+    # Hash for use in Hash keys
+    def hash
+      @keys.hash
+    end
+
+    # Convert back to notation string for display
+    # @return [String]
+    def to_s
+      @notation
+    end
+
+    # Inspect for debugging
+    def inspect
+      "#<Mui::KeySequence #{@notation.inspect} => #{@keys.inspect}>"
+    end
+  end
+end

data/lib/mui/key_sequence_buffer.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Mui
+  # Buffer for accumulating key inputs for multi-key sequence matching
+  # Tracks timing for timeout detection
+  class KeySequenceBuffer
+    attr_reader :last_input_time
+
+    def initialize
+      @buffer = []
+      @last_input_time = nil
+    end
+
+    # Push a key into the buffer
+    # @param key [Integer, String] Raw key input from terminal
+    # @return [Boolean] true if key was added, false if key was invalid
+    def push(key)
+      normalized = KeyNotationParser.normalize_input_key(key)
+      return false unless normalized
+
+      @buffer << normalized
+      @last_input_time = Time.now
+      true
+    end
+
+    # Clear the buffer
+    def clear
+      @buffer.clear
+      @last_input_time = nil
+    end
+
+    # Check if buffer is empty
+    # @return [Boolean]
+    def empty?
+      @buffer.empty?
+    end
+
+    # Get buffer length
+    # @return [Integer]
+    def length
+      @buffer.length
+    end
+
+    alias size length
+
+    # Get copy of buffer contents as array
+    # @return [Array<String>]
+    def to_a
+      @buffer.dup
+    end
+
+    # Get the first key in the buffer
+    # @return [String, nil]
+    def first
+      @buffer.first
+    end
+
+    # Remove and return the first key
+    # @return [String, nil]
+    def shift
+      key = @buffer.shift
+      @last_input_time = nil if @buffer.empty?
+      key
+    end
+
+    # Check if the buffer has timed out
+    # @param timeout_ms [Integer] Timeout in milliseconds
+    # @return [Boolean]
+    def timeout?(timeout_ms)
+      return false unless @last_input_time
+      return false if @buffer.empty?
+
+      elapsed_ms = (Time.now - @last_input_time) * 1000
+      elapsed_ms > timeout_ms
+    end
+
+    # Get elapsed time since last input in milliseconds
+    # @return [Float, nil] Elapsed time in ms, or nil if no input
+    def elapsed_ms
+      return nil unless @last_input_time
+
+      (Time.now - @last_input_time) * 1000
+    end
+  end
+end

data/lib/mui/key_sequence_handler.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Mui
+  # Main handler for multi-key sequence processing
+  # Integrates buffer, matcher, and timeout handling
+  class KeySequenceHandler
+    DEFAULT_TIMEOUT_MS = 1000
+
+    # Process result types
+    RESULT_HANDLED = :handled           # Handler executed
+    RESULT_PENDING = :pending           # Waiting for more keys
+    RESULT_PASSTHROUGH = :passthrough   # No match, pass key to built-in handler
+
+    attr_reader :buffer
+
+    # @param config [Config] Configuration object
+    def initialize(config)
+      @config = config
+      @buffer = KeySequenceBuffer.new
+      @keymaps = {} # { mode => { KeySequence => handler } }
+      @pending_handler = nil # Handler for exact match while waiting for longer
+    end
+
+    # Get the leader key from config
+    # @return [String]
+    def leader_key
+      @config.get(:leader) || "\\"
+    end
+
+    # Get the timeout in milliseconds
+    # @return [Integer]
+    def timeout_ms
+      @config.get(:timeoutlen) || DEFAULT_TIMEOUT_MS
+    end
+
+    # Register a key sequence mapping
+    # @param mode [Symbol] Mode (:normal, :insert, etc.)
+    # @param key_notation [String] Key notation (e.g., "<Leader>gd")
+    # @param handler [Proc] Handler to execute
+    def register(mode, key_notation, handler)
+      @keymaps[mode] ||= {}
+      sequence = KeySequence.new(key_notation)
+      @keymaps[mode][sequence] = handler
+    end
+
+    # Process an input key
+    # @param key [Integer, String] Raw key input
+    # @param mode [Symbol] Current mode
+    # @return [Array<Symbol, Object>] [result_type, data]
+    #   - [:handled, handler] - Execute the handler
+    #   - [:pending, nil] - Wait for more input
+    #   - [:passthrough, key] - Pass key to built-in handler
+    def process(key, mode)
+      # Check timeout first - if timed out, handle before processing new key
+      if @buffer.timeout?(timeout_ms) && !@buffer.empty?
+        result = handle_timeout(mode)
+        # If we got a result, return it; the new key will be processed next time
+        return result if result[0] == RESULT_HANDLED
+
+        # If passthrough, clear buffer and continue with new key
+        @buffer.clear
+        @pending_handler = nil
+      end
+
+      # Add key to buffer
+      unless @buffer.push(key)
+        # Invalid key, pass through as-is
+        return [RESULT_PASSTHROUGH, key]
+      end
+
+      # Match against keymaps
+      matcher = KeySequenceMatcher.new(@keymaps, leader_key)
+      match_type, handler = matcher.match(mode, @buffer.to_a)
+
+      case match_type
+      when KeySequenceMatcher::MATCH_EXACT
+        has_longer = matcher.longer_sequences?(mode, @buffer.to_a)
+        if has_longer
+          # Exact match but longer sequences exist
+          # Store handler and wait for more input or timeout
+          @pending_handler = handler
+          [RESULT_PENDING, nil]
+        else
+          # Exact match, no longer sequences - execute immediately
+          @buffer.clear
+          @pending_handler = nil
+          [RESULT_HANDLED, handler]
+        end
+
+      when KeySequenceMatcher::MATCH_PARTIAL
+        # Could become a match, wait for more input
+        [RESULT_PENDING, nil]
+
+      else
+        # No match - pass through first key
+        handle_no_match
+      end
+    end
+
+    # Check for timeout and handle if needed (called from main loop)
+    # @param mode [Symbol] Current mode
+    # @return [Array<Symbol, Object>, nil] Result if timed out, nil otherwise
+    def check_timeout(mode)
+      return nil if @buffer.empty?
+      return nil unless @buffer.timeout?(timeout_ms)
+
+      handle_timeout(mode)
+    end
+
+    # Check if there are pending keys in the buffer
+    # @return [Boolean]
+    def pending?
+      !@buffer.empty?
+    end
+
+    # Clear the buffer and pending state
+    def clear
+      @buffer.clear
+      @pending_handler = nil
+    end
+
+    # Get pending key display for status line
+    # @return [String, nil]
+    def pending_keys_display
+      return nil if @buffer.empty?
+
+      @buffer.to_a.join
+    end
+
+    # Rebuild internal keymaps from config
+    # Called after config changes
+    def rebuild_keymaps
+      @keymaps = {}
+      @config.keymaps.each do |mode, mappings|
+        mappings.each do |key_notation, handler|
+          register(mode, key_notation, handler)
+        end
+      end
+    end
+
+    private
+
+    def handle_timeout(_mode)
+      if @pending_handler
+        # We had an exact match, execute it
+        handler = @pending_handler
+        @buffer.clear
+        @pending_handler = nil
+        [RESULT_HANDLED, handler]
+      else
+        # No exact match, passthrough first key
+        handle_no_match
+      end
+    end
+
+    def handle_no_match
+      first_key = @buffer.shift
+      @buffer.clear
+      @pending_handler = nil
+      [RESULT_PASSTHROUGH, first_key]
+    end
+  end
+end

data/lib/mui/key_sequence_matcher.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Mui
+  # Matches input key sequences against registered key mappings
+  class KeySequenceMatcher
+    # Match result types
+    MATCH_EXACT = :exact       # Complete match found
+    MATCH_PARTIAL = :partial   # Input is prefix of one or more registered sequences
+    MATCH_NONE = :none         # No match possible
+
+    # @param keymaps [Hash] Mode => { KeySequence => handler }
+    # @param leader_key [String] The leader key to expand :leader symbols
+    def initialize(keymaps, leader_key)
+      @keymaps = keymaps
+      @leader_key = leader_key
+    end
+
+    # Match input keys against registered keymaps for a mode
+    # @param mode [Symbol] The current mode (:normal, :insert, etc.)
+    # @param input_keys [Array<String>] Array of normalized input keys
+    # @return [Array<Symbol, Object>] [match_type, handler_or_nil]
+    def match(mode, input_keys)
+      mode_keymaps = @keymaps[mode]
+      return [MATCH_NONE, nil] unless mode_keymaps
+      return [MATCH_NONE, nil] if input_keys.empty?
+
+      exact_match = nil
+      has_longer_match = false
+
+      mode_keymaps.each do |sequence, handler|
+        seq_keys = sequence.normalize(@leader_key)
+
+        if seq_keys == input_keys
+          # Exact match found
+          exact_match = handler
+        elsif prefix_match?(input_keys, seq_keys)
+          # Input is a prefix of this sequence (longer sequence exists)
+          has_longer_match = true
+        end
+      end
+
+      if exact_match
+        # Exact match found - return it
+        # If there are also longer matches, caller may want to wait for timeout
+        [MATCH_EXACT, exact_match]
+      elsif has_longer_match
+        # No exact match, but input could lead to a match
+        [MATCH_PARTIAL, nil]
+      else
+        # No match possible
+        [MATCH_NONE, nil]
+      end
+    end
+
+    # Check if there are any longer sequences that could match
+    # Used to determine if we should wait for more input
+    # @param mode [Symbol]
+    # @param input_keys [Array<String>]
+    # @return [Boolean]
+    def longer_sequences?(mode, input_keys)
+      mode_keymaps = @keymaps[mode]
+      return false unless mode_keymaps
+
+      mode_keymaps.any? do |sequence, _handler|
+        seq_keys = sequence.normalize(@leader_key)
+        seq_keys.length > input_keys.length && prefix_match?(input_keys, seq_keys)
+      end
+    end
+
+    private
+
+    # Check if input_keys is a prefix of seq_keys
+    def prefix_match?(input_keys, seq_keys)
+      return false if input_keys.length >= seq_keys.length
+
+      seq_keys.take(input_keys.length) == input_keys
+    end
+  end
+end

data/lib/mui/line_renderer.rb

@@ -17,8 +17,59 @@ module Mui
       render_with_highlights(screen, line, x, y, highlights)
     end
 
+    # Renders a wrapped line segment with screen coordinate-based highlights
+    # wrap_info: { text:, start_col:, end_col: }
+    # options: { selection:, search_state:, logical_row:, visible_width: }
+    def render_wrapped_line(screen, y, x, wrap_info, options = {})
+      text = wrap_info[:text]
+      return if text.nil?
+
+      logical_row = options[:logical_row]
+      start_col = wrap_info[:start_col]
+      end_col = wrap_info[:end_col]
+
+      # Collect highlights for this row and clip to wrapped segment range
+      highlights = collect_highlights(logical_row, text, options)
+      clipped_highlights = clip_highlights_to_range(highlights, start_col, end_col)
+
+      # Adjust highlight positions to be relative to wrap segment start
+      adjusted_highlights = clipped_highlights.map do |h|
+        adjusted_start = h.start_col - start_col
+        adjusted_end = h.end_col - start_col
+        Highlight.new(
+          start_col: adjusted_start,
+          end_col: adjusted_end,
+          style: h.style,
+          priority: h.priority
+        )
+      end
+
+      render_with_highlights(screen, text, x, y, adjusted_highlights)
+    end
+
     private
 
+    # Clips highlights to a column range and returns only overlapping portions
+    def clip_highlights_to_range(highlights, range_start, range_end)
+      highlights.filter_map do |h|
+        # Skip if highlight doesn't overlap with range
+        next if h.end_col < range_start || h.start_col >= range_end
+
+        # Clip to range
+        clipped_start = [h.start_col, range_start].max
+        clipped_end = [h.end_col, range_end - 1].min
+
+        next if clipped_start > clipped_end
+
+        Highlight.new(
+          start_col: clipped_start,
+          end_col: clipped_end,
+          style: h.style,
+          priority: h.priority
+        )
+      end
+    end
+
     def collect_highlights(row, line, options)
       @highlighters
         .flat_map { |h| h.highlights_for(row, line, options) }
@@ -36,7 +87,7 @@ module Mui
 
       segments.each do |segment|
         put_text(screen, y, current_x, segment[:text], segment[:style])
-        current_x += segment[:text].length
+        current_x += UnicodeWidth.string_width(segment[:text])
       end
     end
 

data/lib/mui/mode_manager.rb

@@ -4,9 +4,9 @@ module Mui
   # Manages editor mode state and transitions
   class ModeManager
     attr_reader :mode, :selection, :register, :undo_manager, :search_state, :search_input, :editor,
-                :last_visual_selection
+                :last_visual_selection, :key_sequence_handler
 
-    def initialize(window:, buffer:, command_line:, undo_manager: nil, editor: nil, register: nil)
+    def initialize(window:, buffer:, command_line:, undo_manager: nil, editor: nil, register: nil, key_sequence_handler: nil)
       @tab_manager = window.is_a?(TabManager) ? window : nil
       @window_manager = window.is_a?(WindowManager) ? window : nil
       @window = !@tab_manager && !@window_manager ? window : nil
@@ -15,6 +15,7 @@ module Mui
       @register = register || Mui.register
       @undo_manager = undo_manager
       @editor = editor
+      @key_sequence_handler = key_sequence_handler
       @search_state = SearchState.new
       @search_input = SearchInput.new
       @mode = Mode::NORMAL