ruvim 0.4.0 → 0.6.0

data/lib/ruvim/gh/link.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Gh
+    module Link
+      module_function
+
+      # Parse a git remote URL and return the GitHub HTTPS base URL.
+      # Returns nil if the remote is not a GitHub URL.
+      def github_url_from_remote(remote_url)
+        url = remote_url.to_s.strip
+        return nil if url.empty?
+
+        case url
+        when %r{\Agit@github\.com:(.+?)(?:\.git)?\z}
+          "https://github.com/#{$1}"
+        when %r{\Ahttps://github\.com/(.+?)(?:\.git)?\z}
+          "https://github.com/#{$1}"
+        end
+      end
+
+      # Build a GitHub blob URL.
+      def build_url(base_url, ref, relative_path, line_start, line_end = nil)
+        fragment = if line_end && line_end != line_start
+                     "#L#{line_start}-L#{line_end}"
+                   else
+                     "#L#{line_start}"
+                   end
+        "#{base_url}/blob/#{ref}/#{relative_path}#{fragment}"
+      end
+
+      # Generate OSC 52 escape sequence for clipboard copy.
+      def osc52_copy_sequence(text)
+        encoded = [text].pack("m0")
+        "\e]52;c;#{encoded}\a"
+      end
+
+      # Find a GitHub remote. If remote_name is given, use that specific remote.
+      # Otherwise, scan all remotes (preferring "origin", then "upstream", then others).
+      # Returns [remote_name, base_url] or [nil, nil].
+      def find_github_remote(root, remote_name = nil)
+        if remote_name
+          url, _, status = Open3.capture3("git", "remote", "get-url", remote_name, chdir: root)
+          return [nil, nil] unless status.success?
+
+          base = github_url_from_remote(url.strip)
+          return base ? [remote_name, base] : [nil, nil]
+        end
+
+        remotes_out, _, status = Open3.capture3("git", "remote", chdir: root)
+        return [nil, nil] unless status.success?
+
+        remotes = remotes_out.lines(chomp: true)
+        # Prefer origin, then upstream, then others
+        ordered = []
+        ordered << "origin" if remotes.include?("origin")
+        ordered << "upstream" if remotes.include?("upstream")
+        remotes.each { |r| ordered << r unless ordered.include?(r) }
+
+        ordered.each do |name|
+          url, _, st = Open3.capture3("git", "remote", "get-url", name, chdir: root)
+          next unless st.success?
+
+          base = github_url_from_remote(url.strip)
+          return [name, base] if base
+        end
+
+        [nil, nil]
+      end
+
+      # Check if a file differs from the remote tracking branch.
+      def file_differs_from_remote?(root, remote_name, branch, file_path)
+        remote_ref = "#{remote_name}/#{branch}"
+        diff_out, _, status = Open3.capture3("git", "diff", remote_ref, "--", file_path, chdir: root)
+        # If the remote ref doesn't exist or diff fails, consider it as differing
+        return true unless status.success?
+
+        !diff_out.empty?
+      end
+
+      # Resolve GitHub link for a file path at given line(s).
+      # Returns [url, warning, error_message].
+      def resolve(file_path, line_start, line_end = nil, remote_name: nil)
+        root, err = RuVim::Git.repo_root(file_path)
+        return [nil, nil, err] unless root
+
+        found_remote, base_url = find_github_remote(root, remote_name)
+        unless base_url
+          msg = remote_name ? "Remote '#{remote_name}' is not a GitHub remote" : "No GitHub remote found"
+          return [nil, nil, msg]
+        end
+
+        branch, _, status = Open3.capture3("git", "rev-parse", "--abbrev-ref", "HEAD", chdir: root)
+        unless status.success?
+          return [nil, nil, "Cannot determine branch"]
+        end
+        branch = branch.strip
+
+        relative_path = file_path.sub(%r{\A#{Regexp.escape(root)}/?}, "")
+        url = build_url(base_url, branch, relative_path, line_start, line_end)
+
+        warning = nil
+        if file_differs_from_remote?(root, found_remote, branch, file_path)
+          warning = "(remote may differ)"
+        end
+
+        [url, warning, nil]
+      end
+
+      # Build a GitHub PR search URL for a branch.
+      def pr_search_url(base_url, branch)
+        "#{base_url}/pulls?q=head:#{branch}"
+      end
+
+      # Resolve GitHub PR URL for the current repo.
+      # Returns [url, error_message].
+      def resolve_pr(file_path)
+        root, err = RuVim::Git.repo_root(file_path)
+        return [nil, err] unless root
+
+        _, base_url = find_github_remote(root)
+        return [nil, "No GitHub remote found"] unless base_url
+
+        branch, _, status = Open3.capture3("git", "rev-parse", "--abbrev-ref", "HEAD", chdir: root)
+        return [nil, "Cannot determine branch"] unless status.success?
+
+        [pr_search_url(base_url, branch.strip), nil]
+      end
+
+      module HandlerMethods
+        def gh_link(ctx, argv: [], kwargs: {}, **)
+          url, warning = gh_resolve_url(ctx, argv: argv, kwargs: kwargs, command: "gh link")
+          return unless url
+
+          # Copy to clipboard via OSC 52
+          $stdout.write(Link.osc52_copy_sequence(url))
+          $stdout.flush
+
+          msg = warning ? "#{url} #{warning}" : url
+          ctx.editor.echo(msg)
+        end
+
+        def gh_browse(ctx, argv: [], kwargs: {}, **)
+          url, warning = gh_resolve_url(ctx, argv: argv, kwargs: kwargs, command: "gh browse")
+          return unless url
+
+          unless Browser.open_url(url)
+            ctx.editor.echo_error("gh browse: could not open browser")
+            return
+          end
+
+          msg = warning ? "Opened #{url} #{warning}" : "Opened #{url}"
+          ctx.editor.echo(msg)
+        end
+
+        def gh_pr(ctx, **)
+          path = ctx.buffer.path || Dir.pwd
+          url, err = Link.resolve_pr(path)
+          unless url
+            ctx.editor.echo_error("gh pr: #{err}")
+            return
+          end
+
+          unless Browser.open_url(url)
+            ctx.editor.echo_error("gh pr: could not open browser")
+            return
+          end
+
+          ctx.editor.echo("Opened #{url}")
+        end
+
+        private
+
+        def gh_resolve_url(ctx, argv:, kwargs:, command:)
+          path = ctx.buffer.path
+          unless path && File.exist?(path)
+            ctx.editor.echo_error("Buffer has no file path")
+            return nil
+          end
+
+          line_start = kwargs[:range_start]
+          line_end = kwargs[:range_end]
+
+          if line_start
+            line_start += 1
+            line_end += 1 if line_end
+          else
+            line_start = ctx.window.cursor_y + 1
+            line_end = nil
+          end
+
+          remote_name = argv.first
+
+          url, warning, err = Link.resolve(path, line_start, line_end, remote_name: remote_name)
+          unless url
+            ctx.editor.echo_error("#{command}: #{err}")
+            return nil
+          end
+
+          [url, warning]
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/git/blame.rb

@@ -47,15 +47,20 @@ module RuVim
         entries
       end
 
-      # Format entries into display lines for the blame buffer.
+      # Format entries into code lines and gutter labels.
+      # Returns [lines, labels] where lines are code-only and labels are metadata strings.
       def format_lines(entries)
         max_author = entries.map { |e| e[:author].to_s.length }.max || 0
         max_author = [max_author, 20].min
 
-        entries.map do |e|
+        lines = []
+        labels = []
+        entries.each do |e|
           author = (e[:author] || "").ljust(max_author)[0, max_author]
-          "#{e[:short_hash]} #{author} #{e[:date]} #{e[:text]}"
+          labels << "#{e[:short_hash]} #{author} #{e[:date]} "
+          lines << e[:text].to_s
         end
+        [lines, labels]
       end
 
       # Run git blame for a file at a given revision.
@@ -106,19 +111,22 @@ module RuVim
             return
           end
 
-          lines = Blame.format_lines(entries)
+          lines, labels = Blame.format_lines(entries)
           cursor_y = ctx.window.cursor_y
+          source_ft = source_buf.options["filetype"]
 
           blame_buf = ctx.editor.add_virtual_buffer(
             kind: :blame,
             name: "[Blame] #{File.basename(source_buf.path)}",
             lines: lines,
+            filetype: source_ft,
             readonly: true,
             modifiable: false
           )
           blame_buf.options["blame_entries"] = entries
           blame_buf.options["blame_source_path"] = source_buf.path
           blame_buf.options["blame_history"] = []
+          blame_buf.options["gutter_labels"] = labels
 
           ctx.editor.switch_to_buffer(blame_buf.id)
           ctx.window.cursor_y = [cursor_y, lines.length - 1].min
@@ -160,9 +168,10 @@ module RuVim
 
           history.push({ entries: entries, cursor_y: cursor_y })
 
-          new_lines = Blame.format_lines(new_entries)
+          new_lines, new_labels = Blame.format_lines(new_entries)
           buf.instance_variable_set(:@lines, new_lines)
           buf.options["blame_entries"] = new_entries
+          buf.options["gutter_labels"] = new_labels
           ctx.window.cursor_y = [cursor_y, new_lines.length - 1].min
           ctx.window.cursor_x = 0
           ctx.editor.echo("[Blame] #{commit_hash[0, 8]}^")
@@ -182,9 +191,10 @@ module RuVim
           end
 
           state = history.pop
-          lines = Blame.format_lines(state[:entries])
+          lines, labels = Blame.format_lines(state[:entries])
           buf.instance_variable_set(:@lines, lines)
           buf.options["blame_entries"] = state[:entries]
+          buf.options["gutter_labels"] = labels
           ctx.window.cursor_y = [state[:cursor_y], lines.length - 1].min
           ctx.window.cursor_x = 0
           ctx.editor.echo("[Blame] restored")

data/lib/ruvim/git/branch.rb

@@ -80,15 +80,30 @@ module RuVim
             return
           end
 
-          root = buf.options["git_repo_root"]
+          ctx.editor.enter_command_line_mode(":")
+          ctx.editor.command_line.replace_text("git checkout #{branch}")
+        end
+
+        def git_branch_execute_checkout(ctx, argv: [], **)
+          branch = argv.first.to_s.strip
+          raise RuVim::CommandError, "Usage: :git checkout <branch>" if branch.empty?
+
+          root = ctx.buffer.kind == :git_branch ? ctx.buffer.options["git_repo_root"] : nil
+          unless root
+            file_path = git_resolve_path(ctx)
+            root, err = Git.repo_root(file_path) if file_path
+            raise RuVim::CommandError, "Not in a git repository" unless root
+          end
+
           _out, err, status = Open3.capture3("git", "checkout", branch, chdir: root)
           unless status.success?
-            ctx.editor.echo_error("git checkout: #{err.strip}")
-            return
+            raise RuVim::CommandError, "git checkout: #{err.strip}"
           end
 
-          # Refresh the branch list
-          ctx.editor.delete_buffer(buf.id)
+          # Close git branch buffer if we're in one
+          if ctx.buffer.kind == :git_branch
+            ctx.editor.delete_buffer(ctx.buffer.id)
+          end
           ctx.editor.echo("Switched to branch '#{branch}'")
         end
       end

data/lib/ruvim/git/grep.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Git
+    module Grep
+      module_function
+
+      # Run git grep -n with extra args.
+      # Returns [lines, root, error_message].
+      def run(file_path, args: [])
+        root, err = Git.repo_root(file_path)
+        return [nil, nil, err] unless root
+
+        cmd = ["git", "grep", "-n", *args]
+        out, err, status = Open3.capture3(*cmd, chdir: root)
+        # git grep exits 1 when no matches found (not an error)
+        unless status.success? || status.exitstatus == 1
+          return [nil, nil, err.strip]
+        end
+        [out.lines(chomp: true), root, nil]
+      end
+
+      # Parse a git grep output line (file:line:content).
+      # Returns [filename, line_number] or nil.
+      def parse_location(line)
+        return nil if line.empty? || line == "--"
+
+        m = line.match(/\A(.+?):(\d+):/)
+        return nil unless m
+
+        [m[1], m[2].to_i]
+      end
+
+      module HandlerMethods
+        def git_grep(ctx, argv: [], **)
+          if argv.empty?
+            ctx.editor.echo_error("Usage: :git grep <pattern> [<args>...]")
+            return
+          end
+
+          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 = Grep.run(file_path, args: argv)
+          unless lines
+            ctx.editor.echo_error("git grep: #{err}")
+            return
+          end
+
+          if lines.empty?
+            ctx.editor.echo("No matches found")
+            return
+          end
+
+          buf = ctx.editor.add_virtual_buffer(
+            kind: :git_grep,
+            name: "[Git Grep]",
+            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 Grep] #{lines.length} match(es)")
+        end
+
+        def git_grep_open_file(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :git_grep
+            ctx.editor.echo_error("Not a git grep buffer")
+            return
+          end
+
+          line = buf.lines[ctx.window.cursor_y]
+          location = Grep.parse_location(line)
+          unless location
+            ctx.editor.echo_error("No file on this line")
+            return
+          end
+
+          filename, line_num = location
+          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
+          ctx.editor.current_window.cursor_y = [line_num - 1, 0].max
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/git/handler.rb

@@ -27,7 +27,9 @@ module RuVim
         "diff"        => :git_diff,
         "log"         => :git_log,
         "branch"      => :git_branch,
+        "checkout"    => :git_branch_execute_checkout,
         "commit"      => :git_commit,
+        "grep"        => :git_grep,
       }.freeze
 
       include Blame::HandlerMethods
@@ -36,6 +38,14 @@ module RuVim
       include Log::HandlerMethods
       include Branch::HandlerMethods
       include Commit::HandlerMethods
+      include Grep::HandlerMethods
+      include Gh::Link::HandlerMethods
+
+      GH_SUBCOMMANDS = {
+        "link"   => :gh_link,
+        "browse" => :gh_browse,
+        "pr"     => :gh_pr,
+      }.freeze
 
       def enter_git_command_mode(ctx, **)
         ctx.editor.enter_command_line_mode(":")
@@ -44,6 +54,8 @@ module RuVim
       end
 
       def ex_git(ctx, argv: [], **)
+        raise RuVim::CommandError, "Restricted mode: :git is disabled" if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+
         sub = argv.first.to_s.downcase
         if sub.empty?
           ctx.editor.echo("Git subcommands: #{GIT_SUBCOMMANDS.keys.join(', ')}")
@@ -52,13 +64,31 @@ module RuVim
 
         method = GIT_SUBCOMMANDS[sub]
         unless method
-          ctx.editor.echo_error("Unknown Git subcommand: #{sub}")
+          run_shell_fallback(ctx, "git", argv)
           return
         end
 
         public_send(method, ctx, argv: argv[1..], kwargs: {}, bang: false, count: 1)
       end
 
+      def ex_gh(ctx, argv: [], kwargs: {}, **)
+        raise RuVim::CommandError, "Restricted mode: :gh is disabled" if ctx.editor.respond_to?(:restricted_mode?) && ctx.editor.restricted_mode?
+
+        sub = argv.first.to_s.downcase
+        if sub.empty?
+          ctx.editor.echo("GitHub subcommands: #{GH_SUBCOMMANDS.keys.join(', ')}")
+          return
+        end
+
+        method = GH_SUBCOMMANDS[sub]
+        unless method
+          run_shell_fallback(ctx, "gh", argv)
+          return
+        end
+
+        public_send(method, ctx, argv: argv[1..], kwargs: kwargs, bang: false, count: 1)
+      end
+
       def git_close_buffer(ctx, **)
         buf_id = ctx.buffer.id
         ctx.editor.git_stream_stop_handler&.call(buf_id)
@@ -67,6 +97,17 @@ module RuVim
 
       private
 
+      def run_shell_fallback(ctx, cmd, argv)
+        command = ([cmd] + argv).join(" ")
+        executor = ctx.editor.shell_executor
+        if executor
+          status = executor.call(command)
+          ctx.editor.echo("shell exit #{status.exitstatus}")
+        else
+          ctx.editor.echo_error("Unknown #{cmd} subcommand: #{argv.first}")
+        end
+      end
+
       def git_resolve_path(ctx)
         path = ctx.buffer.path
         return path if path && File.exist?(path)