ruvim 0.3.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

data/lib/ruvim/global_commands.rb

@@ -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"
@@ -756,6 +775,11 @@ module RuVim
     end
 
     def file_write(ctx, argv:, bang:, **)
+      if ctx.buffer.kind == :git_commit
+        git_commit_execute(ctx)
+        return
+      end
+
       path = argv[0]
       target = ctx.buffer.write_to(path)
       size = File.exist?(target) ? File.size(target) : 0
@@ -767,6 +791,22 @@ module RuVim
     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")
@@ -1336,6 +1376,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 +1452,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)
@@ -1723,6 +1828,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 +1901,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 +1930,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 +2115,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 +2189,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

data/lib/ruvim/highlighter.rb

@@ -19,12 +19,14 @@ module RuVim
       case ft
       when "ruby"
         Lang::Ruby.color_columns(text)
-      when "json"
+      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)
       else
         {}
       end

data/lib/ruvim/input.rb

@@ -23,6 +23,7 @@ module RuVim
       when "\u0004" then :ctrl_d
       when "\u0005" then :ctrl_e
       when "\u0006" then :ctrl_f
+      when "\u0007" then :ctrl_g
       when "\u0009" then :ctrl_i
       when "\u000c" then :ctrl_l
       when "\u000e" then :ctrl_n