mui 0.2.0 → 0.3.0

data/lib/mui/key_handler/operators/paste_operator.rb

@@ -37,6 +37,7 @@ module Mui
         private
 
         def paste_line_after(name: nil)
+          undo_manager&.begin_group
           text = @register.get(name:)
           lines = text.split("\n", -1)
           lines.reverse_each do |line|
@@ -44,15 +45,18 @@ module Mui
           end
           self.cursor_row = cursor_row + 1
           self.cursor_col = 0
+          undo_manager&.end_group
         end
 
         def paste_line_before(name: nil)
+          undo_manager&.begin_group
           text = @register.get(name:)
           lines = text.split("\n", -1)
           lines.reverse_each do |line|
             @buffer.insert_line(cursor_row, line)
           end
           self.cursor_col = 0
+          undo_manager&.end_group
         end
 
         def paste_char_after(name: nil)
@@ -63,7 +67,7 @@ module Mui
           if text.include?("\n")
             paste_multiline_char(text, line, insert_col)
           else
-            @buffer.lines[cursor_row] = line[0...insert_col].to_s + text + line[insert_col..].to_s
+            @buffer.replace_line(cursor_row, line[0...insert_col].to_s + text + line[insert_col..].to_s)
             self.cursor_col = insert_col + text.length - 1
             @window.clamp_cursor_to_line(@buffer)
           end
@@ -76,19 +80,20 @@ module Mui
           if text.include?("\n")
             paste_multiline_char(text, line, cursor_col)
           else
-            @buffer.lines[cursor_row] = line[0...cursor_col].to_s + text + line[cursor_col..].to_s
+            @buffer.replace_line(cursor_row, line[0...cursor_col].to_s + text + line[cursor_col..].to_s)
             self.cursor_col = cursor_col + text.length - 1
             @window.clamp_cursor_to_line(@buffer)
           end
         end
 
         def paste_multiline_char(text, line, insert_col)
+          undo_manager&.begin_group
           lines = text.split("\n", -1)
           before = line[0...insert_col].to_s
           after = line[insert_col..].to_s
 
           # First line: before + first part of pasted text
-          @buffer.lines[cursor_row] = before + lines.first
+          @buffer.replace_line(cursor_row, before + lines.first)
 
           # Middle lines: insert as new lines
           lines[1...-1].each_with_index do |pasted_line, idx|
@@ -106,6 +111,7 @@ module Mui
           self.cursor_col = lines.last.length - 1
           self.cursor_col = 0 if cursor_col.negative?
           @window.clamp_cursor_to_line(@buffer)
+          undo_manager&.end_group
         end
       end
     end

data/lib/mui/key_handler/search_mode.rb

@@ -23,6 +23,10 @@ module Mui
       end
 
       def handle(key)
+        # Check plugin keymaps first
+        plugin_result = check_plugin_keymap(key, :search)
+        return plugin_result if plugin_result
+
         case key
         when KeyCode::ESCAPE
           handle_escape
@@ -136,19 +140,19 @@ module Mui
 
         direction = @search_input.prompt == "/" ? :forward : :backward
         @search_state.set_pattern(pattern, direction)
-        @search_state.find_all_matches(buffer)
 
         # Move cursor to first match from original position
-        return if @search_state.matches.empty?
+        matches = @search_state.find_all_matches(buffer)
+        return if matches.empty?
 
         # Use original position if set, otherwise use current cursor position
         search_row = @original_cursor_row || cursor_row
         search_col = @original_cursor_col || cursor_col
 
         match = if direction == :forward
-                  @search_state.find_next(search_row, search_col)
+                  @search_state.find_next(search_row, search_col, buffer:)
                 else
-                  @search_state.find_previous(search_row, search_col)
+                  @search_state.find_previous(search_row, search_col, buffer:)
                 end
 
         return unless match
@@ -163,12 +167,11 @@ module Mui
 
         direction = @search_input.prompt == "/" ? :forward : :backward
         @search_state.set_pattern(pattern, direction)
-        @search_state.find_all_matches(@buffer)
 
         match = if direction == :forward
-                  @search_state.find_next(cursor_row, cursor_col)
+                  @search_state.find_next(cursor_row, cursor_col, buffer:)
                 else
-                  @search_state.find_previous(cursor_row, cursor_col)
+                  @search_state.find_previous(cursor_row, cursor_col, buffer:)
                 end
 
         if match

data/lib/mui/key_handler/visual_mode.rb

@@ -18,6 +18,12 @@ module Mui
       end
 
       def handle(key)
+        # Check plugin keymaps first (only when no pending motion)
+        unless @pending_motion
+          plugin_result = check_plugin_keymap(key, :visual)
+          return plugin_result if plugin_result
+        end
+
         if @pending_motion
           handle_pending_motion(key)
         else
@@ -120,7 +126,7 @@ module Mui
         if @selection.line_mode
           change_lines(range)
         else
-          @undo_manager&.begin_group
+          undo_manager&.begin_group
           change_range(range)
         end
         @pending_register = nil
@@ -154,16 +160,15 @@ module Mui
         # Escape special regex characters for literal search
         escaped_pattern = Regexp.escape(text)
 
-        # Set search state and find matches
+        # Set search state
         search_state = @mode_manager.search_state
         search_state.set_pattern(escaped_pattern, direction)
-        search_state.find_all_matches(buffer)
 
         # Find next/previous match from current position
         match = if direction == :forward
-                  search_state.find_next(cursor_row, cursor_col)
+                  search_state.find_next(cursor_row, cursor_col, buffer:)
                 else
-                  search_state.find_previous(cursor_row, cursor_col)
+                  search_state.find_previous(cursor_row, cursor_col, buffer:)
                 end
 
         if match
@@ -207,7 +212,7 @@ module Mui
       def change_lines(range)
         lines = (range[:start_row]..range[:end_row]).map { |r| buffer.line(r) }
         @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
-        @undo_manager&.begin_group
+        undo_manager&.begin_group
         (range[:end_row] - range[:start_row] + 1).times do
           buffer.delete_line(range[:start_row])
         end
@@ -229,11 +234,11 @@ module Mui
       def delete_lines(range)
         lines = (range[:start_row]..range[:end_row]).map { |r| buffer.line(r) }
         @register.delete(lines.join("\n"), linewise: true, name: @pending_register)
-        @undo_manager&.begin_group unless @undo_manager&.in_group?
+        undo_manager&.begin_group unless undo_manager&.in_group?
         (range[:end_row] - range[:start_row] + 1).times do
           buffer.delete_line(range[:start_row])
         end
-        @undo_manager&.end_group
+        undo_manager&.end_group
         self.cursor_row = [range[:start_row], buffer.line_count - 1].min
         self.cursor_col = 0
         window.clamp_cursor_to_line(buffer)
@@ -268,7 +273,7 @@ module Mui
       def indent_lines(start_row, end_row, direction)
         indent_string = build_indent_string
 
-        @undo_manager&.begin_group unless @undo_manager&.in_group?
+        undo_manager&.begin_group unless undo_manager&.in_group?
 
         (start_row..end_row).each do |row|
           if direction == :right
@@ -278,7 +283,7 @@ module Mui
           end
         end
 
-        @undo_manager&.end_group
+        undo_manager&.end_group
       end
 
       def build_indent_string

data/lib/mui/key_notation_parser.rb

@@ -0,0 +1,152 @@
+# 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",
+      "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")
+
+        # 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
+
+        # Handle other special keys
+        normalized_name = name.downcase
+        SPECIAL_KEYS[normalized_name] || 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 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