ruvim 0.2.0 → 0.4.0

data/lib/ruvim/ex_command_registry.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RuVim
   class ExCommandRegistry
     ExCommandSpec = Struct.new(

data/lib/ruvim/file_watcher.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+module RuVim
+  module FileWatcher
+    def self.create(path, &on_event)
+      if InotifyWatcher.available? && File.exist?(path)
+        InotifyWatcher.new(path, &on_event)
+      else
+        PollingWatcher.new(path, &on_event)
+      end
+    end
+
+    class PollingWatcher
+      MIN_INTERVAL = 0.1
+      MAX_INTERVAL = 3.0
+      BACKOFF_FACTOR = 1.5
+
+      attr_reader :current_interval
+
+      def backend = :polling
+
+      def initialize(path, &on_event)
+        @path = path
+        @on_event = on_event
+        @offset = File.exist?(path) ? File.size(path) : 0
+        @file_existed = File.exist?(path)
+        @current_interval = MIN_INTERVAL
+        @thread = nil
+        @stop = false
+      end
+
+      def start
+        @stop = false
+        @thread = Thread.new { poll_loop }
+      end
+
+      def stop
+        @stop = true
+        @thread&.kill
+        @thread&.join(0.5)
+        @thread = nil
+      end
+
+      def alive?
+        @thread&.alive? || false
+      end
+
+      private
+
+      def poll_loop
+        until @stop
+          sleep @current_interval
+          check_file
+        end
+      rescue StandardError
+        nil
+      end
+
+      def check_file
+        exists = File.exist?(@path)
+
+        if !exists
+          if @file_existed
+            @file_existed = false
+            @offset = 0
+            @on_event.call(:deleted, nil)
+          end
+          @current_interval = [@current_interval * BACKOFF_FACTOR, MAX_INTERVAL].min
+          return
+        end
+
+        @file_existed = true
+        current_size = File.size(@path)
+        if current_size > @offset
+          data = File.binread(@path, current_size - @offset, @offset)
+          @offset = current_size
+          @current_interval = MIN_INTERVAL
+          @on_event.call(:data, RuVim::Buffer.decode_text(data)) if data && !data.empty?
+        elsif current_size < @offset
+          @offset = current_size
+          @current_interval = MIN_INTERVAL
+          @on_event.call(:truncated, nil)
+        else
+          @current_interval = [@current_interval * BACKOFF_FACTOR, MAX_INTERVAL].min
+        end
+      end
+    end
+
+    class InotifyWatcher
+      IN_MODIFY = 0x00000002
+      IN_DELETE_SELF = 0x00000400
+
+      def backend = :inotify
+
+      def self.available?
+        return @available unless @available.nil?
+        @available = begin
+          gem "fiddle" if defined?(Gem)
+          require "fiddle/import"
+          _mod = inotify_module
+          true
+        rescue LoadError, StandardError
+          false
+        end
+      end
+
+      def self.inotify_module
+        @inotify_module ||= begin
+          mod = Module.new do
+            extend Fiddle::Importer
+            dlload "libc.so.6"
+            extern "int inotify_init()"
+            extern "int inotify_add_watch(int, const char*, unsigned int)"
+            extern "int inotify_rm_watch(int, int)"
+          end
+          mod
+        end
+      end
+
+      def initialize(path, &on_event)
+        raise ArgumentError, "File does not exist: #{path}" unless File.exist?(path)
+
+        @path = path
+        @on_event = on_event
+        @offset = File.size(path)
+        @thread = nil
+        @stop = false
+        @inotify_io = nil
+        @watch_descriptor = nil
+      end
+
+      def start
+        @stop = false
+        setup_inotify!
+        @thread = Thread.new { watch_loop }
+      end
+
+      def stop
+        @stop = true
+        cleanup_inotify!
+        @thread&.join(0.5)
+        @thread = nil
+      end
+
+      def alive?
+        @thread&.alive? || false
+      end
+
+      private
+
+      def setup_inotify!
+        cleanup_inotify!
+        mod = self.class.inotify_module
+        fd = mod.inotify_init
+        raise "inotify_init failed" if fd < 0
+
+        @inotify_io = IO.new(fd)
+        @watch_descriptor = mod.inotify_add_watch(fd, @path, IN_MODIFY | IN_DELETE_SELF)
+        raise "inotify_add_watch failed" if @watch_descriptor < 0
+      end
+
+      def cleanup_inotify!
+        if @watch_descriptor && @inotify_io && !@inotify_io.closed?
+          begin
+            self.class.inotify_module.inotify_rm_watch(@inotify_io.fileno, @watch_descriptor)
+          rescue StandardError
+            nil
+          end
+        end
+        @watch_descriptor = nil
+        begin
+          @inotify_io&.close unless @inotify_io&.closed?
+        rescue StandardError
+          nil
+        end
+        @inotify_io = nil
+      end
+
+      def watch_loop
+        until @stop
+          ready = IO.select([@inotify_io], nil, nil, 1.0)
+          next unless ready
+
+          begin
+            event_data = @inotify_io.read_nonblock(4096)
+          rescue IO::WaitReadable
+            next
+          end
+
+          if file_deleted_event?(event_data)
+            @offset = 0
+            @on_event.call(:deleted, nil)
+            wait_for_file_and_rewatch!
+            next
+          end
+
+          read_new_data
+        end
+      rescue IOError, Errno::EBADF
+        nil
+      end
+
+      def file_deleted_event?(event_data)
+        return false unless event_data && event_data.bytesize >= 8
+
+        # inotify_event struct: int wd, uint32_t mask, uint32_t cookie, uint32_t len, char name[]
+        # mask is at offset 4, 4 bytes little-endian
+        mask = event_data.byteslice(4, 4).unpack1("V")
+        (mask & IN_DELETE_SELF) != 0
+      end
+
+      def wait_for_file_and_rewatch!
+        cleanup_inotify!
+        interval = PollingWatcher::MIN_INTERVAL
+        until @stop
+          sleep interval
+          if File.exist?(@path)
+            @offset = 0
+            setup_inotify!
+            return
+          end
+          interval = [interval * PollingWatcher::BACKOFF_FACTOR, PollingWatcher::MAX_INTERVAL].min
+        end
+      rescue StandardError
+        nil
+      end
+
+      def read_new_data
+        return unless File.exist?(@path)
+
+        current_size = File.size(@path)
+        if current_size > @offset
+          data = File.binread(@path, current_size - @offset, @offset)
+          @offset = current_size
+          @on_event.call(:data, RuVim::Buffer.decode_text(data)) if data && !data.empty?
+        elsif current_size < @offset
+          @offset = current_size
+          @on_event.call(:truncated, nil)
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/git/blame.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Git
+    module Blame
+      module_function
+
+      # Parse `git blame --porcelain` output into an array of entry hashes.
+      # Each entry: { hash:, short_hash:, author:, date:, summary:, text:, orig_line: }
+      def parse_porcelain(output)
+        entries = []
+        commit_cache = {}
+        current = nil
+
+        output.each_line(chomp: true) do |line|
+          if line.start_with?("\t")
+            current[:text] = line[1..]
+            entries << current
+            current = nil
+          elsif current.nil?
+            parts = line.split(" ")
+            hash = parts[0]
+            orig_line = parts[1].to_i
+
+            if commit_cache.key?(hash)
+              current = commit_cache[hash].dup
+              current[:orig_line] = orig_line
+            else
+              current = { hash: hash, short_hash: hash[0, 8], orig_line: orig_line }
+            end
+          else
+            case line
+            when /\Aauthor (.+)/
+              current[:author] = $1
+            when /\Aauthor-time (\d+)/
+              current[:date] = Time.at($1.to_i).strftime("%Y-%m-%d")
+            when /\Asummary (.+)/
+              current[:summary] = $1
+            when /\Afilename (.+)/
+              commit_cache[current[:hash]] ||= current.dup
+            end
+          end
+        end
+
+        entries
+      end
+
+      # Format entries into display lines for the blame buffer.
+      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|
+          author = (e[:author] || "").ljust(max_author)[0, max_author]
+          "#{e[:short_hash]} #{author} #{e[:date]} #{e[:text]}"
+        end
+      end
+
+      # Run git blame for a file at a given revision.
+      # Returns [entries, error_message].
+      def run(file_path, rev: nil)
+        dir = File.dirname(file_path)
+        basename = File.basename(file_path)
+
+        cmd = ["git", "blame", "--porcelain"]
+        if rev
+          cmd << rev << "--" << basename
+        else
+          cmd << "--" << basename
+        end
+
+        out, err, status = Open3.capture3(*cmd, chdir: dir)
+        unless status.success?
+          return [nil, err.strip]
+        end
+
+        entries = parse_porcelain(out)
+        [entries, nil]
+      end
+
+      # Run git show for a commit.
+      # Returns [lines, error_message].
+      def show_commit(file_path, commit_hash)
+        dir = File.dirname(file_path)
+        out, err, status = Open3.capture3("git", "show", commit_hash, chdir: dir)
+        unless status.success?
+          return [nil, err.strip]
+        end
+        [out.lines(chomp: true), nil]
+      end
+
+      # Command handler methods (included via Git::Handler)
+      module HandlerMethods
+        def git_blame(ctx, **)
+          source_buf = ctx.buffer
+          unless source_buf.path && File.exist?(source_buf.path)
+            ctx.editor.echo_error("No file to blame")
+            return
+          end
+
+          entries, err = Blame.run(source_buf.path)
+          unless entries
+            ctx.editor.echo_error("git blame: #{err}")
+            return
+          end
+
+          lines = Blame.format_lines(entries)
+          cursor_y = ctx.window.cursor_y
+
+          blame_buf = ctx.editor.add_virtual_buffer(
+            kind: :blame,
+            name: "[Blame] #{File.basename(source_buf.path)}",
+            lines: lines,
+            readonly: true,
+            modifiable: false
+          )
+          blame_buf.options["blame_entries"] = entries
+          blame_buf.options["blame_source_path"] = source_buf.path
+          blame_buf.options["blame_history"] = []
+
+          ctx.editor.switch_to_buffer(blame_buf.id)
+          ctx.window.cursor_y = [cursor_y, lines.length - 1].min
+
+          bind_git_buffer_keys(ctx.editor, blame_buf.id)
+          bind_blame_keys(ctx.editor, blame_buf.id)
+          ctx.editor.echo("[Blame] #{File.basename(source_buf.path)}")
+        end
+
+        def git_blame_prev(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :blame
+            ctx.editor.echo_error("Not a blame buffer")
+            return
+          end
+
+          entries = buf.options["blame_entries"]
+          source_path = buf.options["blame_source_path"]
+          history = buf.options["blame_history"]
+          cursor_y = ctx.window.cursor_y
+          entry = entries[cursor_y]
+
+          unless entry
+            ctx.editor.echo_error("No blame entry on this line")
+            return
+          end
+
+          commit_hash = entry[:hash]
+          if commit_hash.start_with?("0000000")
+            ctx.editor.echo_error("Uncommitted changes — cannot go further back")
+            return
+          end
+
+          new_entries, err = Blame.run(source_path, rev: "#{commit_hash}^")
+          unless new_entries
+            ctx.editor.echo_error("git blame: #{err}")
+            return
+          end
+
+          history.push({ entries: entries, cursor_y: cursor_y })
+
+          new_lines = Blame.format_lines(new_entries)
+          buf.instance_variable_set(:@lines, new_lines)
+          buf.options["blame_entries"] = new_entries
+          ctx.window.cursor_y = [cursor_y, new_lines.length - 1].min
+          ctx.window.cursor_x = 0
+          ctx.editor.echo("[Blame] #{commit_hash[0, 8]}^")
+        end
+
+        def git_blame_back(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :blame
+            ctx.editor.echo_error("Not a blame buffer")
+            return
+          end
+
+          history = buf.options["blame_history"]
+          if history.nil? || history.empty?
+            ctx.editor.echo_error("No blame history to go back to")
+            return
+          end
+
+          state = history.pop
+          lines = Blame.format_lines(state[:entries])
+          buf.instance_variable_set(:@lines, lines)
+          buf.options["blame_entries"] = state[:entries]
+          ctx.window.cursor_y = [state[:cursor_y], lines.length - 1].min
+          ctx.window.cursor_x = 0
+          ctx.editor.echo("[Blame] restored")
+        end
+
+        def git_blame_commit(ctx, **)
+          buf = ctx.buffer
+          unless buf.kind == :blame
+            ctx.editor.echo_error("Not a blame buffer")
+            return
+          end
+
+          entries = buf.options["blame_entries"]
+          source_path = buf.options["blame_source_path"]
+          entry = entries[ctx.window.cursor_y]
+
+          unless entry
+            ctx.editor.echo_error("No blame entry on this line")
+            return
+          end
+
+          commit_hash = entry[:hash]
+          if commit_hash.start_with?("0000000")
+            ctx.editor.echo_error("Uncommitted changes — no commit to show")
+            return
+          end
+
+          lines, err = Blame.show_commit(source_path, commit_hash)
+          unless lines
+            ctx.editor.echo_error("git show: #{err}")
+            return
+          end
+
+          show_buf = ctx.editor.add_virtual_buffer(
+            kind: :git_show,
+            name: "[Commit] #{commit_hash[0, 8]}",
+            lines: lines,
+            filetype: "diff",
+            readonly: true,
+            modifiable: false
+          )
+          ctx.editor.switch_to_buffer(show_buf.id)
+          bind_git_buffer_keys(ctx.editor, show_buf.id)
+          ctx.editor.echo("[Commit] #{commit_hash[0, 8]}")
+        end
+
+        private
+
+        def bind_blame_keys(editor, buffer_id)
+          km = editor.keymap_manager
+          km.bind_buffer(buffer_id, "p", "git.blame.prev")
+          km.bind_buffer(buffer_id, "P", "git.blame.back")
+          km.bind_buffer(buffer_id, "c", "git.blame.commit")
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/git/branch.rb

@@ -0,0 +1,97 @@
+# 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
+
+          root = buf.options["git_repo_root"]
+          _out, err, status = Open3.capture3("git", "checkout", branch, chdir: root)
+          unless status.success?
+            ctx.editor.echo_error("git checkout: #{err.strip}")
+            return
+          end
+
+          # Refresh the branch list
+          ctx.editor.delete_buffer(buf.id)
+          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