ruvim 0.4.0 → 0.6.0

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])
@@ -774,12 +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
@@ -790,6 +796,24 @@ 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"]
@@ -1097,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?
@@ -1134,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
@@ -1497,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)
@@ -2945,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:)
@@ -3028,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
@@ -3063,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:)
@@ -3084,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)

data/lib/ruvim/highlighter.rb

@@ -13,20 +13,11 @@ module RuVim
 
     def color_columns(filetype, line)
       ft = filetype.to_s
-      text = line.to_s
-      return {} if text.empty?
+      return {} if line.empty?
 
-      case ft
-      when "ruby"
-        Lang::Ruby.color_columns(text)
-      when "json", "jsonl"
-        Lang::Json.color_columns(text)
-      when "markdown"
-        Lang::Markdown.color_columns(text)
-      when "scheme"
-        Lang::Scheme.color_columns(text)
-      when "diff"
-        Lang::Diff.color_columns(text)
+      entry = Lang::Registry[ft]
+      if entry && entry[:mod].respond_to?(:color_columns)
+        entry[:mod].color_columns(line)
       else
         {}
       end