ruvim 0.3.0 → 0.6.0

data/lib/ruvim/git/branch.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Git
+    module Branch
+      module_function
+
+      # Run git branch listing sorted by most recent commit.
+      # 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", "branch", "-a",
+          "--sort=-committerdate",
+          "--format=%(if)%(HEAD)%(then)* %(else)  %(end)%(refname:short)\t%(committerdate:short)\t%(subject)",
+          chdir: root
+        )
+        unless status.success?
+          return [nil, nil, err.strip]
+        end
+        [out.lines(chomp: true), root, nil]
+      end
+
+      # Parse branch name from a branch list line.
+      # Returns branch name or nil.
+      def parse_branch_name(line)
+        stripped = line.to_s.strip
+        return nil if stripped.empty?
+
+        # Remove leading "* " marker for current branch
+        name = stripped.sub(/\A\*\s*/, "")
+        # Branch name is everything before the first tab
+        name = name.split("\t", 2).first
+        name&.strip
+      end
+
+      # Command handler methods
+      module HandlerMethods
+        def git_branch(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 = Branch.run(file_path)
+          unless lines
+            ctx.editor.echo_error("git branch: #{err}")
+            return
+          end
+
+          buf = ctx.editor.add_virtual_buffer(
+            kind: :git_branch,
+            name: "[Git Branch]",
+            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 Branch]")
+        end
+
+        def git_branch_checkout(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :git_branch
+            ctx.editor.echo_error("Not a git branch buffer")
+            return
+          end
+
+          line = buf.line_at(ctx.window.cursor_y)
+          branch = Branch.parse_branch_name(line)
+          unless branch
+            ctx.editor.echo_error("No branch on this line")
+            return
+          end
+
+          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?
+            raise RuVim::CommandError, "git checkout: #{err.strip}"
+          end
+
+          # 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
+    end
+  end
+end

data/lib/ruvim/git/commit.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Git
+    module Commit
+      module_function
+
+      # Build the initial content for the commit message buffer.
+      # Returns [lines, root, error_message].
+      def prepare(file_path)
+        root, err = Git.repo_root(file_path)
+        return [nil, nil, err] unless root
+
+        status_out, err, status = Open3.capture3("git", "status", chdir: root)
+        unless status.success?
+          return [nil, nil, err.strip]
+        end
+
+        lines = [""]
+        lines << "# Enter commit message above. Lines starting with '#' are ignored."
+        lines << "# Close with :wq to commit, :q! to cancel."
+        lines << "#"
+        status_out.each_line(chomp: true) { |l| lines << "# #{l}" }
+        [lines, root, nil]
+      end
+
+      # Extract commit message from buffer lines (skip # comment lines and trim).
+      def extract_message(lines)
+        msg_lines = lines.reject { |l| l.start_with?("#") }
+        # Strip trailing blank lines
+        msg_lines.pop while msg_lines.last&.empty?
+        msg_lines.join("\n")
+      end
+
+      # Execute git commit with the given message.
+      # Returns [success, output_or_error].
+      def execute(root, message)
+        out, err, status = Open3.capture3("git", "commit", "-m", message, chdir: root)
+        if status.success?
+          [true, out.strip]
+        else
+          [false, err.strip]
+        end
+      end
+
+      # Command handler methods
+      module HandlerMethods
+        def git_commit(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 = Commit.prepare(file_path)
+          unless lines
+            ctx.editor.echo_error("git commit: #{err}")
+            return
+          end
+
+          buf = ctx.editor.add_virtual_buffer(
+            kind: :git_commit,
+            name: "[Commit Message]",
+            lines: lines,
+            readonly: false,
+            modifiable: true
+          )
+          buf.options["git_repo_root"] = root
+          ctx.editor.switch_to_buffer(buf.id)
+          ctx.editor.enter_insert_mode
+          ctx.editor.echo("[Commit Message] :wq to commit, :q! to cancel")
+        end
+
+        def git_commit_execute(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :git_commit
+            ctx.editor.echo_error("Not a git commit buffer")
+            return
+          end
+
+          message = Commit.extract_message(buf.lines)
+          if message.empty?
+            ctx.editor.echo_error("Empty commit message, aborting")
+            return
+          end
+
+          root = buf.options["git_repo_root"]
+          success, output = Commit.execute(root, message)
+          ctx.editor.delete_buffer(buf.id)
+
+          if success
+            ctx.editor.echo(output)
+          else
+            ctx.editor.echo_error("git commit: #{output}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/git/diff.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Git
+    module Diff
+      module_function
+
+      # Run git diff with optional 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", "diff", *args]
+        out, err, status = Open3.capture3(*cmd, chdir: root)
+        unless status.success?
+          return [nil, nil, err.strip]
+        end
+        [out.lines(chomp: true), root, nil]
+      end
+
+      # Parse diff output to find file and line number at cursor_y.
+      # Returns [filename, line_number] or nil.
+      def parse_location(lines, cursor_y)
+        return nil if lines.empty? || cursor_y < 0 || cursor_y >= lines.length
+
+        current_file = nil
+        new_line = nil
+
+        (0..cursor_y).each do |i|
+          l = lines[i]
+          case l
+          when /\Adiff --git a\/.+ b\/(.+)/
+            current_file = $1
+          when /\A\+\+\+ b\/(.+)/
+            current_file = $1
+          when /\A@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/
+            new_line = $1.to_i
+          when /\A[ +]/
+            # Context or added line: current new_line is this line's number
+            new_line += 1 if new_line && i < cursor_y
+          end
+          # Deleted lines ("-") don't advance new_line
+        end
+
+        return nil unless current_file
+
+        l = lines[cursor_y]
+        case l
+        when /\A@@ /
+          # On hunk header: new_line already set
+        when /\Adiff --git /, /\A---/, /\A\+\+\+/, /\Aindex /
+          new_line ||= 1
+        when /\A-/
+          # Deleted line: point to current new-side position
+        end
+
+        [current_file, new_line || 1]
+      end
+
+      # Command handler methods
+      module HandlerMethods
+        def git_diff(ctx, argv: [], **)
+          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 = Diff.run(file_path, args: argv)
+          unless lines
+            ctx.editor.echo_error("git diff: #{err}")
+            return
+          end
+
+          if lines.empty?
+            ctx.editor.echo("No diff output (working tree clean)")
+            return
+          end
+
+          buf = ctx.editor.add_virtual_buffer(
+            kind: :git_diff,
+            name: "[Git Diff]",
+            lines: lines,
+            filetype: "diff",
+            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 Diff]")
+        end
+
+        def git_diff_open_file(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :git_diff || buf.kind == :git_log
+            ctx.editor.echo_error("Not a git diff buffer")
+            return
+          end
+
+          filename, line_num = Diff.parse_location(buf.lines, ctx.window.cursor_y)
+          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
+          ctx.editor.current_window.cursor_y = [line_num - 1, 0].max
+        end
+      end
+    end
+  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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Git
+    module_function
+
+    # Find git repository root from a file path.
+    # Returns [root_path, error_message].
+    def repo_root(file_path)
+      dir = File.directory?(file_path) ? file_path : File.dirname(file_path)
+      out, err, status = Open3.capture3("git", "rev-parse", "--show-toplevel", chdir: dir)
+      unless status.success?
+        return [nil, err.strip]
+      end
+      [out.strip, nil]
+    end
+
+    module Handler
+      GIT_SUBCOMMANDS = {
+        "blame"       => :git_blame,
+        "blameprev"   => :git_blame_prev,
+        "blameback"   => :git_blame_back,
+        "blamecommit" => :git_blame_commit,
+        "status"      => :git_status,
+        "diff"        => :git_diff,
+        "log"         => :git_log,
+        "branch"      => :git_branch,
+        "checkout"    => :git_branch_execute_checkout,
+        "commit"      => :git_commit,
+        "grep"        => :git_grep,
+      }.freeze
+
+      include Blame::HandlerMethods
+      include Status::HandlerMethods
+      include Diff::HandlerMethods
+      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(":")
+        ctx.editor.command_line.replace_text("git ")
+        ctx.editor.clear_message
+      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(', ')}")
+          return
+        end
+
+        method = GIT_SUBCOMMANDS[sub]
+        unless method
+          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)
+        ctx.editor.delete_buffer(buf_id)
+      end
+
+      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)
+        dir = Dir.pwd
+        File.directory?(dir) ? dir : nil
+      end
+
+      def bind_git_buffer_keys(editor, buffer_id)
+        km = editor.keymap_manager
+        km.bind_buffer(buffer_id, "\e", "git.close_buffer")
+        km.bind_buffer(buffer_id, "<C-c>", "git.close_buffer")
+      end
+    end
+  end
+end

data/lib/ruvim/git/log.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Git
+    module Log
+      # Command handler methods
+      module HandlerMethods
+        def git_log(ctx, argv: [], **)
+          file_path = git_resolve_path(ctx)
+          unless file_path
+            ctx.editor.echo_error("No file or directory to resolve git repo")
+            return
+          end
+
+          root, err = Git.repo_root(file_path)
+          unless root
+            ctx.editor.echo_error("git log: #{err}")
+            return
+          end
+
+          filetype = argv.include?("-p") ? "diff" : nil
+          buf = ctx.editor.add_virtual_buffer(
+            kind: :git_log,
+            name: "[Git Log]",
+            lines: [""],
+            filetype: filetype,
+            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 Log] loading...")
+
+          cmd = ["git", "log", *argv]
+          ctx.editor.git_stream_handler&.call(buf.id, cmd, root)
+        end
+      end
+    end
+  end
+end