canopus 0.4.0 → 0.5.0

data/lib/canopus/workspace/editor_configurable.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "editor_config"
+
+module Canopus
+  module Workspace::EditorConfigurable
+    EDITORCONFIG_MAX_BYTES = 64 * 1024
+    EDITORCONFIG_CACHE_LIMIT = 1_024
+
+    # Return settings with the file's EditorConfig properties inserted before
+    # the project settings layer.
+    def settings_for_path(path, language: nil)
+      settings = editorconfig_settings(path)
+      language ? settings.for_language(language) : settings
+    end
+
+    def settings_for_editor(editor)
+      settings_for_path(editor.buffer.path, language: editor.language_document.definition.name)
+    end
+
+    def invalidate_editorconfig
+      @editorconfig_cache&.clear
+      nil
+    end
+
+    def prepare_editorconfig_save(buffer, path)
+      return if buffer.read_only
+      values = settings_for_path(path)
+      buffer.trim_trailing_whitespace if values["trim_trailing_whitespace"]
+      buffer.ensure_final_newline if values["insert_final_newline"]
+    end
+
+    private
+
+    def editorconfig_settings(path)
+      return @settings unless @settings["editorconfig"] && path
+      properties = editorconfig_properties(path)
+      return @settings if properties.empty?
+
+      layers = @settings.layers.dup
+      project_path = File.expand_path(File.join(@root, ".canopus", "settings.jsonc"))
+      index = layers.index do |layer|
+        next false unless layer.is_a?(String)
+        candidate = File.expand_path(layer)
+        candidate = File.realpath(candidate) if File.exist?(candidate)
+        candidate == project_path
+      end
+      layers.insert(index || layers.length, properties)
+      Settings.new(*layers)
+    rescue StandardError => error
+      @message = "EditorConfig ignored: #{error.message}"
+      @settings
+    end
+
+    def editorconfig_properties(path)
+      absolute = File.expand_path(path, @root)
+      absolute = File.realpath(absolute) if File.exist?(absolute)
+      return {} unless absolute == @root || absolute.start_with?(@root + File::SEPARATOR)
+      relative = absolute.delete_prefix(@root + File::SEPARATOR)
+      return {} if relative.empty?
+
+      @editorconfig_cache ||= {}
+      return @editorconfig_cache[absolute] if @editorconfig_cache.key?(absolute)
+
+      raw = EditorConfig.load(relative) do |candidate|
+        editorconfig_file(candidate)
+      end
+      properties = map_editorconfig(EditorConfig.preprocess(raw))
+      @editorconfig_cache[absolute] = properties.freeze
+      @editorconfig_cache.shift if @editorconfig_cache.length > EDITORCONFIG_CACHE_LIMIT
+      properties
+    rescue ArgumentError, EncodingError, IOError, SystemCallError
+      @editorconfig_cache[absolute] = {}.freeze if defined?(@editorconfig_cache) && absolute
+      {}
+    end
+
+    def editorconfig_file(candidate)
+      absolute = File.expand_path(candidate, @root)
+      real = File.realpath(absolute)
+      return unless real == @root || real.start_with?(@root + File::SEPARATOR)
+      return unless absolute == @root || absolute.start_with?(@root + File::SEPARATOR)
+      stat = File.lstat(absolute)
+      return unless stat.file? && !stat.symlink? && stat.size <= EDITORCONFIG_MAX_BYTES
+
+      source = File.binread(absolute)
+      return unless source.force_encoding(Encoding::UTF_8).valid_encoding?
+
+      source
+    rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP, IOError, SystemCallError
+      nil
+    end
+
+    def map_editorconfig(properties)
+      values = {}
+      style = properties[EditorConfig::INDENT_STYLE]
+      values["use_tabs"] = style == EditorConfig::TAB if [EditorConfig::SPACE, EditorConfig::TAB].include?(style)
+
+      size = properties[EditorConfig::INDENT_SIZE]
+      size = properties[EditorConfig::TAB_WIDTH] if size.nil? || size == EditorConfig::TAB
+      values["tab_size"] = size.to_i if size&.match?(/\A[1-9]\d*\z/) && size.to_i <= 16
+
+      {EditorConfig::TRIM_TRAILING_WHITESPACE => "trim_trailing_whitespace",
+       EditorConfig::INSERT_FINAL_NEWLINE => "insert_final_newline"}.each do |source, target|
+        value = properties[source]
+        values[target] = value == EditorConfig::TRUE if [EditorConfig::TRUE, EditorConfig::FALSE].include?(value)
+      end
+
+      length = properties[EditorConfig::MAX_LINE_LENGTH]
+      values["max_line_length"] = length.to_i if length&.match?(/\A[1-9]\d*\z/) && length.to_i <= 1_000_000
+      values
+    end
+  end
+end

data/lib/canopus/workspace/file_change_aware.rb

@@ -4,10 +4,14 @@ module Canopus
   module Workspace::FileChangeAware
     def start_watching
       return if @watcher || !@project
-      native = begin
-        Zaniah::Platform.watch(@root)
-      rescue LoadError, Zaniah::Error, SystemCallError
+      native = if @window && @window.class == Zaniah::Platform::Headless::Window
         nil
+      else
+        begin
+          Zaniah::Platform.watch(@root)
+        rescue LoadError, Zaniah::Error, SystemCallError
+          nil
+        end
       end
       @watcher = @project.watcher(native: native)
       @last_watch = 0
@@ -20,6 +24,10 @@ module Canopus
       events = @watcher.poll
       invalidate_git unless events.empty?
       refresh_files unless events.empty?
+      if events.any? { |event| File.basename(event.path) == ".editorconfig" }
+        invalidate_editorconfig
+        apply_settings
+      end
       events.each do |event|
         path = File.expand_path(event.path, @root)
         buffer = @buffers[path]

data/lib/canopus/workspace/git_aware.rb

@@ -1,35 +1,39 @@
 # frozen_string_literal: true
 
+require_relative "../git/state"
+
 module Canopus
   module Workspace::GitAware
     def git
       return @git if defined?(@git)
       @git = Thuban::Repository.new(@root)
       @git = nil unless @git.root
+      @git
     rescue ArgumentError
       @git = nil
     end
     def git_status
-      return @git_status if @git_status
-      return {} unless git
+      state = git_state
+      return {} unless state
+      return state.snapshot.entries if state.snapshot
       if @window
         unless @git_status_job&.alive?
-          generation = @git_generation
+          generation = @git_generation ||= 0
           @git_status_job = Thread.new do
-            status = git.status.to_h { |entry| [entry.path, entry.code] }
-            post { @git_status = status if generation == @git_generation } unless @closed
+            snapshot = state.capture
+            post { install_git_snapshot(state, snapshot) if generation == @git_generation } unless @closed
           rescue StandardError => error
             post { @message = "Git status: #{error.message}" } unless @closed
           end
         end
         {}
       else
-        @git_status = git.status.to_h { |entry| [entry.path, entry.code] }
+        install_git_snapshot(state, state.capture).entries
       end
     end
     def invalidate_git
       @git_generation = (@git_generation || 0) + 1
-      @git_status = @git_diff_cache = nil
+      @git_state&.invalidate
       @decorations.invalidate(:git)
       @panes.each do |pane|
         pane.editors.each do |current|
@@ -41,18 +45,18 @@ module Canopus
     def poll_git_changes(now: Process.clock_gettime(Process::CLOCK_MONOTONIC))
       return if @last_git_poll && now - @last_git_poll < 1
       @last_git_poll = now
-      return unless git
-      index = File.join(git.git_dir, "index")
-      stat = File.stat(index) if File.file?(index)
-      state = [git.head, git.branch, stat&.mtime, stat&.size, stat&.ino]
-      return if @git_state == state
-      initial = !defined?(@git_state)
-      @git_state = state
-      return if initial
-      invalidate_git
-      @window&.request_frame
-    rescue SystemCallError, ArgumentError => error
-      @message = "Git: #{error.message}"
+      state = git_state
+      return unless state
+      unless @git_poll_job&.alive?
+        generation = @git_generation ||= 0
+        @git_poll_job = Thread.new do
+          identity = state.identity
+          post { install_git_identity(identity) if generation == @git_generation } unless @closed
+        rescue StandardError => error
+          post { @message = "Git: #{error.message}" } unless @closed
+        end
+      end
+      nil
     end
     def git_relative_path(buffer = editor.buffer)
       raise Error, "Current document is not in a Git repository" unless git && buffer.path && buffer.path.start_with?(git.root + File::SEPARATOR)
@@ -61,22 +65,25 @@ module Canopus
     def git_diff(buffer = editor.buffer, async: true)
       return unless git && buffer.path && buffer.path.start_with?(git.root + File::SEPARATOR) && buffer.rope.bytesize < 10 << 20
       path = git_relative_path(buffer)
-      @git_diff_cache ||= {}
-      key = [buffer.object_id, path, buffer.version, git.head]
-      @git_diff_cache.clear if @git_diff_cache.length > 20
-      return @git_diff_cache[key] if @git_diff_cache.key?(key)
+      state = git_state
+      key = [buffer.object_id, path, buffer.version, state.snapshot&.head]
+      cached = state.cached_diff(key)
+      return cached if cached
       if @window && async
         @git_diff_jobs ||= {}
         unless @git_diff_jobs[buffer]&.alive?
           snapshot = buffer.rope
+          generation = @git_generation ||= 0
           @git_diff_jobs[buffer] = Thread.new do
-            before = Buffer.decode_bytes(git.blob(path, reference: key.last || "HEAD").to_s).first
+            before = Buffer.decode_bytes(state.synchronize { |repository| repository.blob(path, reference: key.last || "HEAD") }.to_s).first
             diff = Porrima.diff(before, snapshot.to_s, context: 0)
             diff.hunks
             diff.marks
             post do
-              (@git_diff_cache ||= {})[key] = diff
-              @decorations.invalidate(:git, buffer: buffer)
+              if generation == @git_generation
+                state.store_diff(key, diff)
+                @decorations.invalidate(:git, buffer: buffer)
+              end
             end unless @closed
           rescue StandardError => error
             post { @message = "Git diff: #{error.message}" } unless @closed
@@ -84,11 +91,11 @@ module Canopus
         end
         nil
       else
-        before = Buffer.decode_bytes(git.blob(path).to_s).first
+        before = Buffer.decode_bytes(state.synchronize { |repository| repository.blob(path, reference: key.last || "HEAD") }.to_s).first
         diff = Porrima.diff(before, buffer.text, context: 0)
         diff.hunks
         diff.marks
-        @git_diff_cache[key] = diff
+        state.store_diff(key, diff)
       end
     end
     def git_hunks(buffer = editor.buffer, async: true) = git_diff(buffer, async: async)&.hunks || []
@@ -100,23 +107,24 @@ module Canopus
         next if first + count <= rows.begin || first >= rows.end
 
         color = mark.kind == :removed ? :error : mark.kind == :added ? "#80b987" : :accent
-        style = {color: color, rows: count}.freeze
+        style = {color: color, rows: count, hit_width: 7}.freeze
         click = ->(current, row) { toggle_git_hunk(current, row: row) }
         Decoration::Item.new(:gutter, nil, first, "Toggle Git hunk", style, 0, :git, click)
       end
     end
     def show_git_diff
       path = git_relative_path
-      before = Buffer.decode_bytes(git.blob(path).to_s).first
+      before = Buffer.decode_bytes(git_state.synchronize { |repository| repository.blob(path) }.to_s).first
       buffer = Buffer.new(Porrima.unified(before, editor.buffer.text, old_name: "a/#{path}", new_name: "b/#{path}"), read_only: true)
       @buffers[buffer.object_id] = buffer
       @active_pane.open(buffer).language = Language::Definition.new("diff", "diff", [], "", /\A\z/, /\A\z/, [])
+      invalidate_hidden_selection_ranges
     end
     def toggle_git_hunk(current = editor, row: nil)
       row ||= current.buffer.rope.point_at(current.primary.head).row
       hunk = git_diff(current.buffer, async: false)&.hunk_at(new_line: row + 1)
       raise Error, "No change at the cursor" unless hunk
-      id = [:git_hunk, current.buffer.path, current.buffer.version, git.head, hunk.old_start, hunk.new_start]
+      id = [:git_hunk, current.buffer.path, current.buffer.version, git_state.snapshot&.head, hunk.old_start, hunk.new_start]
       map = current.display_map
       if map.block_map.blocks.key?(id)
         map.remove_block(id)
@@ -138,7 +146,7 @@ module Canopus
     end
     def show_git_blame
       path = git_relative_path
-      lines = git.blame(path)
+      lines = git_state.synchronize { |repository| repository.blame(path) }
       @hover_card = lines.map { |line| "#{line.commit.to_s[0, 8]} #{line.author} #{line.text}" }.join
     end
     def revert_current_hunk
@@ -150,12 +158,50 @@ module Canopus
     end
     def checkout_branch(name)
       raise Error, "Save or discard all buffer changes before switching branches" if @buffers.values.any?(&:dirty?)
-      raise Error, "Not a Git repository" unless git
-      git.checkout(name)
+      raise Error, "Not a Git repository" unless git_state
+      git_state.synchronize { |repository| repository.checkout(name) }
       invalidate_git
       refresh_files
       @buffers.values.each { |buffer| buffer.reload if buffer.path && File.file?(buffer.path) && !buffer.read_only }
       @message = "Switched to #{name}"
     end
+
+    private
+
+    def git_state
+      return @git_state if defined?(@git_state)
+      @git_state = Git::State.new(git) if git
+    end
+
+    def install_git_snapshot(state, snapshot)
+      state.install(snapshot)
+      @git_identity = snapshot.identity
+      refresh_scm if @scm_tree
+      snapshot
+    end
+
+    def install_git_identity(identity)
+      initial = !defined?(@git_identity)
+      changed = !initial && @git_identity != identity
+      @git_identity = identity
+      return unless changed
+
+      invalidate_git
+      refresh_scm if @scm_tree
+      @window&.request_frame
+    end
+
+    def git_branches
+      state = git_state
+      state ? state.synchronize { |repository| repository.branches } : []
+    end
+
+    def close_git
+      [@git_status_job, @git_poll_job, @git_commit_job, *@git_diff_jobs&.values].compact.uniq.each do |thread|
+        thread.join unless thread.equal?(Thread.current)
+      end
+      @git_diff_jobs&.clear
+      nil
+    end
   end
 end

data/lib/canopus/workspace/git_blame.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::GitBlame
+    BLAME_MAX_BYTES = 1 << 20
+    BLAME_MAX_LINES = 20_000
+    BLAME_CACHE_LIMIT = 16
+    BLAME_BUDGET = Porrima::Budget.new(max_bytes: 2 << 20, max_lines: BLAME_MAX_LINES)
+
+    GitBlameLine = Data.define(:commit, :author, :original_line, :path)
+    GitBlameSnapshot = Data.define(:key, :lines, :reason)
+
+    def git_blame_decorations(buffer, rows, current = nil)
+      mode = @settings["git"]["inline_blame"]
+      return [] if mode == "off" || !buffer.path || buffer.rope.bytesize > BLAME_MAX_BYTES ||
+        buffer.line_count > BLAME_MAX_LINES
+      text = buffer.text
+      return [] unless git_blame_text_supported?(text)
+
+      path = safe_git_diff_path(git_relative_path(buffer))
+      key = [buffer.object_id, buffer.version, @git_generation.to_i, path].freeze
+      snapshot = (@git_blame_cache ||= {})[key]
+      unless snapshot
+        requested = request_git_blame(buffer, path, key, text.dup.freeze)
+        snapshot = requested if requested.is_a?(GitBlameSnapshot)
+        return [] unless snapshot
+      end
+      return [] if snapshot.reason
+
+      visible = rows.begin...[rows.end, buffer.line_count].min
+      selected = if mode == "cursor"
+        return [] unless current.is_a?(Editor) && current.buffer.equal?(buffer)
+        row = buffer.rope.point_at(current.primary.head).row
+        visible.cover?(row) ? [row] : []
+      else
+        visible.to_a
+      end
+      selected.filter_map do |row|
+        next if row == buffer.line_count - 1 && buffer.line(row).empty?
+        git_blame_decoration(buffer, row, snapshot.lines[row])
+      end
+    rescue Error
+      []
+    end
+
+    def invalidate_git_blame(buffer = nil)
+      @git_blame_generation = (@git_blame_generation || 0) + 1
+      if buffer
+        @git_blame_cache&.delete_if { |key, _| key[0] == buffer.object_id }
+      else
+        @git_blame_cache&.clear
+      end
+      @decorations.invalidate(:blame, buffer: buffer)
+      nil
+    end
+
+    def invalidate_git
+      invalidate_git_blame
+      super
+    end
+
+    def close_git
+      @git_blame_generation = (@git_blame_generation || 0) + 1
+      jobs = [*@git_blame_jobs&.values].compact.uniq.reject { |thread| thread.equal?(Thread.current) }
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 0.1
+      jobs.each do |thread|
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        break unless remaining.positive?
+        thread.join(remaining)
+      end
+      jobs.each { |thread| thread.kill if thread.alive? }
+      jobs.each(&:join)
+      @git_blame_jobs&.clear
+      super
+    end
+
+    private
+
+    def request_git_blame(buffer, path, key, text)
+      @git_blame_jobs ||= {}
+      return if @git_blame_jobs[buffer]&.alive?
+
+      generation = @git_blame_generation ||= 0
+      work = lambda do
+        capture = git_state.synchronize do |repository|
+          raw = repository.blob(path)
+          if raw && raw.bytesize <= BLAME_MAX_BYTES
+            committed = Buffer.decode_bytes(raw).first
+            git_blame_text_supported?(committed) ? [committed, repository.blame(path)].freeze : [nil, nil].freeze
+          else
+            [nil, nil].freeze
+          end
+        end
+        materialize_git_blame(key, text, *capture)
+      end
+      return install_git_blame(buffer, work.call) unless @window
+
+      @git_blame_jobs[buffer] = Thread.new do
+        current = Thread.current
+        snapshot = work.call
+        post { finish_git_blame(current, generation, buffer, snapshot, nil) } unless @closed
+      rescue StandardError => error
+        post { finish_git_blame(current, generation, buffer, nil, error) } unless @closed
+      end
+    rescue StandardError => error
+      install_git_blame(buffer, GitBlameSnapshot.new(key, [].freeze,
+        safe_git_history_text(error.message, 200).freeze).freeze)
+    end
+
+    def git_blame_text_supported?(text)
+      text.bytesize <= BLAME_MAX_BYTES && text.count("\n") + 1 <= BLAME_MAX_LINES &&
+        !text.match?(/\r(?!\n)|[\u2028\u2029]/)
+    end
+
+    def materialize_git_blame(key, text, committed, blamed)
+      return GitBlameSnapshot.new(key, [].freeze, "Blame unavailable for large or missing content".freeze).freeze unless committed
+      reason = scm_diff_budget_reason(committed, text)
+      return GitBlameSnapshot.new(key, [].freeze, "Blame unavailable: #{scm_diff_budget_description(reason)}".freeze).freeze if reason
+
+      lines = Array.new(text.lines.length)
+      comparison_committed = committed.gsub("\r\n", "\n")
+      comparison_text = text.gsub("\r\n", "\n")
+      if comparison_committed == comparison_text
+        blamed.each_with_index { |line, index| lines[index] = copy_git_blame_line(line) }
+      else
+        Porrima.diff(comparison_committed, comparison_text, budget: BLAME_BUDGET).edits.each do |edit|
+          next unless edit.kind == :equal
+          lines[edit.new_line - 1] = copy_git_blame_line(blamed[edit.old_line - 1])
+        end
+      end
+      GitBlameSnapshot.new(key, lines.freeze, nil).freeze
+    rescue Porrima::BudgetExceeded
+      GitBlameSnapshot.new(key, [].freeze, "Blame unavailable: diff budget exceeded".freeze).freeze
+    end
+
+    def copy_git_blame_line(line)
+      return unless line
+      GitBlameLine.new(line.commit.to_s.dup.freeze, safe_git_history_text(line.author, 100).freeze,
+        line.original_line, line.path.to_s.dup.freeze).freeze
+    end
+
+    def git_blame_decoration(buffer, row, line)
+      source = buffer.line(row)
+      body = source.delete_suffix("\n").delete_suffix("\r")
+      offset = buffer.rope.line_start(row) + body.bytesize
+      content = if line
+        "  #{line.author} · #{line.commit[0, 8]}"
+      else
+        "  Uncommitted changes"
+      end
+      Decoration::Item.new(:inline, offset...offset, row, content.freeze,
+        {color: :muted, padding_left: 8, cells: Zaniah::Unicode.width(content)}.freeze,
+        90, :blame, nil)
+    end
+
+    def install_git_blame(buffer, snapshot)
+      cache = @git_blame_cache ||= {}
+      cache.shift while cache.length >= BLAME_CACHE_LIMIT
+      cache[snapshot.key] = snapshot
+      @decorations.invalidate(:blame, buffer: buffer)
+      @window&.request_frame
+      snapshot
+    end
+
+    def finish_git_blame(worker, generation, buffer, snapshot, error)
+      @git_blame_jobs&.delete(buffer) if @git_blame_jobs&.[](buffer).equal?(worker)
+      return unless generation == @git_blame_generation
+      if error
+        self.message = "Git blame: #{safe_git_history_text(error.message, 200)}"
+      else
+        install_git_blame(buffer, snapshot)
+      end
+    end
+  end
+end