ruvim 0.3.0 → 0.6.0

data/lib/ruvim/git/status.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Git
+    module Status
+      module_function
+
+      # Run git status.
+      # Returns [lines, root, error_message].
+      def run(file_path)
+        root, err = Git.repo_root(file_path)
+        return [nil, nil, err] unless root
+
+        out, err, status = Open3.capture3("git", "status", chdir: root)
+        unless status.success?
+          return [nil, nil, err.strip]
+        end
+        [out.lines(chomp: true), root, nil]
+      end
+
+      # Extract filename from a git status output line.
+      # Returns relative path or nil.
+      def parse_filename(line)
+        stripped = line.to_s.strip
+        case stripped
+        when /\A(?:modified|new file|deleted|renamed|copied|typechange):\s+(.+)/
+          $1.strip
+        when /\A(\S.+)/
+          # Untracked file lines (no prefix keyword)
+          path = $1.strip
+          # Skip section headers and hints
+          return nil if path.start_with?("(")
+          return nil if path.match?(/\A[A-Z]/)
+          path
+        else
+          nil
+        end
+      end
+
+      # Command handler methods
+      module HandlerMethods
+        def git_status(ctx, **)
+          file_path = git_resolve_path(ctx)
+          unless file_path
+            ctx.editor.echo_error("No file or directory to resolve git repo")
+            return
+          end
+
+          lines, root, err = Status.run(file_path)
+          unless lines
+            ctx.editor.echo_error("git status: #{err}")
+            return
+          end
+
+          buf = ctx.editor.add_virtual_buffer(
+            kind: :git_status,
+            name: "[Git Status]",
+            lines: lines,
+            readonly: true,
+            modifiable: false
+          )
+          buf.options["git_repo_root"] = root
+          ctx.editor.switch_to_buffer(buf.id)
+          bind_git_buffer_keys(ctx.editor, buf.id)
+          ctx.editor.echo("[Git Status]")
+        end
+
+        def git_status_open_file(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :git_status
+            ctx.editor.echo_error("Not a git status buffer")
+            return
+          end
+
+          line = buf.line_at(ctx.window.cursor_y)
+          filename = Status.parse_filename(line)
+          unless filename
+            ctx.editor.echo_error("No file on this line")
+            return
+          end
+
+          root = buf.options["git_repo_root"]
+          full_path = File.join(root, filename)
+          unless File.exist?(full_path)
+            ctx.editor.echo_error("File not found: #{filename}")
+            return
+          end
+
+          existing = ctx.editor.buffers.values.find { |b| b.path == full_path }
+          if existing
+            ctx.editor.switch_to_buffer(existing.id)
+          else
+            new_buf = ctx.editor.add_buffer_from_file(full_path)
+            ctx.editor.switch_to_buffer(new_buf.id)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ruvim/global_commands.rb

@@ -366,7 +366,7 @@ module RuVim
         chunk = char_at_cursor_for_delete(ctx.buffer, ctx.window.cursor_y, ctx.window.cursor_x)
         ok = ctx.buffer.delete_char(ctx.window.cursor_y, ctx.window.cursor_x)
         break unless ok
-        deleted << chunk.to_s
+        deleted << chunk
       end
       ctx.buffer.end_change_group
       store_delete_register(ctx, text: deleted, type: :charwise) unless deleted.empty?
@@ -391,7 +391,7 @@ module RuVim
         break if x >= line.length
 
         ch = line[x]
-        swapped = ch.to_s.swapcase
+        swapped = ch.swapcase
         if !swapped.empty? && swapped != ch
           ctx.buffer.delete_span(y, x, y, x + 1)
           ctx.buffer.insert_char(y, x, swapped[0])
@@ -467,6 +467,8 @@ module RuVim
         when "k" then delete_lines_up(ctx, ncount)
         when "$" then delete_to_end_of_line(ctx)
         when "w" then delete_word_forward(ctx, ncount)
+        when "G" then delete_lines_to_end(ctx)
+        when "gg" then delete_lines_to_start(ctx)
         when "iw" then delete_text_object_word(ctx, around: false)
         when "aw" then delete_text_object_word(ctx, around: true)
         else
@@ -478,9 +480,22 @@ module RuVim
 
     def change_motion(ctx, count:, kwargs:, **)
       materialize_intro_buffer_if_needed(ctx)
-      handled = delete_motion(ctx, count:, kwargs:)
-      return unless handled
+      motion = (kwargs[:motion] || kwargs["motion"]).to_s
+      result = delete_motion(ctx, count:, kwargs:)
+      return unless result
 
+      if result == :linewise
+        case motion
+        when "G"
+          y = ctx.buffer.lines.length
+          ctx.buffer.insert_lines_at(y, [""])
+          ctx.window.cursor_y = y
+        when "gg"
+          ctx.buffer.insert_lines_at(0, [""])
+          ctx.window.cursor_y = 0
+        end
+        ctx.window.cursor_x = 0
+      end
       enter_insert_mode(ctx)
     end
 
@@ -610,6 +625,10 @@ module RuVim
         text = ctx.buffer.span_text(y, x, target[:row], target[:col])
         store_yank_register(ctx, text:, type: :charwise)
         ctx.editor.echo("yanked")
+      when "G"
+        yank_lines_to_end(ctx)
+      when "gg"
+        yank_lines_to_start(ctx)
       when "iw"
         yank_text_object_word(ctx, around: false)
       when "aw"
@@ -755,7 +774,18 @@ module RuVim
       ctx.editor.clear_message
     end
 
-    def file_write(ctx, argv:, bang:, **)
+    def file_write(ctx, argv:, bang:, kwargs: {}, **)
+      if ctx.buffer.kind == :git_commit
+        git_commit_execute(ctx)
+        return
+      end
+
+      arg = argv.join(" ")
+      if arg.start_with?("!")
+        file_write_to_shell(ctx, command: arg[1..].strip, kwargs: kwargs)
+        return
+      end
+
       path = argv[0]
       target = ctx.buffer.write_to(path)
       size = File.exist?(target) ? File.size(target) : 0
@@ -766,7 +796,41 @@ module RuVim
       end
     end
 
+    def file_write_to_shell(ctx, command:, kwargs: {})
+      raise RuVim::CommandError, "Usage: :w !<command>" if command.empty?
+
+      r_start = kwargs[:range_start] || 0
+      r_end = kwargs[:range_end] || (ctx.buffer.line_count - 1)
+      lines = (r_start..r_end).map { |i| ctx.buffer.lines[i] }
+      input = lines.join("\n") + "\n"
+
+      shell = ENV["SHELL"].to_s
+      shell = "/bin/sh" if shell.empty?
+      _stdout, stderr_text, status = Open3.capture3(shell, "-c", command, stdin_data: input)
+      unless stderr_text.empty?
+        ctx.editor.echo_error(stderr_text.lines(chomp: true).first)
+        return
+      end
+      ctx.editor.echo("#{lines.length} line(s) written to !#{command}, exit #{status.exitstatus}")
+    end
+
     def app_quit(ctx, bang:, **)
+      if ctx.buffer.kind == :filter
+        saved_y = ctx.buffer.options["filter_source_cursor_y"]
+        saved_x = ctx.buffer.options["filter_source_cursor_x"]
+        saved_row_offset = ctx.buffer.options["filter_source_row_offset"]
+        saved_col_offset = ctx.buffer.options["filter_source_col_offset"]
+        ctx.editor.delete_buffer(ctx.buffer.id)
+        if saved_y
+          win = ctx.editor.current_window
+          win.cursor_y = saved_y
+          win.cursor_x = saved_x || 0
+          win.row_offset = saved_row_offset || 0
+          win.col_offset = saved_col_offset || 0
+        end
+        return
+      end
+
       if ctx.editor.window_count > 1
         ctx.editor.close_current_window
         ctx.editor.echo("closed window")
@@ -1057,8 +1121,8 @@ module RuVim
           errf.flush
           outf.rewind
           errf.rewind
-          stdout_text = outf.read.to_s
-          stderr_text = errf.read.to_s
+          stdout_text = outf.read
+          stderr_text = errf.read
         end
       end
       if !stdout_text.empty? || !stderr_text.empty?
@@ -1094,44 +1158,155 @@ module RuVim
       $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?
+    def ex_run(ctx, argv:, **)
+      editor = ctx.editor
+      source_buffer = ctx.buffer
 
-      cmd = command.to_s
-      raise RuVim::CommandError, "Usage: :!<command>" if cmd.strip.empty?
+      if argv.empty?
+        # No args: use last command for this buffer, or runprg
+        command = editor.run_history[source_buffer.id]
+        if command.nil?
+          runprg = editor.get_option("runprg", buffer: source_buffer)
+          raise RuVim::CommandError, "No runprg set and no previous :run command" unless runprg
+          command = runprg
+        end
+      else
+        command = argv.first
+      end
 
-      shell = ENV["SHELL"].to_s
-      shell = "/bin/sh" if shell.empty?
-      stdout_text, stderr_text, status = Open3.capture3(shell, "-c", cmd)
+      # Auto-save modified buffer before running
+      if source_buffer.modified? && source_buffer.path
+        source_buffer.write_to
+      end
 
-      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")
+      expanded = expand_run_command(command, source_buffer)
+      editor.run_history[source_buffer.id] = command
+
+      # Find or create [Shell Output] buffer
+      output_buf = if editor.run_output_buffer_id
+                     editor.buffers[editor.run_output_buffer_id]
+                   end
+
+      if output_buf
+        # Reuse: clear content
+        output_buf.replace_all_lines!([""])
+      else
+        output_buf = editor.add_virtual_buffer(
+          kind: :run_output,
+          name: "[Shell Output]",
+          lines: [""],
+          readonly: true,
+          modifiable: false
+        )
+        editor.run_output_buffer_id = output_buf.id
+      end
+      # Open output buffer in a split (reuse existing window if present)
+      existing_win = editor.windows.values.find { |w| w.buffer_id == output_buf.id }
+      if existing_win
+        editor.current_window_id = existing_win.id
+      else
+        win = editor.split_current_window(layout: :horizontal, place: :after)
+        win.buffer_id = output_buf.id
+        win.cursor_x = 0
+        win.cursor_y = 0
+        win.row_offset = 0
+      end
+
+      # Start streaming (handler creates Stream::Run and sets buf.stream)
+      handler = editor.run_stream_handler
+      if handler
+        handler.call(output_buf, expanded)
       else
+        # Fallback for tests without stream handler: synchronous execution
+        shell = ENV["SHELL"].to_s
+        shell = "/bin/sh" if shell.empty?
+        output, _status = Open3.capture2e(shell, "-c", expanded)
+        output_buf.replace_all_lines!(output.lines(chomp: true))
+      end
+    end
+
+    def expand_run_command(command, buffer)
+      return command unless command.include?("%")
+
+      path = buffer.path
+      raise RuVim::CommandError, "No file name (use % in :run requires a file)" unless path
+
+      command.gsub("%", path)
+    end
+
+    def ex_shell(ctx, command:, **)
+      raise RuVim::CommandError, "Restricted mode: :! is disabled" if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+
+      raise RuVim::CommandError, "Usage: :!<command>" if command.strip.empty?
+
+      executor = ctx.editor.shell_executor
+      if executor
+        status = executor.call(command)
         ctx.editor.echo("shell exit #{status.exitstatus}")
+      else
+        shell = ENV["SHELL"].to_s
+        shell = "/bin/sh" if shell.empty?
+        stdout_text, stderr_text, status = Open3.capture3(shell, "-c", command)
+
+        if !stdout_text.empty? || !stderr_text.empty?
+          lines = ["Shell output", "", "[command]", command, ""]
+          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 << "[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
       end
     rescue Errno::ENOENT => e
       raise RuVim::CommandError, "Shell error: #{e.message}"
     end
 
+    def ex_read(ctx, argv:, kwargs:, **)
+      arg = argv.join(" ")
+      raise RuVim::CommandError, "Usage: :r[ead] [file] or :r[ead] !command" if arg.strip.empty?
+
+      insert_line = kwargs[:range_start] || ctx.window.cursor_y
+      new_lines = if arg.start_with?("!")
+                    command = arg[1..].strip
+                    raise RuVim::CommandError, "Usage: :r !<command>" if command.empty?
+
+                    shell = ENV["SHELL"].to_s
+                    shell = "/bin/sh" if shell.empty?
+                    stdout_text, stderr_text, _status = Open3.capture3(shell, "-c", command)
+                    unless stderr_text.empty?
+                      ctx.editor.echo_error(stderr_text.lines(chomp: true).first)
+                    end
+                    stdout_text.lines(chomp: true)
+                  else
+                    path = File.expand_path(arg.strip)
+                    raise RuVim::CommandError, "File not found: #{arg.strip}" unless File.exist?(path)
+
+                    File.read(path).lines(chomp: true)
+                  end
+
+      return if new_lines.empty?
+
+      ctx.buffer.insert_lines_at(insert_line + 1, new_lines)
+      ctx.window.cursor_y = insert_line + new_lines.length
+      ctx.editor.echo("#{new_lines.length} line(s) inserted")
+    end
+
     def ex_commands(ctx, **)
       rows = RuVim::ExCommandRegistry.instance.all.map do |spec|
         alias_text = spec.aliases.empty? ? "" : " (#{spec.aliases.join(', ')})"
         source = spec.source == :user ? " [user]" : ""
         name = "#{spec.name}#{alias_text}#{source}"
-        desc = spec.desc.to_s
+        desc = spec.desc
         keys = ex_command_binding_labels(ctx.editor, spec)
         [name, desc, keys]
       end
@@ -1336,6 +1511,69 @@ module RuVim
       RuVim::RichView.toggle!(ctx.editor)
     end
 
+    def rich_view_close_buffer(ctx, **)
+      ctx.editor.delete_buffer(ctx.buffer.id)
+    end
+
+    def search_filter(ctx, **)
+      editor = ctx.editor
+      search = editor.last_search
+      unless search
+        editor.echo_error("No search pattern")
+        return
+      end
+
+      regex = compile_search_regex(search[:pattern], editor: editor, window: ctx.window, buffer: ctx.buffer)
+      source_buffer = ctx.buffer
+
+      # Collect matching lines with origin mapping
+      origins = []
+      matching_lines = []
+      source_buffer.lines.each_with_index do |line, row|
+        if regex.match?(line)
+          # If source is a filter buffer, chain back to the original
+          if source_buffer.kind == :filter && source_buffer.options["filter_origins"]
+            origins << source_buffer.options["filter_origins"][row]
+          else
+            origins << { buffer_id: source_buffer.id, row: row }
+          end
+          matching_lines << line
+        end
+      end
+
+      if matching_lines.empty?
+        editor.echo_error("Pattern not found: #{search[:pattern]}")
+        return
+      end
+
+      filetype = source_buffer.options["filetype"]
+      filter_buf = editor.add_virtual_buffer(
+        kind: :filter,
+        name: "[Filter: /#{search[:pattern]}/]",
+        lines: matching_lines,
+        filetype: filetype,
+        readonly: false,
+        modifiable: false
+      )
+      filter_buf.options["filter_origins"] = origins
+      filter_buf.options["filter_source_buffer_id"] = source_buffer.id
+      filter_buf.options["filter_source_cursor_y"] = ctx.window.cursor_y
+      filter_buf.options["filter_source_cursor_x"] = ctx.window.cursor_x
+      filter_buf.options["filter_source_row_offset"] = ctx.window.row_offset
+      filter_buf.options["filter_source_col_offset"] = ctx.window.col_offset
+      editor.switch_to_buffer(filter_buf.id)
+      editor.echo("filter: #{matching_lines.length} line(s)")
+    end
+
+    def ex_filter(ctx, argv:, **)
+      if argv.any?
+        pattern = parse_vimgrep_pattern(argv.join(" "))
+        editor = ctx.editor
+        editor.set_last_search(pattern: pattern, direction: :forward)
+      end
+      search_filter(ctx)
+    end
+
     def submit_search(ctx, pattern:, direction:)
       text = pattern.to_s
       if text.empty?
@@ -1349,6 +1587,8 @@ module RuVim
       move_to_search(ctx, pattern: text, direction:, count: 1)
     end
 
+    include RuVim::Git::Handler
+
     private
 
     def reindent_range(ctx, start_row, end_row)
@@ -1392,13 +1632,18 @@ module RuVim
     end
 
     def run_external_grep(ctx, argv:, target:)
-      args = Array(argv).join(" ").strip
+      if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+        raise RuVim::CommandError, "Restricted mode: :grep is disabled"
+      end
+
+      args = Array(argv)
       raise RuVim::CommandError, "Usage: :grep pattern [files...]" if args.empty?
 
       grepprg = ctx.editor.effective_option("grepprg", window: ctx.window, buffer: ctx.buffer) || "grep -n"
-      cmd = "#{grepprg} #{args}"
+      cmd_parts = Shellwords.shellsplit(grepprg)
+      expanded_args = args.flat_map { |a| (g = Dir.glob(a)).empty? ? [a] : g }
 
-      stdout, stderr, status = Open3.capture3(cmd)
+      stdout, stderr, status = Open3.capture3(*cmd_parts, *expanded_args)
       if stdout.strip.empty? && !status.success?
         msg = stderr.strip.empty? ? "No matches found" : stderr.strip
         ctx.editor.echo_error(msg)
@@ -1723,6 +1968,48 @@ module RuVim
       true
     end
 
+    def delete_lines_to_end(ctx)
+      y = ctx.window.cursor_y
+      total = ctx.buffer.lines.length - y
+      deleted = ctx.buffer.line_block_text(y, total)
+      ctx.buffer.begin_change_group
+      total.times { ctx.buffer.delete_line(y) }
+      ctx.buffer.end_change_group
+      store_delete_register(ctx, text: deleted, type: :linewise)
+      ctx.window.clamp_to_buffer(ctx.buffer)
+      :linewise
+    end
+
+    def delete_lines_to_start(ctx)
+      y = ctx.window.cursor_y
+      total = y + 1
+      deleted = ctx.buffer.line_block_text(0, total)
+      ctx.buffer.begin_change_group
+      total.times { ctx.buffer.delete_line(0) }
+      ctx.buffer.end_change_group
+      store_delete_register(ctx, text: deleted, type: :linewise)
+      ctx.window.cursor_y = 0
+      ctx.window.cursor_x = 0
+      ctx.window.clamp_to_buffer(ctx.buffer)
+      :linewise
+    end
+
+    def yank_lines_to_end(ctx)
+      y = ctx.window.cursor_y
+      total = ctx.buffer.lines.length - y
+      text = ctx.buffer.line_block_text(y, total)
+      store_yank_register(ctx, text: text, type: :linewise)
+      ctx.editor.echo("#{total} line(s) yanked")
+    end
+
+    def yank_lines_to_start(ctx)
+      y = ctx.window.cursor_y
+      total = y + 1
+      text = ctx.buffer.line_block_text(0, total)
+      store_yank_register(ctx, text: text, type: :linewise)
+      ctx.editor.echo("#{total} line(s) yanked")
+    end
+
     def delete_to_end_of_line(ctx)
       y = ctx.window.cursor_y
       x = ctx.window.cursor_x
@@ -1754,22 +2041,22 @@ module RuVim
     end
 
     def delete_text_object_word(ctx, around:)
-      span = word_object_span(ctx.buffer, ctx.window, around:)
-      return false unless span
-
-      text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
-      ctx.buffer.begin_change_group
-      ctx.buffer.delete_span(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
-      ctx.buffer.end_change_group
-      store_delete_register(ctx, text:, type: :charwise) unless text.empty?
-      ctx.window.cursor_y = span[:start_row]
-      ctx.window.cursor_x = span[:start_col]
-      ctx.window.clamp_to_buffer(ctx.buffer)
-      true
+      delete_span(ctx, word_object_span(ctx.buffer, ctx.window, around:))
     end
 
     def delete_text_object(ctx, motion)
-      span = text_object_span(ctx.buffer, ctx.window, motion)
+      delete_span(ctx, text_object_span(ctx.buffer, ctx.window, motion))
+    end
+
+    def yank_text_object_word(ctx, around:)
+      yank_span(ctx, word_object_span(ctx.buffer, ctx.window, around:))
+    end
+
+    def yank_text_object(ctx, motion)
+      yank_span(ctx, text_object_span(ctx.buffer, ctx.window, motion))
+    end
+
+    def delete_span(ctx, span)
       return false unless span
 
       text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
@@ -1783,18 +2070,7 @@ module RuVim
       true
     end
 
-    def yank_text_object_word(ctx, around:)
-      span = word_object_span(ctx.buffer, ctx.window, around:)
-      return false unless span
-
-      text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
-      store_yank_register(ctx, text:, type: :charwise) unless text.empty?
-      ctx.editor.echo("yanked")
-      true
-    end
-
-    def yank_text_object(ctx, motion)
-      span = text_object_span(ctx.buffer, ctx.window, motion)
+    def yank_span(ctx, span)
       return false unless span
 
       text = ctx.buffer.span_text(span[:start_row], span[:start_col], span[:end_row], span[:end_col])
@@ -1979,9 +2255,9 @@ module RuVim
       x = [window.cursor_x, line.length - 1].min
       return nil if x.negative?
 
-      left = find_left_quote(line, x, quote)
+      left = find_quote(line, x, quote, :left)
       right_from = [x, (left ? left + 1 : 0)].max
-      right = find_right_quote(line, right_from, quote)
+      right = find_quote(line, right_from, quote, :right)
       return nil unless left && right && left < right
 
       if around
@@ -2053,20 +2329,18 @@ module RuVim
       end
     end
 
-    def find_left_quote(line, x, quote)
+    def find_quote(line, x, quote, direction)
       i = x
-      while i >= 0
-        return i if line[i] == quote && !escaped?(line, i)
-        i -= 1
-      end
-      nil
-    end
-
-    def find_right_quote(line, x, quote)
-      i = x
-      while i < line.length
-        return i if line[i] == quote && !escaped?(line, i)
-        i += 1
+      if direction == :left
+        while i >= 0
+          return i if line[i] == quote && !escaped?(line, i)
+          i -= 1
+        end
+      else
+        while i < line.length
+          return i if line[i] == quote && !escaped?(line, i)
+          i += 1
+        end
       end
       nil
     end
@@ -2811,7 +3085,7 @@ module RuVim
         operator_pending: 5,
         command_line: 6
       }
-      order.fetch(mode.to_sym, 99)
+      order.fetch(mode, 99)
     end
 
     def sort_binding_entries(entries, sort:)
@@ -2894,7 +3168,7 @@ module RuVim
       lhs = format_binding_tokens(entry.tokens)
       if entry.scope == :global
         "global:#{lhs}"
-      elsif entry.mode && entry.mode.to_sym != :normal
+      elsif entry.mode && entry.mode != :normal
         "#{entry.mode}:#{lhs}"
       else
         lhs
@@ -2929,7 +3203,7 @@ module RuVim
     end
 
     def invert_direction(direction)
-      direction.to_sym == :forward ? :backward : :forward
+      direction == :forward ? :backward : :forward
     end
 
     def move_to_search(ctx, pattern:, direction:, count:)
@@ -2950,7 +3224,7 @@ module RuVim
     def find_next_match(buffer, window, regex, direction:)
       return nil unless regex
 
-      if direction.to_sym == :backward
+      if direction == :backward
         find_backward_match(buffer, window, regex)
       else
         find_forward_match(buffer, window, regex)