ruvim 0.2.0 → 0.4.0

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/handler.rb

@@ -0,0 +1,84 @@
+# 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,
+        "commit"      => :git_commit,
+      }.freeze
+
+      include Blame::HandlerMethods
+      include Status::HandlerMethods
+      include Diff::HandlerMethods
+      include Log::HandlerMethods
+      include Branch::HandlerMethods
+      include Commit::HandlerMethods
+
+      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: [], **)
+        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
+          ctx.editor.echo_error("Unknown Git subcommand: #{sub}")
+          return
+        end
+
+        public_send(method, ctx, argv: argv[1..], 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 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

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