ruvim 0.3.0 → 0.6.0

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/gh/link.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module RuVim
+  module Gh
+    module Link
+      module_function
+
+      # Parse a git remote URL and return the GitHub HTTPS base URL.
+      # Returns nil if the remote is not a GitHub URL.
+      def github_url_from_remote(remote_url)
+        url = remote_url.to_s.strip
+        return nil if url.empty?
+
+        case url
+        when %r{\Agit@github\.com:(.+?)(?:\.git)?\z}
+          "https://github.com/#{$1}"
+        when %r{\Ahttps://github\.com/(.+?)(?:\.git)?\z}
+          "https://github.com/#{$1}"
+        end
+      end
+
+      # Build a GitHub blob URL.
+      def build_url(base_url, ref, relative_path, line_start, line_end = nil)
+        fragment = if line_end && line_end != line_start
+                     "#L#{line_start}-L#{line_end}"
+                   else
+                     "#L#{line_start}"
+                   end
+        "#{base_url}/blob/#{ref}/#{relative_path}#{fragment}"
+      end
+
+      # Generate OSC 52 escape sequence for clipboard copy.
+      def osc52_copy_sequence(text)
+        encoded = [text].pack("m0")
+        "\e]52;c;#{encoded}\a"
+      end
+
+      # Find a GitHub remote. If remote_name is given, use that specific remote.
+      # Otherwise, scan all remotes (preferring "origin", then "upstream", then others).
+      # Returns [remote_name, base_url] or [nil, nil].
+      def find_github_remote(root, remote_name = nil)
+        if remote_name
+          url, _, status = Open3.capture3("git", "remote", "get-url", remote_name, chdir: root)
+          return [nil, nil] unless status.success?
+
+          base = github_url_from_remote(url.strip)
+          return base ? [remote_name, base] : [nil, nil]
+        end
+
+        remotes_out, _, status = Open3.capture3("git", "remote", chdir: root)
+        return [nil, nil] unless status.success?
+
+        remotes = remotes_out.lines(chomp: true)
+        # Prefer origin, then upstream, then others
+        ordered = []
+        ordered << "origin" if remotes.include?("origin")
+        ordered << "upstream" if remotes.include?("upstream")
+        remotes.each { |r| ordered << r unless ordered.include?(r) }
+
+        ordered.each do |name|
+          url, _, st = Open3.capture3("git", "remote", "get-url", name, chdir: root)
+          next unless st.success?
+
+          base = github_url_from_remote(url.strip)
+          return [name, base] if base
+        end
+
+        [nil, nil]
+      end
+
+      # Check if a file differs from the remote tracking branch.
+      def file_differs_from_remote?(root, remote_name, branch, file_path)
+        remote_ref = "#{remote_name}/#{branch}"
+        diff_out, _, status = Open3.capture3("git", "diff", remote_ref, "--", file_path, chdir: root)
+        # If the remote ref doesn't exist or diff fails, consider it as differing
+        return true unless status.success?
+
+        !diff_out.empty?
+      end
+
+      # Resolve GitHub link for a file path at given line(s).
+      # Returns [url, warning, error_message].
+      def resolve(file_path, line_start, line_end = nil, remote_name: nil)
+        root, err = RuVim::Git.repo_root(file_path)
+        return [nil, nil, err] unless root
+
+        found_remote, base_url = find_github_remote(root, remote_name)
+        unless base_url
+          msg = remote_name ? "Remote '#{remote_name}' is not a GitHub remote" : "No GitHub remote found"
+          return [nil, nil, msg]
+        end
+
+        branch, _, status = Open3.capture3("git", "rev-parse", "--abbrev-ref", "HEAD", chdir: root)
+        unless status.success?
+          return [nil, nil, "Cannot determine branch"]
+        end
+        branch = branch.strip
+
+        relative_path = file_path.sub(%r{\A#{Regexp.escape(root)}/?}, "")
+        url = build_url(base_url, branch, relative_path, line_start, line_end)
+
+        warning = nil
+        if file_differs_from_remote?(root, found_remote, branch, file_path)
+          warning = "(remote may differ)"
+        end
+
+        [url, warning, nil]
+      end
+
+      # Build a GitHub PR search URL for a branch.
+      def pr_search_url(base_url, branch)
+        "#{base_url}/pulls?q=head:#{branch}"
+      end
+
+      # Resolve GitHub PR URL for the current repo.
+      # Returns [url, error_message].
+      def resolve_pr(file_path)
+        root, err = RuVim::Git.repo_root(file_path)
+        return [nil, err] unless root
+
+        _, base_url = find_github_remote(root)
+        return [nil, "No GitHub remote found"] unless base_url
+
+        branch, _, status = Open3.capture3("git", "rev-parse", "--abbrev-ref", "HEAD", chdir: root)
+        return [nil, "Cannot determine branch"] unless status.success?
+
+        [pr_search_url(base_url, branch.strip), nil]
+      end
+
+      module HandlerMethods
+        def gh_link(ctx, argv: [], kwargs: {}, **)
+          url, warning = gh_resolve_url(ctx, argv: argv, kwargs: kwargs, command: "gh link")
+          return unless url
+
+          # Copy to clipboard via OSC 52
+          $stdout.write(Link.osc52_copy_sequence(url))
+          $stdout.flush
+
+          msg = warning ? "#{url} #{warning}" : url
+          ctx.editor.echo(msg)
+        end
+
+        def gh_browse(ctx, argv: [], kwargs: {}, **)
+          url, warning = gh_resolve_url(ctx, argv: argv, kwargs: kwargs, command: "gh browse")
+          return unless url
+
+          unless Browser.open_url(url)
+            ctx.editor.echo_error("gh browse: could not open browser")
+            return
+          end
+
+          msg = warning ? "Opened #{url} #{warning}" : "Opened #{url}"
+          ctx.editor.echo(msg)
+        end
+
+        def gh_pr(ctx, **)
+          path = ctx.buffer.path || Dir.pwd
+          url, err = Link.resolve_pr(path)
+          unless url
+            ctx.editor.echo_error("gh pr: #{err}")
+            return
+          end
+
+          unless Browser.open_url(url)
+            ctx.editor.echo_error("gh pr: could not open browser")
+            return
+          end
+
+          ctx.editor.echo("Opened #{url}")
+        end
+
+        private
+
+        def gh_resolve_url(ctx, argv:, kwargs:, command:)
+          path = ctx.buffer.path
+          unless path && File.exist?(path)
+            ctx.editor.echo_error("Buffer has no file path")
+            return nil
+          end
+
+          line_start = kwargs[:range_start]
+          line_end = kwargs[:range_end]
+
+          if line_start
+            line_start += 1
+            line_end += 1 if line_end
+          else
+            line_start = ctx.window.cursor_y + 1
+            line_end = nil
+          end
+
+          remote_name = argv.first
+
+          url, warning, err = Link.resolve(path, line_start, line_end, remote_name: remote_name)
+          unless url
+            ctx.editor.echo_error("#{command}: #{err}")
+            return nil
+          end
+
+          [url, warning]
+        end
+      end
+    end
+  end
+end

data/lib/ruvim/git/blame.rb

@@ -0,0 +1,255 @@
+# 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 code lines and gutter labels.
+      # Returns [lines, labels] where lines are code-only and labels are metadata strings.
+      def format_lines(entries)
+        max_author = entries.map { |e| e[:author].to_s.length }.max || 0
+        max_author = [max_author, 20].min
+
+        lines = []
+        labels = []
+        entries.each do |e|
+          author = (e[:author] || "").ljust(max_author)[0, max_author]
+          labels << "#{e[:short_hash]} #{author} #{e[:date]} "
+          lines << e[:text].to_s
+        end
+        [lines, labels]
+      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, labels = Blame.format_lines(entries)
+          cursor_y = ctx.window.cursor_y
+          source_ft = source_buf.options["filetype"]
+
+          blame_buf = ctx.editor.add_virtual_buffer(
+            kind: :blame,
+            name: "[Blame] #{File.basename(source_buf.path)}",
+            lines: lines,
+            filetype: source_ft,
+            readonly: true,
+            modifiable: false
+          )
+          blame_buf.options["blame_entries"] = entries
+          blame_buf.options["blame_source_path"] = source_buf.path
+          blame_buf.options["blame_history"] = []
+          blame_buf.options["gutter_labels"] = labels
+
+          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, new_labels = Blame.format_lines(new_entries)
+          buf.instance_variable_set(:@lines, new_lines)
+          buf.options["blame_entries"] = new_entries
+          buf.options["gutter_labels"] = new_labels
+          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, labels = Blame.format_lines(state[:entries])
+          buf.instance_variable_set(:@lines, lines)
+          buf.options["blame_entries"] = state[:entries]
+          buf.options["gutter_labels"] = labels
+          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