ruvim 0.1.0 → 0.2.0

data/lib/ruvim/global_commands.rb

@@ -1,3 +1,6 @@
+require "tempfile"
+require "open3"
+
 module RuVim
   class GlobalCommands
     include Singleton
@@ -12,11 +15,11 @@ module RuVim
     end
 
     def cursor_left(ctx, count:, **)
-      ctx.window.move_left(ctx.buffer, count)
+      move_cursor_horizontally(ctx, direction: :left, count:)
     end
 
     def cursor_right(ctx, count:, **)
-      ctx.window.move_right(ctx.buffer, count)
+      move_cursor_horizontally(ctx, direction: :right, count:)
     end
 
     def cursor_up(ctx, count:, **)
@@ -37,6 +40,38 @@ module RuVim
       ctx.window.move_down(ctx.buffer, page_lines * [count.to_i, 1].max)
     end
 
+    def cursor_page_up_default(ctx, count:, bang:, **)
+      call(:cursor_page_up, ctx, count:, bang:, kwargs: { page_lines: current_page_step_lines(ctx) })
+    end
+
+    def cursor_page_down_default(ctx, count:, bang:, **)
+      call(:cursor_page_down, ctx, count:, bang:, kwargs: { page_lines: current_page_step_lines(ctx) })
+    end
+
+    def cursor_page_up_half(ctx, count:, bang:, **)
+      call(:cursor_page_up, ctx, count:, bang:, kwargs: { page_lines: current_half_page_step_lines(ctx) })
+    end
+
+    def cursor_page_down_half(ctx, count:, bang:, **)
+      call(:cursor_page_down, ctx, count:, bang:, kwargs: { page_lines: current_half_page_step_lines(ctx) })
+    end
+
+    def window_scroll_up(ctx, kwargs:, count:, **)
+      scroll_window_vertically(ctx, direction: :up, lines: kwargs[:lines] || kwargs["lines"], view_height: kwargs[:view_height] || kwargs["view_height"], count:)
+    end
+
+    def window_scroll_down(ctx, kwargs:, count:, **)
+      scroll_window_vertically(ctx, direction: :down, lines: kwargs[:lines] || kwargs["lines"], view_height: kwargs[:view_height] || kwargs["view_height"], count:)
+    end
+
+    def window_scroll_up_line(ctx, count:, bang:, **)
+      call(:window_scroll_up, ctx, count:, bang:, kwargs: { lines: 1, view_height: current_view_height(ctx) + 1 })
+    end
+
+    def window_scroll_down_line(ctx, count:, bang:, **)
+      call(:window_scroll_down, ctx, count:, bang:, kwargs: { lines: 1, view_height: current_view_height(ctx) + 1 })
+    end
+
     def cursor_line_start(ctx, **)
       ctx.window.cursor_x = 0
       ctx.window.clamp_to_buffer(ctx.buffer)
@@ -149,6 +184,7 @@ module RuVim
       x = ctx.buffer.line_length(y)
       ctx.buffer.begin_change_group
       new_y, new_x = ctx.buffer.insert_newline(y, x)
+      new_x = apply_autoindent_to_newline(ctx, row: new_y, previous_row: y, start_col: new_x)
       ctx.window.cursor_y = new_y
       ctx.window.cursor_x = new_x
       ctx.editor.enter_insert_mode
@@ -159,8 +195,10 @@ module RuVim
       materialize_intro_buffer_if_needed(ctx)
       y = ctx.window.cursor_y
       ctx.buffer.begin_change_group
-      ctx.buffer.insert_newline(y, 0)
-      ctx.window.cursor_x = 0
+      _new_y, new_x = ctx.buffer.insert_newline(y, 0)
+      new_x = apply_autoindent_to_newline(ctx, row: y, previous_row: y + 1, start_col: 0)
+      ctx.window.cursor_y = y
+      ctx.window.cursor_x = new_x
       ctx.editor.enter_insert_mode
       ctx.editor.echo("-- INSERT --")
     end
@@ -181,12 +219,14 @@ module RuVim
     end
 
     def window_split(ctx, **)
-      ctx.editor.split_current_window(layout: :horizontal)
+      place = ctx.editor.effective_option("splitbelow", window: ctx.window, buffer: ctx.buffer) ? :after : :before
+      ctx.editor.split_current_window(layout: :horizontal, place:)
       ctx.editor.echo("split")
     end
 
     def window_vsplit(ctx, **)
-      ctx.editor.split_current_window(layout: :vertical)
+      place = ctx.editor.effective_option("splitright", window: ctx.window, buffer: ctx.buffer) ? :after : :before
+      ctx.editor.split_current_window(layout: :vertical, place:)
       ctx.editor.echo("vsplit")
     end
 
@@ -212,9 +252,11 @@ module RuVim
 
     def tab_new(ctx, argv:, **)
       path = argv[0]
-      if ctx.buffer.modified?
-        ctx.editor.echo_error("Unsaved changes (use :w or :q!)")
-        return
+      if ctx.buffer.modified? && !ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+        unless maybe_autowrite_before_switch(ctx)
+          ctx.editor.echo_error("Unsaved changes (use :w or :q!)")
+          return
+        end
       end
       tab = ctx.editor.tabnew(path: path)
       if path && !path.empty?
@@ -423,7 +465,7 @@ module RuVim
       when "w"
         y = ctx.window.cursor_y
         x = ctx.window.cursor_x
-        target = advance_word_forward(ctx.buffer, y, x, count)
+        target = advance_word_forward(ctx.buffer, y, x, count, editor: ctx.editor, window: ctx.window)
         target ||= { row: y, col: x }
         text = ctx.buffer.span_text(y, x, target[:row], target[:col])
         store_yank_register(ctx, text:, type: :charwise)
@@ -587,8 +629,14 @@ module RuVim
       end
 
       if ctx.buffer.modified? && !bang
-        ctx.editor.echo_error("Unsaved changes (use :e! to discard and open)")
-        return
+        if ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+          # hidden permits abandoning a modified buffer without forcing write.
+        elsif maybe_autowrite_before_switch(ctx)
+          # autowrite handled
+        else
+          ctx.editor.echo_error("Unsaved changes (use :e! to discard and open)")
+          return
+        end
       end
 
       new_buffer = ctx.editor.add_buffer_from_file(path)
@@ -596,6 +644,29 @@ module RuVim
       ctx.editor.echo(File.exist?(path) ? "\"#{path}\" #{new_buffer.line_count}L" : "\"#{path}\" [New File]")
     end
 
+    def file_goto_under_cursor(ctx, **)
+      token = file_token_under_cursor(ctx.buffer, ctx.window)
+      if token.nil? || token.empty?
+        ctx.editor.echo_error("No file under cursor")
+        return
+      end
+
+      path = resolve_gf_path(ctx, token)
+      unless path
+        ctx.editor.echo_error("File not found: #{token}")
+        return
+      end
+
+      if ctx.buffer.modified? && !ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+        unless maybe_autowrite_before_switch(ctx)
+          ctx.editor.echo_error("Unsaved changes (set hidden or :w)")
+          return
+        end
+      end
+
+      ctx.editor.open_path(path)
+    end
+
     def buffer_list(ctx, **)
       current_id = ctx.buffer.id
       alt_id = ctx.editor.alternate_buffer_id
@@ -639,6 +710,28 @@ module RuVim
       switch_buffer_id(ctx, target_id, bang:)
     end
 
+    def buffer_delete(ctx, argv:, bang:, **)
+      arg = argv[0]
+      target_id =
+        if arg.nil? || arg.empty?
+          ctx.buffer.id
+        elsif arg == "#"
+          ctx.editor.alternate_buffer_id || raise(RuVim::CommandError, "No alternate buffer")
+        elsif arg.match?(/\A\d+\z/)
+          arg.to_i
+        else
+          find_buffer_by_name(ctx.editor, arg)&.id || raise(RuVim::CommandError, "No such buffer: #{arg}")
+        end
+
+      target = ctx.editor.buffers[target_id] || raise(RuVim::CommandError, "No such buffer: #{target_id}")
+      if target.modified? && !bang
+        raise RuVim::CommandError, "No write since last change (use :bdelete! to discard)"
+      end
+
+      ctx.editor.delete_buffer(target_id)
+      ctx.editor.echo("buffer #{target_id} deleted")
+    end
+
     def ex_help(ctx, argv: [], **)
       topic = argv.first.to_s
       registry = RuVim::ExCommandRegistry.instance
@@ -724,13 +817,98 @@ module RuVim
       raise RuVim::CommandError, "Usage: :ruby <code>" if code.strip.empty?
 
       b = binding
+      # Use local_variable_set for eval locals to avoid "assigned but unused variable"
+      # warnings while still exposing editor/buffer/window in :ruby.
       b.local_variable_set(:editor, ctx.editor)
       b.local_variable_set(:buffer, ctx.buffer)
       b.local_variable_set(:window, ctx.window)
-      result = eval(code, b) # rubocop:disable Security/Eval
-      ctx.editor.echo(result.nil? ? "ruby: nil" : "ruby: #{result.inspect}")
+      saved_stdout = STDOUT.dup
+      saved_stderr = STDERR.dup
+      original_g_stdout = $stdout
+      original_g_stderr = $stderr
+      result = nil
+      stdout_text = ""
+      stderr_text = ""
+      Tempfile.create("ruvim-ruby-stdout") do |outf|
+        Tempfile.create("ruvim-ruby-stderr") do |errf|
+          STDOUT.reopen(outf)
+          STDERR.reopen(errf)
+          $stdout = STDOUT
+          $stderr = STDERR
+          result = eval(code, b) # rubocop:disable Security/Eval
+          STDOUT.flush
+          STDERR.flush
+          outf.flush
+          errf.flush
+          outf.rewind
+          errf.rewind
+          stdout_text = outf.read.to_s
+          stderr_text = errf.read.to_s
+        end
+      end
+      if !stdout_text.empty? || !stderr_text.empty?
+        lines = ["Ruby output", ""]
+        unless stdout_text.empty?
+          lines << "[stdout]"
+          lines.concat(stdout_text.lines(chomp: true))
+          lines << ""
+        end
+        unless stderr_text.empty?
+          lines << "[stderr]"
+          lines.concat(stderr_text.lines(chomp: true))
+          lines << ""
+        end
+        lines << "[result]"
+        lines << (result.nil? ? "nil" : result.inspect)
+        ctx.editor.show_help_buffer!(title: "[Ruby Output]", lines:, filetype: "ruby")
+      else
+        ctx.editor.echo(result.nil? ? "ruby: nil" : "ruby: #{result.inspect}")
+      end
     rescue StandardError => e
       raise RuVim::CommandError, "Ruby error: #{e.class}: #{e.message}"
+    ensure
+      if defined?(saved_stdout) && saved_stdout
+        STDOUT.reopen(saved_stdout)
+        saved_stdout.close unless saved_stdout.closed?
+      end
+      if defined?(saved_stderr) && saved_stderr
+        STDERR.reopen(saved_stderr)
+        saved_stderr.close unless saved_stderr.closed?
+      end
+      $stdout = (defined?(original_g_stdout) && original_g_stdout) ? original_g_stdout : STDOUT
+      $stderr = (defined?(original_g_stderr) && original_g_stderr) ? original_g_stderr : STDERR
+    end
+
+    def ex_shell(ctx, command:, **)
+      raise RuVim::CommandError, "Restricted mode: :! is disabled" if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+
+      cmd = command.to_s
+      raise RuVim::CommandError, "Usage: :!<command>" if cmd.strip.empty?
+
+      shell = ENV["SHELL"].to_s
+      shell = "/bin/sh" if shell.empty?
+      stdout_text, stderr_text, status = Open3.capture3(shell, "-c", cmd)
+
+      if !stdout_text.to_s.empty? || !stderr_text.to_s.empty?
+        lines = ["Shell output", "", "[command]", cmd, ""]
+        unless stdout_text.to_s.empty?
+          lines << "[stdout]"
+          lines.concat(stdout_text.to_s.lines(chomp: true))
+          lines << ""
+        end
+        unless stderr_text.to_s.empty?
+          lines << "[stderr]"
+          lines.concat(stderr_text.to_s.lines(chomp: true))
+          lines << ""
+        end
+        lines << "[status]"
+        lines << "exit #{status.exitstatus}"
+        ctx.editor.show_help_buffer!(title: "[Shell Output]", lines:, filetype: "sh")
+      else
+        ctx.editor.echo("shell exit #{status.exitstatus}")
+      end
+    rescue Errno::ENOENT => e
+      raise RuVim::CommandError, "Shell error: #{e.message}"
     end
 
     def ex_commands(ctx, **)
@@ -783,7 +961,7 @@ module RuVim
     end
 
     def ex_copen(ctx, **)
-      open_list_window(ctx, kind: :quickfix, title: "[Quickfix]", lines: quickfix_buffer_lines(ctx.editor))
+      open_list_window(ctx, kind: :quickfix, title: "[Quickfix]", lines: quickfix_buffer_lines(ctx.editor), source_window_id: ctx.window.id)
     end
 
     def ex_cclose(ctx, **)
@@ -811,7 +989,8 @@ module RuVim
     end
 
     def ex_lopen(ctx, **)
-      open_list_window(ctx, kind: :location_list, title: "[Location List]", lines: location_list_buffer_lines(ctx.editor, ctx.window.id))
+      open_list_window(ctx, kind: :location_list, title: "[Location List]", lines: location_list_buffer_lines(ctx.editor, ctx.window.id),
+                       source_window_id: ctx.window.id)
     end
 
     def ex_lclose(ctx, **)
@@ -933,10 +1112,11 @@ module RuVim
       ]
     end
 
-    def open_list_window(ctx, kind:, title:, lines:)
+    def open_list_window(ctx, kind:, title:, lines:, source_window_id:)
       editor = ctx.editor
       editor.split_current_window(layout: :horizontal)
       buffer = editor.add_virtual_buffer(kind:, name: title, lines:, filetype: "qf", readonly: true, modifiable: false)
+      buffer.options["ruvim_list_source_window_id"] = source_window_id
       editor.switch_to_buffer(buffer.id)
       editor.echo(title)
       buffer
@@ -979,9 +1159,11 @@ module RuVim
         raise RuVim::CommandError, "No such buffer: #{buffer_id}"
       end
 
-      if ctx.buffer.modified? && ctx.buffer.id != buffer_id && !bang
-        ctx.editor.echo_error("Unsaved changes (use :w or :buffer! / :bnext! / :bprev!)")
-        return
+      if ctx.buffer.modified? && ctx.buffer.id != buffer_id && !bang && !ctx.editor.effective_option("hidden", window: ctx.window, buffer: ctx.buffer)
+        unless maybe_autowrite_before_switch(ctx)
+          ctx.editor.echo_error("Unsaved changes (use :w or :buffer! / :bnext! / :bprev!)")
+          return
+        end
       end
 
       record_jump(ctx)
@@ -1017,28 +1199,55 @@ module RuVim
       end.join("\n")
     end
 
+    def apply_autoindent_to_newline(ctx, row:, previous_row:, start_col: 0)
+      return start_col unless ctx.editor.effective_option("autoindent", window: ctx.window, buffer: ctx.buffer)
+
+      prev = ctx.buffer.line_at(previous_row)
+      indent = prev[/\A[ \t]*/].to_s
+
+      if ctx.editor.effective_option("smartindent", window: ctx.window, buffer: ctx.buffer)
+        trimmed = prev.rstrip
+        if trimmed.end_with?("{", "[", "(")
+          sw = ctx.editor.effective_option("shiftwidth", window: ctx.window, buffer: ctx.buffer).to_i
+          sw = 2 if sw <= 0
+          indent += " " * sw
+        end
+      end
+
+      return start_col if indent.empty?
+
+      _y, x = ctx.buffer.insert_text(row, start_col, indent)
+      x
+    end
+
     def search_current_word(ctx, exact:, direction:)
-      word = current_word_under_cursor(ctx.buffer, ctx.window)
+      keyword_rx = keyword_char_regex(ctx.editor, ctx.buffer, ctx.window)
+      word = current_word_under_cursor(ctx.buffer, ctx.window, keyword_rx:)
       if word.nil? || word.empty?
         ctx.editor.echo("No word under cursor")
         return
       end
 
-      pattern = exact ? "\\b#{Regexp.escape(word)}\\b" : Regexp.escape(word)
+      pattern =
+        if exact
+          "(?<!#{keyword_rx.source})#{Regexp.escape(word)}(?!#{keyword_rx.source})"
+        else
+          Regexp.escape(word)
+        end
       ctx.editor.set_last_search(pattern:, direction:)
       move_to_search(ctx, pattern:, direction:, count: 1)
     end
 
-    def current_word_under_cursor(buffer, window)
+    def current_word_under_cursor(buffer, window, keyword_rx: /[[:alnum:]_]/)
       line = buffer.line_at(window.cursor_y)
       return nil if line.empty?
 
       x = [window.cursor_x, line.length - 1].min
       return nil if x.negative?
 
-      if line[x] !~ /[[:alnum:]_]/
+      if !keyword_char?(line[x], keyword_rx)
         left = x - 1
-        if left >= 0 && line[left] =~ /[[:alnum:]_]/
+        if left >= 0 && keyword_char?(line[left], keyword_rx)
           x = left
         else
           return nil
@@ -1046,9 +1255,9 @@ module RuVim
       end
 
       s = x
-      s -= 1 while s.positive? && line[s - 1] =~ /[[:alnum:]_]/
+      s -= 1 while s.positive? && keyword_char?(line[s - 1], keyword_rx)
       e = x + 1
-      e += 1 while e < line.length && line[e] =~ /[[:alnum:]_]/
+      e += 1 while e < line.length && keyword_char?(line[e], keyword_rx)
       line[s...e]
     end
 
@@ -1132,7 +1341,7 @@ module RuVim
     def delete_word_forward(ctx, count)
       y = ctx.window.cursor_y
       x = ctx.window.cursor_x
-      target = advance_word_forward(ctx.buffer, y, x, count)
+      target = advance_word_forward(ctx.buffer, y, x, count, editor: ctx.editor, window: ctx.window)
       return true unless target
 
       deleted = ctx.buffer.span_text(y, x, target[:row], target[:col])
@@ -1194,12 +1403,13 @@ module RuVim
       true
     end
 
-    def advance_word_forward(buffer, row, col, count)
+    def advance_word_forward(buffer, row, col, count, editor: nil, window: nil)
       text = buffer.lines.join("\n")
       flat = cursor_to_offset(buffer, row, col)
       idx = flat
+      keyword_rx = keyword_char_regex(editor, buffer, window)
       count.times do
-        idx = next_word_start_offset(text, idx)
+        idx = next_word_start_offset(text, idx, keyword_rx)
         return nil unless idx
       end
       offset_to_cursor(buffer, idx)
@@ -1214,9 +1424,9 @@ module RuVim
       count.times do
         target =
           case kind
-          when :forward_start then advance_word_forward(buffer, target[:row], target[:col], 1)
-          when :backward_start then advance_word_backward(buffer, target[:row], target[:col], 1)
-          when :forward_end then advance_word_end(buffer, target[:row], target[:col], 1)
+          when :forward_start then advance_word_forward(buffer, target[:row], target[:col], 1, editor: ctx.editor, window: ctx.window)
+          when :backward_start then advance_word_backward(buffer, target[:row], target[:col], 1, editor: ctx.editor, window: ctx.window)
+          when :forward_end then advance_word_end(buffer, target[:row], target[:col], 1, editor: ctx.editor, window: ctx.window)
           end
         break unless target
       end
@@ -1227,60 +1437,62 @@ module RuVim
       ctx.window.clamp_to_buffer(buffer)
     end
 
-    def advance_word_backward(buffer, row, col, _count)
+    def advance_word_backward(buffer, row, col, _count, editor: nil, window: nil)
       text = buffer.lines.join("\n")
       idx = cursor_to_offset(buffer, row, col)
       idx = [idx - 1, 0].max
-      while idx > 0 && char_class(text[idx]) == :space
+      keyword_rx = keyword_char_regex(editor, buffer, window)
+      while idx > 0 && char_class(text[idx], keyword_rx) == :space
         idx -= 1
       end
-      cls = char_class(text[idx])
-      while idx > 0 && char_class(text[idx - 1]) == cls && cls != :space
+      cls = char_class(text[idx], keyword_rx)
+      while idx > 0 && char_class(text[idx - 1], keyword_rx) == cls && cls != :space
         idx -= 1
       end
-      while idx > 0 && char_class(text[idx]) == :space
+      while idx > 0 && char_class(text[idx], keyword_rx) == :space
         idx += 1
       end
       offset_to_cursor(buffer, idx)
     end
 
-    def advance_word_end(buffer, row, col, _count)
+    def advance_word_end(buffer, row, col, _count, editor: nil, window: nil)
       text = buffer.lines.join("\n")
       idx = cursor_to_offset(buffer, row, col)
       n = text.length
-      while idx < n && char_class(text[idx]) == :space
+      keyword_rx = keyword_char_regex(editor, buffer, window)
+      while idx < n && char_class(text[idx], keyword_rx) == :space
         idx += 1
       end
       return nil if idx >= n
 
-      cls = char_class(text[idx])
-      idx += 1 while idx + 1 < n && char_class(text[idx + 1]) == cls && cls != :space
+      cls = char_class(text[idx], keyword_rx)
+      idx += 1 while idx + 1 < n && char_class(text[idx + 1], keyword_rx) == cls && cls != :space
       offset_to_cursor(buffer, idx)
     end
 
-    def next_word_start_offset(text, from_offset)
+    def next_word_start_offset(text, from_offset, keyword_rx = nil)
       i = [from_offset, 0].max
       n = text.length
       return nil if i >= n
 
-      cls = char_class(text[i])
+      cls = char_class(text[i], keyword_rx)
       if cls == :word
-        i += 1 while i < n && char_class(text[i]) == :word
+        i += 1 while i < n && char_class(text[i], keyword_rx) == :word
       elsif cls == :space
-        i += 1 while i < n && char_class(text[i]) == :space
+        i += 1 while i < n && char_class(text[i], keyword_rx) == :space
       else
         i += 1
       end
-      i += 1 while i < n && char_class(text[i]) == :space
+      i += 1 while i < n && char_class(text[i], keyword_rx) == :space
       return n if i > n
 
       i <= n ? i : nil
     end
 
-    def char_class(ch)
+    def char_class(ch, keyword_rx = nil)
       return :space if ch == "\n"
       return :space if ch =~ /\s/
-      return :word if ch =~ /[[:alnum:]_]/
+      return :word if keyword_char?(ch, keyword_rx)
       :punct
     end
 
@@ -1306,11 +1518,12 @@ module RuVim
         x = nxt
       end
 
-      cls = line[x] =~ /[[:alnum:]_]/ ? :word : :punct
+      keyword_rx = keyword_char_regex(nil, buffer, window)
+      cls = keyword_char?(line[x], keyword_rx) ? :word : :punct
       start_col = x
-      start_col -= 1 while start_col.positive? && same_word_class?(line[start_col - 1], cls)
+      start_col -= 1 while start_col.positive? && same_word_class?(line[start_col - 1], cls, keyword_rx)
       end_col = x + 1
-      end_col += 1 while end_col < line.length && same_word_class?(line[end_col], cls)
+      end_col += 1 while end_col < line.length && same_word_class?(line[end_col], cls, keyword_rx)
 
       if around
         while end_col < line.length && line[end_col] =~ /\s/
@@ -1493,15 +1706,146 @@ module RuVim
       nil
     end
 
-    def same_word_class?(ch, cls)
+    def same_word_class?(ch, cls, keyword_rx = nil)
       return false if ch.nil?
       case cls
-      when :word then ch =~ /[[:alnum:]_]/
-      when :punct then !(ch =~ /[[:alnum:]_\s]/)
+      when :word then keyword_char?(ch, keyword_rx)
+      when :punct then !(keyword_char?(ch, keyword_rx) || ch =~ /\s/)
       else false
       end
     end
 
+    def keyword_char?(ch, keyword_rx = nil)
+      return false if ch.nil?
+
+      (keyword_rx || /[[:alnum:]_]/).match?(ch)
+    end
+
+    def keyword_char_regex(editor, buffer, window)
+      win = window || editor&.current_window
+      buf = buffer || editor&.current_buffer
+      raw =
+        if editor
+          editor.effective_option("iskeyword", window: win, buffer: buf).to_s
+        else
+          buf&.options&.fetch("iskeyword", nil).to_s
+        end
+      RuVim::KeywordChars.regex(raw)
+    end
+
+    def move_cursor_horizontally(ctx, direction:, count:)
+      count = [count.to_i, 1].max
+      allow_wrap = whichwrap_allows?(ctx, direction)
+      virtualedit_mode = virtualedit_mode(ctx)
+      count.times do
+        line = ctx.buffer.line_at(ctx.window.cursor_y)
+        if direction == :left
+          if ctx.window.cursor_x > line.length && virtualedit_mode
+            ctx.window.cursor_x -= 1
+          elsif ctx.window.cursor_x.positive?
+            ctx.window.cursor_x = RuVim::TextMetrics.previous_grapheme_char_index(line, ctx.window.cursor_x)
+          elsif allow_wrap && ctx.window.cursor_y.positive?
+            ctx.window.cursor_y -= 1
+            ctx.window.cursor_x = ctx.buffer.line_length(ctx.window.cursor_y)
+          end
+        else
+          max_right =
+            case virtualedit_mode
+            when :all then line.length + count + 1024 # practical cap; clamp below uses current cursor
+            when :onemore then line.length + 1
+            else line.length
+            end
+          if ctx.window.cursor_x < max_right
+            ctx.window.cursor_x =
+              if virtualedit_mode == :onemore && ctx.window.cursor_x == line.length
+                line.length + 1
+              elsif virtualedit_mode == :all && ctx.window.cursor_x >= line.length
+                ctx.window.cursor_x + 1
+              else
+                RuVim::TextMetrics.next_grapheme_char_index(line, ctx.window.cursor_x)
+              end
+            ctx.window.cursor_x = [ctx.window.cursor_x, max_right].min
+          elsif allow_wrap && ctx.window.cursor_y < ctx.buffer.line_count - 1
+            ctx.window.cursor_y += 1
+            ctx.window.cursor_x = 0
+          end
+        end
+      end
+      extra =
+        case virtualedit_mode
+        when :all
+          [ctx.window.cursor_x - ctx.buffer.line_length(ctx.window.cursor_y), 0].max
+        when :onemore
+          1
+        else
+          0
+        end
+      ctx.window.clamp_to_buffer(ctx.buffer, max_extra_col: extra)
+    end
+
+    def whichwrap_allows?(ctx, direction)
+      toks = ctx.editor.effective_option("whichwrap", window: ctx.window, buffer: ctx.buffer).to_s
+               .split(",").map { |s| s.strip.downcase }.reject(&:empty?)
+      return false if toks.empty?
+
+      if direction == :left
+        toks.include?("h") || toks.include?("<") || toks.include?("left")
+      else
+        toks.include?("l") || toks.include?(">") || toks.include?("right")
+      end
+    end
+
+    def virtualedit_mode(ctx)
+      spec = ctx.editor.effective_option("virtualedit", window: ctx.window, buffer: ctx.buffer).to_s
+      toks = spec.split(",").map { |s| s.strip.downcase }
+      return :all if toks.include?("all")
+      return :onemore if toks.include?("onemore")
+
+      nil
+    end
+
+    def current_view_height(ctx)
+      hint = ctx.editor.respond_to?(:current_window_view_height_hint) ? ctx.editor.current_window_view_height_hint : nil
+      [hint.to_i, 1].max
+    rescue StandardError
+      1
+    end
+
+    def current_page_step_lines(ctx)
+      [current_view_height(ctx) - 1, 1].max
+    end
+
+    def current_half_page_step_lines(ctx)
+      [current_view_height(ctx) / 2, 1].max
+    end
+
+    def scroll_window_vertically(ctx, direction:, lines:, view_height:, count:)
+      step = [[lines.to_i, 1].max * [count.to_i, 1].max, 1].max
+      height = [view_height.to_i, 1].max
+      max_row_offset = [ctx.buffer.line_count - height, 0].max
+
+      before = ctx.window.row_offset.to_i
+      after =
+        if direction == :up
+          [before - step, 0].max
+        else
+          [before + step, max_row_offset].min
+        end
+      return if after == before
+
+      ctx.window.row_offset = after
+
+      # Vim-like behavior: scroll viewport first, then keep cursor inside it.
+      top = after
+      bottom = after + height - 1
+      if ctx.window.cursor_y < top
+        ctx.window.cursor_y = top
+      elsif ctx.window.cursor_y > bottom
+        ctx.window.cursor_y = bottom
+      end
+      ctx.window.clamp_to_buffer(ctx.buffer)
+    end
+
     def cursor_to_offset(buffer, row, col)
       offset = 0
       row.times { |r| offset += buffer.line_length(r) + 1 }
@@ -1612,6 +1956,107 @@ module RuVim
       nil
     end
 
+    def maybe_autowrite_before_switch(ctx)
+      return false unless ctx.editor.effective_option("autowrite", window: ctx.window, buffer: ctx.buffer)
+      return false unless ctx.buffer.file_buffer?
+      return false unless ctx.buffer.path && !ctx.buffer.path.empty?
+
+      ctx.buffer.write_to(ctx.buffer.path)
+      true
+    rescue StandardError
+      false
+    end
+
+    def file_token_under_cursor(buffer, window)
+      line = buffer.line_at(window.cursor_y)
+      return nil if line.empty?
+
+      x = [[window.cursor_x, 0].max, [line.length - 1, 0].max].min
+      file_char = /[[:alnum:]_\.\/~-]/
+      if line[x] !~ file_char
+        left = x - 1
+        right = x + 1
+        if left >= 0 && line[left] =~ file_char
+          x = left
+        elsif right < line.length && line[right] =~ file_char
+          x = right
+        else
+          return nil
+        end
+      end
+
+      s = x
+      e = x + 1
+      s -= 1 while s.positive? && line[s - 1] =~ file_char
+      e += 1 while e < line.length && line[e] =~ file_char
+      line[s...e]
+    end
+
+    def resolve_gf_path(ctx, token)
+      candidates = gf_candidate_paths(ctx, token.to_s)
+      candidates.find { |p| File.file?(p) || File.directory?(p) }
+    end
+
+    def gf_candidate_paths(ctx, token)
+      suffixes = gf_suffixes(ctx)
+      names = [token]
+      if File.extname(token).empty?
+        suffixes.each { |suf| names << "#{token}#{suf}" }
+      end
+      names.uniq!
+
+      if token.start_with?("/", "~/")
+        return names.map { |n| File.expand_path(n) }.uniq
+      end
+
+      base_dirs = gf_search_dirs(ctx)
+      base_dirs.product(names).map { |dir, name| File.expand_path(name, dir) }.uniq
+    end
+
+    def gf_search_dirs(ctx)
+      current_dir = if ctx.buffer.path && !ctx.buffer.path.empty?
+                      File.dirname(File.expand_path(ctx.buffer.path))
+                    else
+                      Dir.pwd
+                    end
+      raw = ctx.editor.effective_option("path", window: ctx.window, buffer: ctx.buffer).to_s
+      dirs = raw.split(",").map(&:strip).reject(&:empty?)
+      dirs = ["."] if dirs.empty?
+      dirs.flat_map do |dir|
+        expand_gf_path_entry(dir, current_dir)
+      end.uniq
+    rescue StandardError
+      [Dir.pwd]
+    end
+
+    def gf_suffixes(ctx)
+      raw = ctx.editor.effective_option("suffixesadd", window: ctx.window, buffer: ctx.buffer).to_s
+      raw.split(",").map(&:strip).reject(&:empty?).map do |s|
+        s.start_with?(".") ? s : ".#{s}"
+      end
+    end
+
+    def expand_gf_path_entry(entry, current_dir)
+      dir = entry.to_s
+      return [current_dir] if dir.empty? || dir == "."
+
+      expanded = File.expand_path(dir, current_dir)
+      if expanded.end_with?("/**")
+        base = expanded[0...-3]
+        [base, *Dir.glob(File.join(base, "**", "*"))].select { |p| File.directory?(p) }
+      elsif expanded.end_with?("**")
+        base = expanded.sub(/\*\*\z/, "")
+        base = base.sub(%r{/+\z}, "")
+        [base, *Dir.glob(File.join(base, "**", "*"))].select { |p| File.directory?(p) }
+      elsif expanded.match?(/[*?\[]/)
+        Dir.glob(expanded).select { |p| File.directory?(p) }
+      else
+        [expanded]
+      end
+    rescue StandardError
+      [expanded || File.expand_path(dir, current_dir)]
+    end
+
     def ex_set_common(ctx, argv, scope:)
       editor = ctx.editor
       if argv.empty?