ruvim 0.3.0 → 0.4.0

data/lib/ruvim/lang/diff.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuVim
+  module Lang
+    module Diff
+      ADD_COLOR    = "\e[32m"  # green
+      DELETE_COLOR = "\e[31m"  # red
+      HUNK_COLOR   = "\e[36m"  # cyan
+      HEADER_COLOR = "\e[1m"   # bold
+      META_COLOR   = "\e[33m"  # yellow
+
+      module_function
+
+      def color_columns(text)
+        cols = {}
+        color = line_color(text)
+        return cols unless color
+
+        text.length.times { |i| cols[i] = color }
+        cols
+      end
+
+      def line_color(text)
+        return nil if text.empty?
+
+        case text
+        when /\A@@/
+          HUNK_COLOR
+        when /\Adiff /
+          HEADER_COLOR
+        when /\A\+/
+          ADD_COLOR
+        when /\A-/
+          DELETE_COLOR
+        when /\Aindex /, /\Anew file/, /\Adeleted file/, /\Arename/, /\Asimilarity/
+          META_COLOR
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/lang/json.rb

@@ -5,6 +5,40 @@ module RuVim
     module Json
       module_function
 
+      INDENT_OPEN_RE = /[\[{]\s*$/
+      INDENT_CLOSE_RE = /\A\s*[\]}]/
+
+      DEDENT_TRIGGERS = {
+        "}" => /\A(\s*)\}/,
+        "]" => /\A(\s*)\]/
+      }.freeze
+
+      def calculate_indent(lines, target_row, shiftwidth)
+        depth = 0
+        (0...target_row).each do |row|
+          line = lines[row].to_s
+          line.each_char do |ch|
+            case ch
+            when "{", "[" then depth += 1
+            when "}", "]" then depth -= 1
+            end
+          end
+        end
+
+        target_line = lines[target_row].to_s.lstrip
+        depth -= 1 if target_line.match?(INDENT_CLOSE_RE)
+        depth = 0 if depth < 0
+        depth * shiftwidth
+      end
+
+      def indent_trigger?(line)
+        line.to_s.rstrip.match?(INDENT_OPEN_RE)
+      end
+
+      def dedent_trigger(char)
+        DEDENT_TRIGGERS[char]
+      end
+
       def color_columns(text)
         cols = {}
         Highlighter.apply_regex(cols, text, /"(?:\\.|[^"\\])*"\s*(?=:)/, "\e[36m")

data/lib/ruvim/rich_view/json_renderer.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RuVim
+  module RichView
+    module JsonRenderer
+      module_function
+
+      # Signal that this renderer creates a virtual buffer
+      # instead of entering rich mode on the same buffer.
+      def open_view!(editor)
+        buffer = editor.current_buffer
+        window = editor.current_window
+        text = buffer.lines.join("\n")
+
+        begin
+          parsed = JSON.parse(text)
+        rescue JSON::ParserError => e
+          editor.echo_error("JSON parse error: #{e.message}")
+          return
+        end
+
+        # Compute cursor's significant char offset before formatting
+        cursor_offset = char_offset_for(buffer.lines, window.cursor_y, window.cursor_x)
+        sig_count = significant_char_count(text, cursor_offset + 1)
+
+        formatted = JSON.pretty_generate(parsed)
+        lines = formatted.lines(chomp: true)
+
+        target_line = line_for_significant_count(formatted, sig_count)
+
+        buf = editor.add_virtual_buffer(
+          kind: :json_formatted,
+          name: "[JSON Formatted]",
+          lines: lines,
+          filetype: "json",
+          readonly: true,
+          modifiable: false
+        )
+        editor.switch_to_buffer(buf.id)
+        RichView.bind_close_keys(editor, buf.id)
+        window.cursor_y = [target_line, lines.length - 1].min
+        window.cursor_x = 0
+        editor.echo("[JSON Formatted] #{lines.length} lines")
+      end
+
+      # Count significant (non-whitespace-outside-strings) characters
+      # in text[0...byte_offset].
+      def significant_char_count(text, byte_offset)
+        in_string = false
+        escape = false
+        count = 0
+        text.each_char.with_index do |ch, i|
+          break if i >= byte_offset
+          if in_string
+            if escape
+              escape = false
+            elsif ch == "\\"
+              escape = true
+            elsif ch == '"'
+              in_string = false
+            end
+            count += 1
+          else
+            case ch
+            when '"'
+              in_string = true
+              count += 1
+            when " ", "\n", "\r", "\t"
+              # skip whitespace outside strings
+            else
+              count += 1
+            end
+          end
+        end
+        count
+      end
+
+      # Find the line number in text where the N-th significant character falls.
+      def line_for_significant_count(text, target_count)
+        return 0 if target_count <= 0
+
+        in_string = false
+        escape = false
+        count = 0
+        line = 0
+        text.each_char do |ch|
+          if ch == "\n" && !in_string
+            line += 1
+            next
+          end
+          if in_string
+            if escape
+              escape = false
+            elsif ch == "\\"
+              escape = true
+            elsif ch == '"'
+              in_string = false
+            end
+            count += 1
+          else
+            case ch
+            when '"'
+              in_string = true
+              count += 1
+            when " ", "\r", "\t"
+              # skip
+            else
+              count += 1
+            end
+          end
+          return line if count >= target_count
+        end
+        line
+      end
+
+      # Compute character offset in joined text from cursor row/col.
+      def char_offset_for(lines, row, col)
+        offset = 0
+        lines.each_with_index do |line, i|
+          if i == row
+            return offset + [col, line.length].min
+          end
+          offset += line.length + 1 # +1 for "\n"
+        end
+        offset
+      end
+    end
+  end
+end

data/lib/ruvim/rich_view/jsonl_renderer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RuVim
+  module RichView
+    module JsonlRenderer
+      module_function
+
+      SEPARATOR = "---"
+
+      def open_view!(editor)
+        buffer = editor.current_buffer
+        window = editor.current_window
+        cursor_row = window.cursor_y
+
+        output_lines = []
+        # Map from source line index to starting line in output
+        line_map = {}
+
+        buffer.lines.each_with_index do |raw_line, idx|
+          line = raw_line.to_s.strip
+          next if line.empty?
+
+          output_lines << SEPARATOR unless output_lines.empty?
+          line_map[idx] = output_lines.length
+
+          begin
+            parsed = JSON.parse(line)
+            formatted = JSON.pretty_generate(parsed)
+            formatted.each_line(chomp: true) { |l| output_lines << l }
+          rescue JSON::ParserError
+            output_lines << "// PARSE ERROR: #{raw_line}"
+          end
+        end
+
+        output_lines << "" if output_lines.empty?
+
+        target_line = line_map[cursor_row] || 0
+
+        buf = editor.add_virtual_buffer(
+          kind: :jsonl_formatted,
+          name: "[JSONL Formatted]",
+          lines: output_lines,
+          filetype: "json",
+          readonly: true,
+          modifiable: false
+        )
+        editor.switch_to_buffer(buf.id)
+        RichView.bind_close_keys(editor, buf.id)
+        window.cursor_y = [target_line, output_lines.length - 1].min
+        window.cursor_x = 0
+        editor.echo("[JSONL Formatted] #{output_lines.length} lines")
+      end
+    end
+  end
+end

data/lib/ruvim/rich_view.rb

@@ -2,6 +2,8 @@
 
 require_relative "rich_view/table_renderer"
 require_relative "rich_view/markdown_renderer"
+require_relative "rich_view/json_renderer"
+require_relative "rich_view/jsonl_renderer"
 
 module RuVim
   module RichView
@@ -46,6 +48,11 @@ module RuVim
       renderer = @renderers[format]
       raise RuVim::CommandError, "No renderer for format: #{format}" unless renderer
 
+      if renderer.respond_to?(:open_view!)
+        renderer.open_view!(editor)
+        return
+      end
+
       delimiter = renderer.delimiter_for(format)
       editor.enter_rich_mode(format: format, delimiter: delimiter)
       editor.echo("[Rich: #{format}]")
@@ -89,5 +96,14 @@ module RuVim
 
       editor.exit_rich_mode
     end
+
+    # Bind Esc and C-c to close a virtual buffer created by a renderer.
+    def bind_close_keys(editor, buffer_id)
+      km = editor.keymap_manager
+      return unless km
+
+      km.bind_buffer(buffer_id, "\e", "rich.close_buffer")
+      km.bind_buffer(buffer_id, "<C-c>", "rich.close_buffer")
+    end
   end
 end

data/lib/ruvim/screen.rb

@@ -871,15 +871,19 @@ module RuVim
     end
 
     def search_bg_seq(editor)
-      truecolor_enabled?(editor) ? "\e[48;2;255;215;0m" : "\e[43m"
+      term_color(editor, "\e[48;2;255;215;0m", "\e[43m")
     end
 
     def colorcolumn_bg_seq(editor)
-      truecolor_enabled?(editor) ? "\e[48;2;72;72;72m" : "\e[48;5;238m"
+      term_color(editor, "\e[48;2;72;72;72m", "\e[48;5;238m")
     end
 
     def cursorline_bg_seq(editor)
-      truecolor_enabled?(editor) ? "\e[48;2;58;58;58m" : "\e[48;5;236m"
+      term_color(editor, "\e[48;2;58;58;58m", "\e[48;5;236m")
+    end
+
+    def term_color(editor, truecolor_seq, fallback_seq)
+      truecolor_enabled?(editor) ? truecolor_seq : fallback_seq
     end
 
     def line_number_fg_seq(editor, current_line: false)
@@ -911,7 +915,7 @@ module RuVim
 
       path = buffer.display_name
       mod = buffer.modified? ? " [+]" : ""
-      stream = stream_status_token(buffer)
+      stream = buffer.stream_status ? " [#{buffer.stream_status}]" : ""
       loading = file_loading_status_token(buffer)
       tab = tab_status_token(editor)
       msg = editor.message_error? ? "" : editor.message.to_s
@@ -921,14 +925,6 @@ module RuVim
       "#{compose_status_body(left, msg, body_width)}#{right}"
     end
 
-    def stream_status_token(buffer)
-      return "" unless buffer.respond_to?(:stream_state)
-      return "" unless buffer.kind == :stream
-
-      state = (buffer.stream_state || :live).to_s
-      " [stdin/#{state}]"
-    end
-
     def file_loading_status_token(buffer)
       return "" unless buffer.respond_to?(:loading_state)
       return "" unless buffer.file_buffer?
@@ -1130,6 +1126,7 @@ module RuVim
       search = editor.last_search
       return {} unless search && search[:pattern]
       return {} unless editor.effective_option("hlsearch")
+      return {} if editor.hlsearch_suppressed?
 
       regex = build_screen_search_regex(editor, search[:pattern])
       cols = {}

data/lib/ruvim/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RuVim
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/ruvim.rb

@@ -18,6 +18,7 @@ require_relative "ruvim/lang/markdown"
 require_relative "ruvim/lang/ruby"
 require_relative "ruvim/lang/json"
 require_relative "ruvim/lang/scheme"
+require_relative "ruvim/lang/diff"
 require_relative "ruvim/highlighter"
 require_relative "ruvim/context"
 require_relative "ruvim/buffer"
@@ -25,6 +26,13 @@ require_relative "ruvim/window"
 require_relative "ruvim/editor"
 require_relative "ruvim/command_registry"
 require_relative "ruvim/ex_command_registry"
+require_relative "ruvim/git/blame"
+require_relative "ruvim/git/status"
+require_relative "ruvim/git/diff"
+require_relative "ruvim/git/log"
+require_relative "ruvim/git/branch"
+require_relative "ruvim/git/commit"
+require_relative "ruvim/git/handler"
 require_relative "ruvim/global_commands"
 require_relative "ruvim/dispatcher"
 require_relative "ruvim/keymap_manager"
@@ -35,6 +43,8 @@ require_relative "ruvim/rich_view"
 
 # Register renderers after RichView is defined
 RuVim::RichView.register("markdown", RuVim::RichView::MarkdownRenderer)
+RuVim::RichView.register("json", RuVim::RichView::JsonRenderer)
+RuVim::RichView.register("jsonl", RuVim::RichView::JsonlRenderer)
 
 require_relative "ruvim/lang/tsv"
 require_relative "ruvim/lang/csv"

data/test/app_completion_test.rb

@@ -210,4 +210,29 @@ class AppCompletionTest < Minitest::Test
     @app.send(:handle_insert_key, :ctrl_n)
     assert_equal "foobar", b.line_at(0)
   end
+
+  def test_git_subcommand_completion
+    @editor.materialize_intro_buffer!
+    @editor.enter_command_line_mode(":")
+    cmd = @editor.command_line
+    cmd.replace_text("git bl")
+
+    @app.send(:command_line_complete)
+
+    # "bl" matches "blame", "blameback", "blamecommit", "blameprev", "branch"
+    # With multiple matches, wildmode applies (longest common prefix or cycle)
+    text = cmd.text
+    assert text.start_with?("git bl"), "Expected completion to keep 'git bl' prefix, got: #{text}"
+  end
+
+  def test_git_subcommand_completion_unique
+    @editor.materialize_intro_buffer!
+    @editor.enter_command_line_mode(":")
+    cmd = @editor.command_line
+    cmd.replace_text("git co")
+
+    @app.send(:command_line_complete)
+
+    assert_equal "git commit", cmd.text
+  end
 end

data/test/app_scenario_test.rb

@@ -695,6 +695,28 @@ class AppScenarioTest < Minitest::Test
     assert_equal :normal, @editor.mode
   end
 
+  def test_paste_batch_suppresses_autoindent
+    @editor.current_buffer.replace_all_lines!(["  hello"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 0
+
+    # Normal enter in insert mode should autoindent
+    feed("A", :enter, :escape)
+    assert_equal ["  hello", "  "], @editor.current_buffer.lines
+
+    # Simulate paste batch: autoindent should be suppressed
+    @editor.current_buffer.replace_all_lines!(["  hello"])
+    @editor.current_window.cursor_y = 0
+    @editor.current_window.cursor_x = 0
+    feed("A")
+    @app.instance_variable_set(:@paste_batch, true)
+    feed(:enter, *"world".chars)
+    @app.instance_variable_set(:@paste_batch, false)
+    feed(:escape)
+
+    assert_equal ["  hello", "world"], @editor.current_buffer.lines
+  end
+
   def test_batch_insert_stops_on_escape
     @editor.current_buffer.replace_all_lines!([""])
     # Escape exits insert mode; subsequent keys are normal-mode commands
@@ -1072,4 +1094,151 @@ class AppScenarioTest < Minitest::Test
     assert_equal :hsplit, tree[:type]
     assert_equal 3, tree[:children].length
   end
+
+  # --- search filter (g/) ---
+
+  def test_filter_creates_buffer_with_matching_lines
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot", "cherry"])
+    feed("/", "a", "p", :enter)  # search for "ap"
+    feed("g", "/")
+
+    buf = @editor.current_buffer
+    assert_equal :filter, buf.kind
+    assert_equal ["apple", "apricot"], buf.lines
+  end
+
+  def test_filter_enter_jumps_to_original_line_and_closes_filter
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot", "cherry"])
+    original_buf_id = @editor.current_buffer.id
+    feed("/", "a", "p", :enter)
+    feed("g", "/")
+
+    # Move to second match line ("apricot", originally line 2)
+    feed("j")
+    feed(:enter)
+
+    assert_equal original_buf_id, @editor.current_buffer.id
+    assert_equal 2, @editor.current_window.cursor_y
+  end
+
+  def test_filter_quit_returns_to_previous_buffer
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot"])
+    original_buf_id = @editor.current_buffer.id
+    feed("/", "a", "p", :enter)
+    feed("g", "/")
+
+    assert_equal :filter, @editor.current_buffer.kind
+    feed(":", "q", :enter)
+
+    assert_equal original_buf_id, @editor.current_buffer.id
+  end
+
+  def test_filter_recursive_filtering
+    @editor.current_buffer.replace_all_lines!(["apple pie", "apricot jam", "apple sauce", "cherry"])
+    feed("/", "a", "p", :enter)
+    feed("g", "/")
+
+    assert_equal ["apple pie", "apricot jam", "apple sauce"], @editor.current_buffer.lines
+
+    # Search within filter and filter again
+    feed("/", "p", "l", "e", :enter)
+    feed("g", "/")
+
+    assert_equal ["apple pie", "apple sauce"], @editor.current_buffer.lines
+
+    # Enter jumps to original buffer
+    feed("j")  # "apple sauce" - originally line 2 of buffer
+    feed(:enter)
+
+    assert_equal 2, @editor.current_window.cursor_y
+  end
+
+  def test_filter_inherits_filetype
+    @editor.current_buffer.replace_all_lines!(["a\tb", "c\td", "a\te"])
+    @editor.current_buffer.options["filetype"] = "tsv"
+    feed("/", "a", :enter)
+    feed("g", "/")
+
+    assert_equal "tsv", @editor.current_buffer.options["filetype"]
+  end
+
+  def test_filter_without_search_pattern_shows_error
+    @editor.current_buffer.replace_all_lines!(["apple", "banana"])
+    feed("g", "/")
+
+    assert @editor.message_error?
+  end
+
+  def test_filter_quit_restores_cursor_position
+    @editor.current_buffer.replace_all_lines!(["aaa", "bbb", "aab", "ccc", "aac"])
+    original_buf_id = @editor.current_buffer.id
+    feed("/", "a", "a", :enter)
+    # Search moves cursor to line 0 (first match)
+    feed("n")
+    # Now on line 2 ("aab")
+    assert_equal 2, @editor.current_window.cursor_y
+    feed("g", "/")
+
+    assert_equal :filter, @editor.current_buffer.kind
+    feed(":", "q", :enter)
+
+    assert_equal original_buf_id, @editor.current_buffer.id
+    assert_equal 2, @editor.current_window.cursor_y
+  end
+
+  def test_filter_ex_command
+    @editor.current_buffer.replace_all_lines!(["apple", "banana", "apricot"])
+    feed("/", "a", "p", :enter)
+    feed(":", "f", "i", "l", "t", "e", "r", :enter)
+
+    assert_equal :filter, @editor.current_buffer.kind
+    assert_equal ["apple", "apricot"], @editor.current_buffer.lines
+  end
+
+  # --- dG / dgg / yG / ygg / cG / cgg ---
+
+  def test_dG_deletes_from_cursor_to_end
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd", "ee"])
+    @editor.current_window.cursor_y = 2
+    feed("d", "G")
+
+    assert_equal ["aa", "bb"], @editor.current_buffer.lines
+  end
+
+  def test_dgg_deletes_from_cursor_to_start
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd", "ee"])
+    @editor.current_window.cursor_y = 2
+    feed("d", "g", "g")
+
+    assert_equal ["dd", "ee"], @editor.current_buffer.lines
+  end
+
+  def test_yG_yanks_from_cursor_to_end
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd"])
+    @editor.current_window.cursor_y = 1
+    feed("y", "G")
+
+    reg = @editor.get_register('"')&.fetch(:text, "")
+    assert_includes reg, "bb"
+    assert_includes reg, "dd"
+  end
+
+  def test_ygg_yanks_from_cursor_to_start
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd"])
+    @editor.current_window.cursor_y = 2
+    feed("y", "g", "g")
+
+    reg = @editor.get_register('"')&.fetch(:text, "")
+    assert_includes reg, "aa"
+    assert_includes reg, "cc"
+  end
+
+  def test_cG_changes_from_cursor_to_end
+    @editor.current_buffer.replace_all_lines!(["aa", "bb", "cc", "dd"])
+    @editor.current_window.cursor_y = 2
+    feed("c", "G")
+
+    assert_equal ["aa", "bb", ""], @editor.current_buffer.lines
+    assert_equal :insert, @editor.mode
+  end
 end

data/test/cli_test.rb

@@ -153,6 +153,20 @@ class CLITest < Minitest::Test
     assert_equal "", err.string
   end
 
+  def test_parse_follow_option
+    opts = RuVim::CLI.parse(["-f", "log.txt"])
+
+    assert_equal ["log.txt"], opts.files
+    assert_equal true, opts.follow
+  end
+
+  def test_help_mentions_follow_option
+    out = StringIO.new
+    err = StringIO.new
+    RuVim::CLI.run(["--help"], stdout: out, stderr: err, stdin: StringIO.new)
+    assert_match(/-f\s+Open file in follow mode/, out.string)
+  end
+
   def test_run_returns_error_for_missing_config_file
     out = StringIO.new
     err = StringIO.new