mui 0.1.0 → 0.3.0

data/lib/mui/key_handler/window_command.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Mui
+  module KeyHandler
+    class WindowCommand
+      def initialize(window_manager)
+        @window_manager = window_manager
+      end
+
+      def handle(key)
+        if key.is_a?(Integer)
+          result = handle_control_key(key)
+          return result if result
+        end
+
+        char = key_to_char(key)
+        return :done unless char
+
+        case char
+        when "s"
+          handle_split_horizontal
+        when "v"
+          handle_split_vertical
+        when "h", "H"
+          handle_focus_direction(:left)
+        when "j", "J"
+          handle_focus_direction(:down)
+        when "k", "K"
+          handle_focus_direction(:up)
+        when "l", "L"
+          handle_focus_direction(:right)
+        when "w"
+          handle_focus_next
+        when "W"
+          handle_focus_previous
+        when "c", "q"
+          handle_close_window
+        when "o"
+          handle_close_all_except_current
+        else
+          :done
+        end
+      end
+
+      private
+
+      def handle_control_key(key)
+        case key
+        when KeyCode::CTRL_S
+          handle_split_horizontal
+        when KeyCode::CTRL_V
+          handle_split_vertical
+        when KeyCode::CTRL_H
+          handle_focus_direction(:left)
+        when KeyCode::CTRL_J
+          handle_focus_direction(:down)
+        when KeyCode::CTRL_K
+          handle_focus_direction(:up)
+        when KeyCode::CTRL_L
+          handle_focus_direction(:right)
+        when KeyCode::CTRL_W
+          handle_focus_next
+        when KeyCode::CTRL_C
+          handle_close_window
+        when KeyCode::CTRL_O
+          handle_close_all_except_current
+        end
+      end
+
+      def key_to_char(key)
+        key.is_a?(String) ? key : key.chr
+      rescue RangeError
+        nil
+      end
+
+      def handle_split_horizontal
+        @window_manager.split_horizontal
+        :split_horizontal
+      end
+
+      def handle_split_vertical
+        @window_manager.split_vertical
+        :split_vertical
+      end
+
+      def handle_focus_direction(direction)
+        @window_manager.focus_direction(direction)
+        :"focus_#{direction}"
+      end
+
+      def handle_focus_next
+        @window_manager.focus_next
+        :focus_next
+      end
+
+      def handle_focus_previous
+        @window_manager.focus_previous
+        :focus_previous
+      end
+
+      def handle_close_window
+        @window_manager.close_current_window
+        :close_window
+      end
+
+      def handle_close_all_except_current
+        @window_manager.close_all_except_current
+        :close_all_except_current
+      end
+    end
+  end
+end

data/lib/mui/key_handler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "key_handler/motions/motion_handler"
+require_relative "key_handler/operators/base_operator"
+require_relative "key_handler/operators/delete_operator"
+require_relative "key_handler/operators/change_operator"
+require_relative "key_handler/operators/yank_operator"
+require_relative "key_handler/operators/paste_operator"
+require_relative "key_handler/base"
+require_relative "key_handler/normal_mode"
+require_relative "key_handler/insert_mode"
+require_relative "key_handler/command_mode"
+require_relative "key_handler/visual_mode"
+require_relative "key_handler/visual_line_mode"
+require_relative "key_handler/search_mode"
+require_relative "key_handler/window_command"

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

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/layout/calculator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mui
+  module Layout
+    class Calculator
+      def calculate(root, x, y, width, height)
+        root.x = x
+        root.y = y
+        root.width = width
+        root.height = height
+        root.apply_geometry
+      end
+    end
+  end
+end