ruvim 0.1.0 → 0.2.0

data/lib/ruvim/app.rb

@@ -10,6 +10,11 @@ module RuVim
       @signal_r, @signal_w = IO.pipe
       @cmdline_history = Hash.new { |h, k| h[k] = [] }
       @cmdline_history_index = nil
+      @cmdline_completion = nil
+      @pending_key_deadline = nil
+      @pending_ambiguous_invocation = nil
+      @insert_start_location = nil
+      @incsearch_preview = nil
       @needs_redraw = true
       @clean_mode = clean
       @skip_user_config = skip_user_config
@@ -71,8 +76,16 @@ module RuVim
           end
           break unless @editor.running?
 
-          key = @input.read_key(wakeup_ios: [@signal_r])
-          next if key.nil?
+          key = @input.read_key(
+            wakeup_ios: [@signal_r],
+            timeout: loop_timeout_seconds,
+            esc_timeout: escape_sequence_timeout_seconds
+          )
+          if key.nil?
+            handle_pending_key_timeout if pending_key_timeout_expired?
+            clear_expired_transient_message_if_any
+            next
+          end
 
           handle_key(key)
           @needs_redraw = true
@@ -89,6 +102,59 @@ module RuVim
 
     private
 
+    def pending_key_timeout_seconds
+      return nil unless @pending_key_deadline
+
+      [@pending_key_deadline - monotonic_now, 0.0].max
+    end
+
+    def loop_timeout_seconds
+      now = monotonic_now
+      timeouts = []
+      if @pending_key_deadline
+        timeouts << [@pending_key_deadline - now, 0.0].max
+      end
+      if (msg_to = @editor.transient_message_timeout_seconds(now:))
+        timeouts << msg_to
+      end
+      timeouts.min
+    end
+
+    def pending_key_timeout_expired?
+      @pending_key_deadline && monotonic_now >= @pending_key_deadline
+    end
+
+    def escape_sequence_timeout_seconds
+      ms = @editor.global_options["ttimeoutlen"].to_i
+      ms = 50 if ms <= 0
+      ms / 1000.0
+    rescue StandardError
+      0.005
+    end
+
+    def arm_pending_key_timeout
+      ms = @editor.global_options["timeoutlen"].to_i
+      ms = 1000 if ms <= 0
+      @pending_key_deadline = monotonic_now + (ms / 1000.0)
+    end
+
+    def clear_pending_key_timeout
+      @pending_key_deadline = nil
+      @pending_ambiguous_invocation = nil
+    end
+
+    def handle_pending_key_timeout
+      inv = @pending_ambiguous_invocation
+      clear_pending_key_timeout
+      if inv
+        @dispatcher.dispatch(@editor, dup_invocation(inv))
+      elsif @pending_keys && !@pending_keys.empty?
+        @editor.echo_error("Unknown key: #{@pending_keys.join}")
+      end
+      @editor.pending_count = nil
+      @pending_keys = []
+    end
+
     def register_builtins!
       cmd = CommandRegistry.instance
       ex = ExCommandRegistry.instance
@@ -99,6 +165,14 @@ module RuVim
       register_internal_unless(cmd, "cursor.down", call: :cursor_down, desc: "Move cursor down")
       register_internal_unless(cmd, "cursor.page_up", call: :cursor_page_up, desc: "Move one page up")
       register_internal_unless(cmd, "cursor.page_down", call: :cursor_page_down, desc: "Move one page down")
+      register_internal_unless(cmd, "window.scroll_up", call: :window_scroll_up, desc: "Scroll window up")
+      register_internal_unless(cmd, "window.scroll_down", call: :window_scroll_down, desc: "Scroll window down")
+      register_internal_unless(cmd, "cursor.page_up.default", call: :cursor_page_up_default, desc: "Move one page up (view-sized)")
+      register_internal_unless(cmd, "cursor.page_down.default", call: :cursor_page_down_default, desc: "Move one page down (view-sized)")
+      register_internal_unless(cmd, "cursor.page_up.half", call: :cursor_page_up_half, desc: "Move half page up")
+      register_internal_unless(cmd, "cursor.page_down.half", call: :cursor_page_down_half, desc: "Move half page down")
+      register_internal_unless(cmd, "window.scroll_up.line", call: :window_scroll_up_line, desc: "Scroll window up one line")
+      register_internal_unless(cmd, "window.scroll_down.line", call: :window_scroll_down_line, desc: "Scroll window down one line")
       register_internal_unless(cmd, "cursor.line_start", call: :cursor_line_start, desc: "Move to column 1")
       register_internal_unless(cmd, "cursor.line_end", call: :cursor_line_end, desc: "Move to end of line")
       register_internal_unless(cmd, "cursor.first_nonblank", call: :cursor_first_nonblank, desc: "Move to first nonblank")
@@ -153,7 +227,9 @@ module RuVim
       register_internal_unless(cmd, "jump.newer", call: :jump_newer, desc: "Jump newer")
       register_internal_unless(cmd, "editor.buffer_next", call: :buffer_next, desc: "Next buffer")
       register_internal_unless(cmd, "editor.buffer_prev", call: :buffer_prev, desc: "Previous buffer")
+      register_internal_unless(cmd, "editor.buffer_delete", call: :buffer_delete, desc: "Delete buffer")
       register_internal_unless(cmd, "buffer.replace_char", call: :replace_char, desc: "Replace single char")
+      register_internal_unless(cmd, "file.goto_under_cursor", call: :file_goto_under_cursor, desc: "Open file under cursor")
       register_internal_unless(cmd, "ui.clear_message", call: :clear_message, desc: "Clear message")
 
       register_ex_unless(ex, "w", call: :file_write, aliases: %w[write], desc: "Write current buffer", nargs: :maybe_one, bang: true)
@@ -167,6 +243,7 @@ module RuVim
       register_ex_unless(ex, "bnext", call: :buffer_next, aliases: %w[bn], desc: "Next buffer", nargs: 0, bang: true)
       register_ex_unless(ex, "bprev", call: :buffer_prev, aliases: %w[bp], desc: "Previous buffer", nargs: 0, bang: true)
       register_ex_unless(ex, "buffer", call: :buffer_switch, aliases: %w[b], desc: "Switch buffer", nargs: 1, bang: true)
+      register_ex_unless(ex, "bdelete", call: :buffer_delete, aliases: %w[bd], desc: "Delete buffer", nargs: :maybe_one, bang: true)
       register_ex_unless(ex, "commands", call: :ex_commands, desc: "List Ex commands", nargs: 0)
       register_ex_unless(ex, "set", call: :ex_set, desc: "Set options", nargs: :any)
       register_ex_unless(ex, "setlocal", call: :ex_setlocal, desc: "Set window/buffer local option", nargs: :any)
@@ -193,6 +270,10 @@ module RuVim
       @keymaps.bind(:normal, "j", "cursor.down")
       @keymaps.bind(:normal, "k", "cursor.up")
       @keymaps.bind(:normal, "l", "cursor.right")
+      @keymaps.bind(:normal, ["<Left>"], "cursor.left")
+      @keymaps.bind(:normal, ["<Down>"], "cursor.down")
+      @keymaps.bind(:normal, ["<Up>"], "cursor.up")
+      @keymaps.bind(:normal, ["<Right>"], "cursor.right")
       @keymaps.bind(:normal, "0", "cursor.line_start")
       @keymaps.bind(:normal, "$", "cursor.line_end")
       @keymaps.bind(:normal, "^", "cursor.first_nonblank")
@@ -226,20 +307,32 @@ module RuVim
       @keymaps.bind(:normal, ["<C-r>"], "buffer.redo")
       @keymaps.bind(:normal, ["<C-o>"], "jump.older")
       @keymaps.bind(:normal, ["<C-i>"], "jump.newer")
+      @keymaps.bind(:normal, ["<C-d>"], "cursor.page_down.half")
+      @keymaps.bind(:normal, ["<C-u>"], "cursor.page_up.half")
+      @keymaps.bind(:normal, ["<C-f>"], "cursor.page_down.default")
+      @keymaps.bind(:normal, ["<C-b>"], "cursor.page_up.default")
+      @keymaps.bind(:normal, ["<C-e>"], "window.scroll_down.line")
+      @keymaps.bind(:normal, ["<C-y>"], "window.scroll_up.line")
       @keymaps.bind(:normal, "n", "search.next")
       @keymaps.bind(:normal, "N", "search.prev")
       @keymaps.bind(:normal, "*", "search.word_forward")
       @keymaps.bind(:normal, "#", "search.word_backward")
       @keymaps.bind(:normal, "g*", "search.word_forward_partial")
       @keymaps.bind(:normal, "g#", "search.word_backward_partial")
+      @keymaps.bind(:normal, "gf", "file.goto_under_cursor")
+      @keymaps.bind(:normal, ["<PageUp>"], "cursor.page_up.default")
+      @keymaps.bind(:normal, ["<PageDown>"], "cursor.page_down.default")
       @keymaps.bind(:normal, "\e", "ui.clear_message")
     end
 
     def handle_key(key)
+      mode_before = @editor.mode
+      clear_stale_message_before_key(key)
       @skip_record_for_current_key = false
       append_dot_change_capture_key(key)
       if key == :ctrl_c
         handle_ctrl_c
+        track_mode_transition(mode_before)
         record_macro_key_if_needed(key)
         return
       end
@@ -254,153 +347,130 @@ module RuVim
       else
         handle_normal_key(key)
       end
+      track_mode_transition(mode_before)
       load_current_ftplugin!
       record_macro_key_if_needed(key)
     end
 
-    def handle_normal_key(key)
-      if arrow_key?(key)
-        invoke_arrow(key)
-        return
-      end
+    def clear_stale_message_before_key(key)
+      return if @editor.message.to_s.empty?
+      return if @editor.command_line_active?
 
-      if paging_key?(key)
-        invoke_page_key(key)
-        return
+      # Keep the error visible while the user is still dismissing/cancelling;
+      # otherwise, the next operation replaces the command-line area naturally.
+      return if key == :ctrl_c
+
+      @editor.clear_message
+    end
+
+    def handle_normal_key(key)
+      case
+      when handle_normal_key_pre_dispatch(key)
+      when (token = normalize_key_token(key)).nil?
+      when handle_normal_pending_state(token)
+      when handle_normal_direct_token(token)
+      else
+        @pending_keys ||= []
+        @pending_keys << token
+        resolve_normal_key_sequence
       end
+    end
 
-      if digit_key?(key) && count_digit_allowed?(key)
+    def handle_normal_key_pre_dispatch(key)
+      case
+      when key == :enter && handle_list_window_enter
+      when digit_key?(key) && count_digit_allowed?(key)
         @editor.pending_count = (@editor.pending_count.to_s + key).to_i
         @editor.echo(@editor.pending_count.to_s)
         @pending_keys = []
-        return
+      else
+        return false
       end
+      true
+    end
 
-      token = normalize_key_token(key)
-      return if token.nil?
-
-      if @operator_pending
+    def handle_normal_pending_state(token)
+      case
+      when @pending_keys && !@pending_keys.empty?
+        @pending_keys << token
+        resolve_normal_key_sequence
+      when @operator_pending
         handle_operator_pending_key(token)
-        return
-      end
-
-      if @register_pending
+      when @register_pending
         finish_register_pending(token)
-        return
-      end
-
-      if @mark_pending
+      when @mark_pending
         finish_mark_pending(token)
-        return
-      end
-
-      if @jump_pending
+      when @jump_pending
         finish_jump_pending(token)
-        return
-      end
-
-      if @macro_record_pending
+      when @macro_record_pending
         finish_macro_record_pending(token)
-        return
-      end
-
-      if @macro_play_pending
+      when @macro_play_pending
         finish_macro_play_pending(token)
-        return
-      end
-
-      if @replace_pending
+      when @replace_pending
         handle_replace_pending_key(token)
-        return
-      end
-
-      if @find_pending
+      when @find_pending
         finish_find_pending(token)
-        return
+      else
+        return false
       end
+      true
+    end
 
-      if token == "\""
+    def handle_normal_direct_token(token)
+      case token
+      when "\""
         start_register_pending
-        return
-      end
-
-      if token == "d"
+      when "d"
         start_operator_pending(:delete)
-        return
-      end
-
-      if token == "y"
+      when "y"
         start_operator_pending(:yank)
-        return
-      end
-
-      if token == "c"
+      when "c"
         start_operator_pending(:change)
-        return
-      end
-
-      if token == "r"
+      when "r"
         start_replace_pending
-        return
-      end
-
-      if %w[f F t T].include?(token)
+      when "f", "F", "t", "T"
         start_find_pending(token)
-        return
-      end
-
-      if token == ";"
+      when ";"
         repeat_last_find(reverse: false)
-        return
-      end
-
-      if token == ","
+      when ","
         repeat_last_find(reverse: true)
-        return
-      end
-
-      if token == "."
+      when "."
         repeat_last_change
-        return
-      end
-
-      if token == "q"
+      when "q"
         if @editor.macro_recording?
           stop_macro_recording
         else
           start_macro_record_pending
         end
-        return
-      end
-
-      if token == "@"
+      when "@"
         start_macro_play_pending
-        return
-      end
-
-      if token == "m"
+      when "m"
         start_mark_pending
-        return
-      end
-
-      if token == "'"
+      when "'"
         start_jump_pending(linewise: true, repeat_token: "'")
-        return
-      end
-
-      if token == "`"
+      when "`"
         start_jump_pending(linewise: false, repeat_token: "`")
-        return
+      else
+        return false
       end
+      true
+    end
 
-      @pending_keys ||= []
-      @pending_keys << token
-
+    def resolve_normal_key_sequence
       match = @keymaps.resolve_with_context(:normal, @pending_keys, editor: @editor)
       case match.status
       when :pending, :ambiguous
+        if match.status == :ambiguous && match.invocation
+          inv = dup_invocation(match.invocation)
+          inv.count = @editor.pending_count || 1
+          @pending_ambiguous_invocation = inv
+        else
+          @pending_ambiguous_invocation = nil
+        end
+        arm_pending_key_timeout
         return
       when :match
+        clear_pending_key_timeout
         matched_keys = @pending_keys.dup
         repeat_count = @editor.pending_count || 1
         invocation = dup_invocation(match.invocation)
@@ -408,6 +478,7 @@ module RuVim
         @dispatcher.dispatch(@editor, invocation)
         maybe_record_simple_dot_change(invocation, matched_keys, repeat_count)
       else
+        clear_pending_key_timeout
         @editor.echo_error("Unknown key: #{@pending_keys.join}")
       end
       @editor.pending_count = nil
@@ -424,28 +495,27 @@ module RuVim
         @editor.echo("")
       when :backspace
         clear_insert_completion
-        y, x = @editor.current_buffer.backspace(@editor.current_window.cursor_y, @editor.current_window.cursor_x)
-        @editor.current_window.cursor_y = y
-        @editor.current_window.cursor_x = x
+        return unless insert_backspace_allowed?
+        insert_backspace_in_insert_mode
       when :ctrl_n
         insert_complete(+1)
       when :ctrl_p
         insert_complete(-1)
       when :ctrl_i
         clear_insert_completion
-        @editor.current_buffer.insert_char(@editor.current_window.cursor_y, @editor.current_window.cursor_x, "\t")
-        @editor.current_window.cursor_x += 1
+        insert_tab_in_insert_mode
       when :enter
         clear_insert_completion
         y, x = @editor.current_buffer.insert_newline(@editor.current_window.cursor_y, @editor.current_window.cursor_x)
+        x = apply_insert_autoindent(y, x, previous_row: y - 1)
         @editor.current_window.cursor_y = y
         @editor.current_window.cursor_x = x
       when :left
         clear_insert_completion
-        @editor.current_window.move_left(@editor.current_buffer, 1)
+        dispatch_insert_cursor_motion("cursor.left")
       when :right
         clear_insert_completion
-        @editor.current_window.move_right(@editor.current_buffer, 1)
+        dispatch_insert_cursor_motion("cursor.right")
       when :up
         clear_insert_completion
         @editor.current_window.move_up(@editor.current_buffer, 1)
@@ -461,6 +531,7 @@ module RuVim
         clear_insert_completion
         @editor.current_buffer.insert_char(@editor.current_window.cursor_y, @editor.current_window.cursor_x, key)
         @editor.current_window.cursor_x += 1
+        maybe_showmatch_after_insert(key)
       end
     end
 
@@ -551,6 +622,7 @@ module RuVim
       if token == "g"
         @pending_keys ||= []
         @pending_keys << token
+        arm_pending_key_timeout
         return
       end
 
@@ -559,9 +631,11 @@ module RuVim
       end
 
       if id
+        clear_pending_key_timeout
         count = @editor.pending_count || 1
         @dispatcher.dispatch(@editor, CommandInvocation.new(id:, count: count))
       else
+        clear_pending_key_timeout
         @editor.echo_error("Unknown visual key: #{token}")
       end
     ensure
@@ -572,29 +646,87 @@ module RuVim
       cmd = @editor.command_line
       case key
       when :escape
+        clear_command_line_completion
+        cancel_incsearch_preview_if_any
         @editor.cancel_command_line
       when :enter
+        clear_command_line_completion
         line = cmd.text.dup
         push_command_line_history(cmd.prefix, line)
         handle_command_line_submit(cmd.prefix, line)
       when :backspace
+        clear_command_line_completion
+        if cmd.text.empty? && cmd.cursor.zero?
+          cancel_incsearch_preview_if_any
+          @editor.cancel_command_line
+          return
+        end
         cmd.backspace
       when :up
+        clear_command_line_completion
         command_line_history_move(-1)
       when :down
+        clear_command_line_completion
         command_line_history_move(1)
       when :left
+        clear_command_line_completion
         cmd.move_left
       when :right
+        clear_command_line_completion
         cmd.move_right
       else
         if key == :ctrl_i
           command_line_complete
         elsif key.is_a?(String)
+          clear_command_line_completion
           @cmdline_history_index = nil
           cmd.insert(key)
         end
       end
+      update_incsearch_preview_if_needed
+    end
+
+    def handle_list_window_enter
+      buffer = @editor.current_buffer
+      return false unless buffer.kind == :quickfix || buffer.kind == :location_list
+
+      item_index = @editor.current_window.cursor_y - 2
+      if item_index.negative?
+        @editor.echo_error("No list item on this line")
+        return true
+      end
+
+      source_window_id = buffer.options["ruvim_list_source_window_id"]
+      source_window_id = source_window_id.to_i if source_window_id
+      source_window_id = nil unless source_window_id && @editor.windows.key?(source_window_id)
+
+      item =
+        if buffer.kind == :quickfix
+          @editor.select_quickfix(item_index)
+        else
+          owner_window_id = source_window_id || @editor.current_window_id
+          @editor.select_location_list(item_index, window_id: owner_window_id)
+        end
+
+      unless item
+        @editor.echo_error("#{buffer.kind == :quickfix ? 'quickfix' : 'location list'} item not found")
+        return true
+      end
+
+      if source_window_id
+        @editor.current_window_id = source_window_id
+      end
+      @editor.jump_to_location(item)
+      @editor.echo(
+        if buffer.kind == :quickfix
+          "qf #{@editor.quickfix_index.to_i + 1}/#{@editor.quickfix_items.length}"
+        else
+          owner_window_id = source_window_id || @editor.current_window_id
+          list = @editor.location_list(owner_window_id)
+          "ll #{list[:index].to_i + 1}/#{list[:items].length}"
+        end
+      )
+      true
     end
 
     def arrow_key?(key)
@@ -630,13 +762,6 @@ module RuVim
       @pending_keys = []
     end
 
-    def current_page_step_lines
-      height = @screen.current_window_view_height(@editor)
-      [height - 1, 1].max
-    rescue StandardError
-      1
-    end
-
     def digit_key?(key)
       key.is_a?(String) && key.match?(/\A\d\z/)
     end
@@ -653,10 +778,21 @@ module RuVim
       when String then key
       when :escape then "\e"
       when :ctrl_r then "<C-r>"
+      when :ctrl_d then "<C-d>"
+      when :ctrl_u then "<C-u>"
+      when :ctrl_f then "<C-f>"
+      when :ctrl_b then "<C-b>"
+      when :ctrl_e then "<C-e>"
+      when :ctrl_y then "<C-y>"
       when :ctrl_v then "<C-v>"
       when :ctrl_i then "<C-i>"
       when :ctrl_o then "<C-o>"
       when :ctrl_w then "<C-w>"
+      when :ctrl_l then "<C-l>"
+      when :left then "<Left>"
+      when :right then "<Right>"
+      when :up then "<Up>"
+      when :down then "<Down>"
       when :home then "<Home>"
       when :end then "<End>"
       when :pageup then "<PageUp>"
@@ -682,17 +818,22 @@ module RuVim
         finish_insert_change_group
         finish_dot_change_capture
         clear_insert_completion
+        clear_pending_key_timeout
         @editor.enter_normal_mode
         @editor.echo("")
       when :command_line
+        clear_pending_key_timeout
+        cancel_incsearch_preview_if_any
         @editor.cancel_command_line
       when :visual_char, :visual_line, :visual_block
         @visual_pending = nil
         @register_pending = false
         @mark_pending = false
         @jump_pending = nil
+        clear_pending_key_timeout
         @editor.enter_normal_mode
       else
+        clear_pending_key_timeout
         @editor.pending_count = nil
         @pending_keys = []
         @operator_pending = nil
@@ -711,6 +852,7 @@ module RuVim
     end
 
     def handle_command_line_submit(prefix, line)
+      clear_incsearch_preview_state(apply: false) if %w[/ ?].include?(prefix)
       case prefix
       when ":"
         verbose_log(2, "ex: #{line}")
@@ -1181,6 +1323,7 @@ module RuVim
       else
         cmd.replace_text(hist[@cmdline_history_index])
       end
+      update_incsearch_preview_if_needed
     end
 
     def command_line_complete
@@ -1193,14 +1336,96 @@ module RuVim
       matches = ex_completion_candidates(ctx)
       case matches.length
       when 0
+        clear_command_line_completion
         @editor.echo("No completion")
       when 1
+        clear_command_line_completion
         cmd.replace_span(ctx[:token_start], ctx[:token_end], matches.first)
       else
-        prefix = common_prefix(matches)
-        cmd.replace_span(ctx[:token_start], ctx[:token_end], prefix) if prefix.length > ctx[:prefix].length
-        @editor.echo(matches.join(" "))
+        apply_wildmode_completion(cmd, ctx, matches)
+      end
+      update_incsearch_preview_if_needed
+    end
+
+    def clear_command_line_completion
+      @cmdline_completion = nil
+    end
+
+    def apply_wildmode_completion(cmd, ctx, matches)
+      mode_steps = wildmode_steps
+      mode_steps = [:full] if mode_steps.empty?
+      state = @cmdline_completion
+      before_text = cmd.text[0...ctx[:token_start]].to_s
+      after_text = cmd.text[ctx[:token_end]..].to_s
+      same = state &&
+             state[:prefix] == cmd.prefix &&
+             state[:kind] == ctx[:kind] &&
+             state[:command] == ctx[:command] &&
+             state[:arg_index] == ctx[:arg_index] &&
+             state[:token_start] == ctx[:token_start] &&
+             state[:before_text] == before_text &&
+             state[:after_text] == after_text &&
+             state[:matches] == matches
+      unless same
+        state = {
+          prefix: cmd.prefix,
+          kind: ctx[:kind],
+          command: ctx[:command],
+          arg_index: ctx[:arg_index],
+          token_start: ctx[:token_start],
+          before_text: before_text,
+          after_text: after_text,
+          matches: matches.dup,
+          step_index: -1,
+          full_index: nil
+        }
+      end
+
+      state[:step_index] += 1
+      step = mode_steps[state[:step_index] % mode_steps.length]
+      case step
+      when :longest
+        pref = common_prefix(matches)
+        cmd.replace_span(ctx[:token_start], ctx[:token_end], pref) if pref.length > ctx[:prefix].length
+      when :list
+        show_command_line_completion_menu(matches, selected: state[:full_index], force: true)
+      when :full
+        state[:full_index] = state[:full_index] ? (state[:full_index] + 1) % matches.length : 0
+        cmd.replace_span(ctx[:token_start], ctx[:token_end], matches[state[:full_index]])
+        show_command_line_completion_menu(matches, selected: state[:full_index], force: false)
+      else
+        pref = common_prefix(matches)
+        cmd.replace_span(ctx[:token_start], ctx[:token_end], pref) if pref.length > ctx[:prefix].length
+      end
+
+      @cmdline_completion = state
+    end
+
+    def wildmode_steps
+      raw = @editor.effective_option("wildmode").to_s
+      return [:full] if raw.empty?
+
+      raw.split(",").flat_map do |tok|
+        tok.to_s.split(":").map do |part|
+          case part.strip.downcase
+          when "longest" then :longest
+          when "list" then :list
+          when "full" then :full
+          end
+        end
+      end.compact
+    end
+
+    def show_command_line_completion_menu(matches, selected:, force:)
+      return unless force || @editor.effective_option("wildmenu")
+
+      limit = [@editor.effective_option("pumheight").to_i, 1].max
+      items = matches.first(limit).each_with_index.map do |m, i|
+        idx = i
+        idx == selected ? "[#{m}]" : m
       end
+      items << "..." if matches.length > limit
+      @editor.echo(items.join(" "))
     end
 
     def common_prefix(strings)
@@ -1219,6 +1444,66 @@ module RuVim
       @insert_completion = nil
     end
 
+    def insert_tab_in_insert_mode
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      if @editor.effective_option("expandtab", window: win, buffer: buf)
+        width = @editor.effective_option("softtabstop", window: win, buffer: buf).to_i
+        width = @editor.effective_option("tabstop", window: win, buffer: buf).to_i if width <= 0
+        width = 2 if width <= 0
+        line = buf.line_at(win.cursor_y)
+        current_col = RuVim::TextMetrics.screen_col_for_char_index(line, win.cursor_x, tabstop: effective_tabstop(win, buf))
+        spaces = width - (current_col % width)
+        spaces = width if spaces <= 0
+        _y, x = buf.insert_text(win.cursor_y, win.cursor_x, " " * spaces)
+        win.cursor_x = x
+      else
+        buf.insert_char(win.cursor_y, win.cursor_x, "\t")
+        win.cursor_x += 1
+      end
+    end
+
+    def apply_insert_autoindent(row, x, previous_row:)
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      return x unless @editor.effective_option("autoindent", window: win, buffer: buf)
+      return x if previous_row.negative?
+
+      prev = buf.line_at(previous_row)
+      indent = prev[/\A[ \t]*/].to_s
+      if @editor.effective_option("smartindent", window: win, buffer: buf)
+        trimmed = prev.rstrip
+        if trimmed.end_with?("{", "[", "(")
+          sw = @editor.effective_option("shiftwidth", window: win, buffer: buf).to_i
+          sw = effective_tabstop(win, buf) if sw <= 0
+          sw = 2 if sw <= 0
+          indent += " " * sw
+        end
+      end
+      return x if indent.empty?
+
+      _y, new_x = buf.insert_text(row, x, indent)
+      new_x
+    end
+
+    def maybe_showmatch_after_insert(key)
+      return unless [")", "]", "}"].include?(key)
+      return unless @editor.effective_option("showmatch")
+
+      mt = @editor.effective_option("matchtime").to_i
+      mt = 5 if mt <= 0
+      @editor.echo_temporary("match", duration_seconds: mt * 0.1)
+    end
+
+    def clear_expired_transient_message_if_any
+      @needs_redraw = true if @editor.clear_expired_transient_message!(now: monotonic_now)
+    end
+
+    def effective_tabstop(window = @editor.current_window, buffer = @editor.current_buffer)
+      v = @editor.effective_option("tabstop", window:, buffer:).to_i
+      v.positive? ? v : 2
+    end
+
     def insert_complete(direction)
       state = ensure_insert_completion_state
       return unless state
@@ -1229,8 +1514,27 @@ module RuVim
         return
       end
 
+      if state[:index].nil? && insert_completion_noselect? && matches.length > 1
+        show_insert_completion_menu(matches, selected: nil)
+        state[:index] = :pending_select
+        return
+      end
+
+      if state[:index].nil? && insert_completion_noinsert?
+        preview_idx = direction.positive? ? 0 : matches.length - 1
+        state[:index] = :pending_insert
+        state[:pending_index] = preview_idx
+        show_insert_completion_menu(matches, selected: preview_idx, current: matches[preview_idx])
+        return
+      end
+
       idx = state[:index]
-      idx = idx.nil? ? (direction.positive? ? 0 : matches.length - 1) : (idx + direction) % matches.length
+      idx = nil if idx == :pending_select
+      if idx == :pending_insert
+        idx = state.delete(:pending_index) || (direction.positive? ? 0 : matches.length - 1)
+      else
+        idx = idx.nil? ? (direction.positive? ? 0 : matches.length - 1) : (idx + direction) % matches.length
+      end
       replacement = matches[idx]
 
       end_col = state[:current_end_col]
@@ -1241,17 +1545,51 @@ module RuVim
       @editor.current_window.cursor_x = new_x
       state[:index] = idx
       state[:current_end_col] = start_col + replacement.length
-      @editor.echo(matches.length == 1 ? replacement : "#{replacement} (#{idx + 1}/#{matches.length})")
+      if matches.length == 1
+        @editor.echo(replacement)
+      else
+        show_insert_completion_menu(matches, selected: idx, current: replacement)
+      end
     rescue StandardError => e
       @editor.echo_error("Completion error: #{e.message}")
       clear_insert_completion
     end
 
+    def insert_completion_noselect?
+      @editor.effective_option("completeopt").to_s.split(",").map { |s| s.strip.downcase }.include?("noselect")
+    end
+
+    def insert_completion_noinsert?
+      @editor.effective_option("completeopt").to_s.split(",").map { |s| s.strip.downcase }.include?("noinsert")
+    end
+
+    def insert_completion_menu_enabled?
+      opts = @editor.effective_option("completeopt").to_s.split(",").map { |s| s.strip.downcase }
+      opts.include?("menu") || opts.include?("menuone")
+    end
+
+    def show_insert_completion_menu(matches, selected:, current: nil)
+      if insert_completion_menu_enabled?
+        limit = [@editor.effective_option("pumheight").to_i, 1].max
+        items = matches.first(limit).each_with_index.map do |m, i|
+          i == selected ? "[#{m}]" : m
+        end
+        items << "..." if matches.length > limit
+        if current
+          @editor.echo("#{current} (#{selected + 1}/#{matches.length}) | #{items.join(' ')}")
+        else
+          @editor.echo(items.join(" "))
+        end
+      elsif current
+        @editor.echo("#{current} (#{selected + 1}/#{matches.length})")
+      end
+    end
+
     def ensure_insert_completion_state
       row = @editor.current_window.cursor_y
       col = @editor.current_window.cursor_x
       line = @editor.current_buffer.line_at(row)
-      prefix = line[0...col].to_s[/[[:alnum:]_]+\z/]
+      prefix = trailing_keyword_fragment(line[0...col].to_s, @editor.current_window, @editor.current_buffer)
       return nil if prefix.nil? || prefix.empty?
 
       start_col = col - prefix.length
@@ -1280,9 +1618,10 @@ module RuVim
     def collect_buffer_word_completions(prefix, current_word:)
       words = []
       seen = {}
+      rx = keyword_scan_regex(@editor.current_window, @editor.current_buffer)
       @editor.buffers.values.each do |buf|
         buf.lines.each do |line|
-          line.scan(/[[:alnum:]_]+/) do |w|
+          line.scan(rx) do |w|
             next unless w.start_with?(prefix)
             next if w == current_word
             next if seen[w]
@@ -1295,6 +1634,210 @@ module RuVim
       words.sort
     end
 
+    def track_mode_transition(mode_before)
+      mode_after = @editor.mode
+      if mode_before != :insert && mode_after == :insert
+        @insert_start_location = @editor.current_location
+      elsif mode_before == :insert && mode_after != :insert
+        @insert_start_location = nil
+      end
+
+      if mode_before != :command_line && mode_after == :command_line
+        @incsearch_preview = nil
+      elsif mode_before == :command_line && mode_after != :command_line
+        @incsearch_preview = nil
+      end
+    end
+
+    def insert_backspace_allowed?
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      row = win.cursor_y
+      col = win.cursor_x
+      return false if row.zero? && col.zero?
+
+      opt = @editor.effective_option("backspace", window: win, buffer: buf).to_s
+      allow = opt.split(",").map { |s| s.strip.downcase }.reject(&:empty?)
+      allow_all = allow.include?("2")
+      allow_indent = allow_all || allow.include?("indent")
+
+      if col.zero? && row.positive?
+        return true if allow_all || allow.include?("eol")
+
+        @editor.echo_error("backspace=eol required")
+        return false
+      end
+
+      if @insert_start_location
+        same_buf = @insert_start_location[:buffer_id] == buf.id
+        if same_buf && (row < @insert_start_location[:row] || (row == @insert_start_location[:row] && col <= @insert_start_location[:col]))
+          if allow_all || allow.include?("start")
+            return true
+          end
+
+          if allow_indent && same_row_autoindent_backspace?(buf, row, col)
+            return true
+          end
+
+          @editor.echo_error("backspace=start required")
+          return false
+        end
+      end
+
+      true
+    end
+
+    def insert_backspace_in_insert_mode
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      row = win.cursor_y
+      col = win.cursor_x
+
+      if row >= 0 && col.positive? && try_softtabstop_backspace(buf, win)
+        return
+      end
+
+      y, x = buf.backspace(row, col)
+      win.cursor_y = y
+      win.cursor_x = x
+    end
+
+    def dispatch_insert_cursor_motion(id)
+      @dispatcher.dispatch(@editor, CommandInvocation.new(id: id, count: 1))
+    rescue StandardError => e
+      @editor.echo_error("Motion error: #{e.message}")
+    end
+
+    def try_softtabstop_backspace(buf, win)
+      row = win.cursor_y
+      col = win.cursor_x
+      line = buf.line_at(row)
+      return false unless line
+      return false unless @editor.effective_option("expandtab", window: win, buffer: buf)
+
+      sts = @editor.effective_option("softtabstop", window: win, buffer: buf).to_i
+      sts = @editor.effective_option("tabstop", window: win, buffer: buf).to_i if sts <= 0
+      return false if sts <= 0
+
+      prefix = line[0...col].to_s
+      m = prefix.match(/ +\z/)
+      return false unless m
+
+      run = m[0].length
+      return false if run <= 1
+
+      tabstop = effective_tabstop(win, buf)
+      cur_screen = RuVim::TextMetrics.screen_col_for_char_index(line, col, tabstop:)
+      target_screen = [cur_screen - sts, 0].max
+      target_col = RuVim::TextMetrics.char_index_for_screen_col(line, target_screen, tabstop:, align: :floor)
+      delete_cols = col - target_col
+      delete_cols = [delete_cols, run, sts].min
+      return false if delete_cols <= 1
+
+      # Only collapse whitespace run; if target lands before the run, clamp to run start.
+      run_start = col - run
+      target_col = [target_col, run_start].max
+      delete_cols = col - target_col
+      return false if delete_cols <= 1
+
+      buf.delete_span(row, target_col, row, col)
+      win.cursor_x = target_col
+      true
+    rescue StandardError
+      false
+    end
+
+    def same_row_autoindent_backspace?(buf, row, col)
+      return false unless @insert_start_location
+      return false unless row == @insert_start_location[:row]
+      return false unless col <= @insert_start_location[:col]
+
+      line = buf.line_at(row)
+      line[0...@insert_start_location[:col]].to_s.match?(/\A[ \t]*\z/)
+    rescue StandardError
+      false
+    end
+
+    def incsearch_enabled?
+      return false unless @editor.command_line_active?
+      return false unless ["/", "?"].include?(@editor.command_line.prefix)
+
+      !!@editor.effective_option("incsearch")
+    end
+
+    def update_incsearch_preview_if_needed
+      return unless incsearch_enabled?
+
+      cmd = @editor.command_line
+      ensure_incsearch_preview_origin!(direction: (cmd.prefix == "/" ? :forward : :backward))
+      pattern = cmd.text.to_s
+      if pattern.empty?
+        clear_incsearch_preview_state(apply: false)
+        return
+      end
+
+      buf = @editor.current_buffer
+      win = @editor.current_window
+      origin = @incsearch_preview[:origin]
+      tmp_window = RuVim::Window.new(id: -1, buffer_id: buf.id)
+      tmp_window.cursor_y = origin[:row]
+      tmp_window.cursor_x = origin[:col]
+      regex = GlobalCommands.instance.send(:compile_search_regex, pattern, editor: @editor, window: win, buffer: buf)
+      match = GlobalCommands.instance.send(:find_next_match, buf, tmp_window, regex, direction: @incsearch_preview[:direction])
+      if match
+        win.cursor_y = match[:row]
+        win.cursor_x = match[:col]
+        win.clamp_to_buffer(buf)
+      end
+      @incsearch_preview[:active] = true
+    rescue RuVim::CommandError, RegexpError
+      # Keep editing command-line without forcing an error flash on every keystroke.
+    end
+
+    def ensure_incsearch_preview_origin!(direction:)
+      return if @incsearch_preview
+
+      @incsearch_preview = {
+        origin: @editor.current_location,
+        direction: direction,
+        active: false
+      }
+    end
+
+    def cancel_incsearch_preview_if_any
+      clear_incsearch_preview_state(apply: false)
+    end
+
+    def clear_incsearch_preview_state(apply:)
+      return unless @incsearch_preview
+
+      if !apply && @incsearch_preview[:origin]
+        @editor.jump_to_location(@incsearch_preview[:origin])
+      end
+      @incsearch_preview = nil
+    end
+
+    def trailing_keyword_fragment(prefix_text, window, buffer)
+      cls = keyword_char_class(window, buffer)
+      prefix_text.to_s[/[#{cls}]+\z/]
+    rescue RegexpError
+      prefix_text.to_s[/[[:alnum:]_]+\z/]
+    end
+
+    def keyword_scan_regex(window, buffer)
+      cls = keyword_char_class(window, buffer)
+      /[#{cls}]+/
+    rescue RegexpError
+      /[[:alnum:]_]+/
+    end
+
+    def keyword_char_class(window, buffer)
+      raw = @editor.effective_option("iskeyword", window:, buffer:).to_s
+      RuVim::KeywordChars.char_class(raw)
+    rescue StandardError
+      "[:alnum:]_"
+    end
+
     def ex_completion_context(cmd)
       text = cmd.text
       cursor = cmd.cursor
@@ -1369,12 +1912,27 @@ module RuVim
       Dir.glob(pattern, File::FNM_DOTMATCH).sort.filter_map do |p|
         next if [".", ".."].include?(File.basename(p))
         next unless p.start_with?(input) || input.empty?
+        next if wildignore_path?(p)
         File.directory?(p) ? "#{p}/" : p
       end
     rescue StandardError
       []
     end
 
+    def wildignore_path?(path)
+      spec = @editor.global_options["wildignore"].to_s
+      return false if spec.empty?
+
+      flags = @editor.global_options["wildignorecase"] ? File::FNM_CASEFOLD : 0
+      name = path.to_s
+      base = File.basename(name)
+      spec.split(",").map(&:strip).reject(&:empty?).any? do |pat|
+        File.fnmatch?(pat, name, flags) || File.fnmatch?(pat, base, flags)
+      end
+    rescue StandardError
+      false
+    end
+
     def buffer_completion_candidates(prefix)
       pfx = prefix.to_s
       items = @editor.buffers.values.flat_map do |b|