canopus 0.1.0

data/lib/canopus/workspace/edit/plan.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "set"
+require_relative "../edit"
+require_relative "node"
+require_relative "resource_preparable"
+require_relative "executable"
+
+module Canopus
+  module Workspace::Edit
+    # Resource edits are uncommon and explicitly confirmed. No filesystem mutation
+    # happens until every ordered resource/text operation has passed preflight.
+    class Plan
+      include ResourcePreparable
+      include Executable
+
+      def initialize(workspace, edit)
+        @workspace, @root = workspace, workspace.root
+        @nodes, @observed, @originals = {}, {}, {}
+        @operations, @new_buffers, @recoveries, @journal = [], [], [], []
+        @text_bytes = @edit_count = 0
+        changes = edit.fetch("documentChanges")
+        raise Error, "invalid documentChanges" unless changes.is_a?(Array) && changes.length <= 10_000
+        changes.each_with_index do |change, index|
+          @failed_change = index
+          raise Error, "invalid workspace change" unless change.is_a?(Hash)
+          change["kind"] ? prepare_resource(change, index) : prepare_text(change, index)
+        end
+        @failed_change = nil
+      rescue StandardError
+        close
+        raise
+      end
+
+      def close
+        @new_buffers.each { |buffer| buffer.close unless @workspace.buffers.value?(buffer) }
+      end
+
+      private
+
+      def local_path(uri)
+        raise Error, "resource URI is too long" unless uri.is_a?(String) && uri.bytesize <= 16_384
+        path = File.expand_path(LSP::Protocol.path(uri))
+        raise Error, "resource path is too long" if path.bytesize > 4_096
+        unless path.start_with?(@root + File::SEPARATOR)
+          parent, pieces = File.dirname(path), [File.basename(path)]
+          until File.directory?(parent)
+            pieces.unshift(File.basename(parent))
+            parent = File.dirname(parent)
+          end
+          path = File.join(File.realpath(parent), *pieces)
+        end
+        raise Error, "language server resource is outside project" unless path.start_with?(@root + File::SEPARATOR)
+        pieces = path.delete_prefix(@root + File::SEPARATOR).split(File::SEPARATOR)
+        raise Error, "language server cannot modify Git metadata or recovery files" if protected_path?(path)
+        parent = @root
+        pieces[0...-1].each do |piece|
+          parent = File.join(parent, piece)
+          node = node_at(parent)
+          raise Error, "resource parent does not exist or follows a symlink" unless node&.exists && node.kind == :directory
+        end
+        path
+      end
+
+      def protected_path?(path)
+        pieces = path.delete_prefix(@root + File::SEPARATOR).split(File::SEPARATOR).map(&:downcase)
+        pieces.include?(".git") || pieces.each_cons(2).any? { |pair| pair == %w[.canopus trash] }
+      end
+
+      def node_at(path)
+        return @nodes[path] if @nodes.key?(path)
+        raise Error, "workspace edit exceeds 100000 filesystem entries" if @nodes.length >= 100_000
+        stat = File.lstat(path) rescue nil
+        buffer = @workspace.buffers[path]
+        @observed[path] = fingerprint(path)
+        return @nodes[path] = nil unless stat || buffer
+        kind = if stat&.symlink? then :symlink
+        elsif stat&.directory? then :directory
+        elsif !stat || stat.file? then :file
+        else :special
+        end
+        raise Error, "special files are not workspace edit targets" if kind == :special
+        @nodes[path] = Node.new(origin: stat && path, path: path, kind: kind, exists: !!stat, buffer: buffer, edits: [])
+      end
+
+      def fingerprint(path)
+        stat = File.lstat(path)
+        [stat.dev, stat.ino, stat.mode, stat.size, stat.mtime, stat.ctime]
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+
+      def subtree(path)
+        first = node_at(path)
+        return [] unless first
+        pending, result, seen = [first], [], {}
+        until pending.empty?
+          node = pending.pop
+          next if seen[node.object_id]
+          seen[node.object_id] = true
+          result << node
+          raise Error, "resource operation exceeds 100000 entries" if result.length > 100_000
+          if node.kind == :directory && node.origin
+            Dir.children(node.origin).each do |name|
+              child_path = File.join(node.path, name)
+              raise Error, "resource operation includes protected metadata" if protected_path?(child_path)
+              unless @nodes.key?(child_path)
+                origin = File.join(node.origin, name)
+                child = node_at(origin)
+                @nodes[child_path] = child
+                child.path = child_path if child
+              end
+              pending << @nodes[child_path] if @nodes[child_path]
+            end
+          end
+        end
+        # Include unsaved documents under a directory even if they have no disk entry.
+        @workspace.buffers.keys.grep(String).each do |candidate|
+          next unless candidate.start_with?(path + File::SEPARATOR)
+          node = node_at(candidate)
+          result << node if node && !seen[node.object_id]
+          seen[node.object_id] = true if node
+        end
+        @nodes.each_value do |node|
+          next unless node && node.path.start_with?(path + File::SEPARATOR) && !seen[node.object_id]
+          result << node
+          seen[node.object_id] = true
+        end
+        result
+      end
+
+      def buffer_for(node)
+        return node.buffer if node.rope
+        unless node.buffer
+          node.buffer = node.origin ? Buffer.open(node.origin) : Buffer.new("", path: node.path)
+          @new_buffers << node.buffer
+        end
+        buffer = node.buffer
+        @originals[buffer] ||= [buffer.rope, buffer.version, buffer.path]
+        node.rope, node.version = buffer.rope, buffer.version
+        buffer
+      end
+
+      def prepare_text(change, index)
+        document, edits = change.values_at("textDocument", "edits")
+        raise Error, "invalid text document edit" unless document.is_a?(Hash) && edits.is_a?(Array)
+        path = local_path(document.fetch("uri"))
+        node = node_at(path)
+        raise Error, "text edit target does not exist or is a symlink" unless node && node.kind == :file
+        buffer = buffer_for(node)
+        raise Error, "cannot edit a read-only document" if buffer.read_only
+        version = document["version"]
+        raise Error, "language server edit has stale document version" unless version.nil? || (version.is_a?(Integer) && version == node.version)
+        changes = edits.map do |entry|
+          unless entry.is_a?(Hash) && entry["range"].is_a?(Hash) && entry["newText"].is_a?(String) && entry["newText"].valid_encoding?
+            raise Error, "invalid LSP text edit"
+          end
+          @text_bytes += entry["newText"].bytesize
+          @edit_count += 1
+          raise Error, "workspace edit text exceeds safety limits" if @text_bytes > (32 << 20) || @edit_count > 100_000
+          range = entry.fetch("range")
+          [LSP::Protocol.offset(node.rope, range.fetch("start"))...LSP::Protocol.offset(node.rope, range.fetch("end")), entry.fetch("newText")]
+        end
+        node.rope = node.rope.apply_edits(changes)
+        node.version += 1 unless changes.empty?
+        node.edits << [changes, index] unless changes.empty?
+      end
+    end
+  end
+end

data/lib/canopus/workspace/edit/resource_preparable.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::Edit
+    module ResourcePreparable
+      private
+
+      def prepare_resource(change, index)
+        options = change.fetch("options", {})
+        unless options.is_a?(Hash) && options.values.all? { |value| value == true || value == false }
+          raise Error, "invalid resource operation options"
+        end
+        case change["kind"]
+        when "create" then prepare_create(change, options, index)
+        when "rename" then prepare_rename(change, options, index)
+        when "delete" then prepare_delete(change, options, index)
+        else raise Error, "unknown resource operation"
+        end
+      end
+
+      def protect_buffers(nodes, destination: false)
+        nodes.each do |node|
+          buffer = node.buffer
+          @originals[buffer] ||= [buffer.rope, buffer.version, buffer.path] if buffer
+          raise Error, "save or discard changes before deleting or overwriting a resource" if !node.edits.empty? || buffer&.dirty? || buffer&.read_only
+          raise Error, "close the destination document before overwriting it" if destination && buffer
+          if buffer && @workspace.buffers.values.grep(MultiBuffer).any? { |multi| multi.excerpts.any? { |excerpt| excerpt.buffer.equal?(buffer) } }
+            raise Error, "close excerpt views before deleting a source resource"
+          end
+        end
+      end
+
+      def prepare_create(change, options, index)
+        path = local_path(change.fetch("uri"))
+        previous = node_at(path)
+        return if previous&.exists && options["ignoreIfExists"] && !options["overwrite"]
+        raise Error, "resource already exists" if previous&.exists && !options["overwrite"]
+        raise Error, "cannot replace a directory or symlink with a file" if previous&.exists && previous.kind != :file
+        protect_buffers([previous].compact)
+        # A trailing slash explicitly denotes a directory URI.
+        kind = change.fetch("uri").end_with?("/") ? :directory : :file
+        raise Error, "cannot replace a file with a directory" if kind == :directory && previous&.exists
+        node = Node.new(path: path, kind: kind, exists: true, buffer: previous&.buffer, edits: [])
+        if node.buffer
+          buffer_for(node)
+          node.reset = true
+          node.version += 1 unless node.rope.empty?
+          node.rope = Denebola::Rope.new("")
+        end
+        @nodes[path] = node
+        @operations << {kind: :create, path: path, directory: kind == :directory, backup: !!previous&.exists, index: index}
+      end
+
+      def prepare_rename(change, options, index)
+        source, target = local_path(change.fetch("oldUri")), local_path(change.fetch("newUri"))
+        node = node_at(source)
+        raise Error, "rename source does not exist" unless node&.exists
+        if source == target || target.start_with?(source + File::SEPARATOR) || source.start_with?(target + File::SEPARATOR)
+          raise Error, "cannot move a resource into itself or overwrite its ancestor"
+        end
+        previous = node_at(target)
+        return if previous&.exists && options["ignoreIfExists"] && !options["overwrite"]
+        raise Error, "rename destination exists" if previous&.exists && !options["overwrite"]
+        destination_nodes = subtree(target)
+        protect_buffers(destination_nodes, destination: true)
+        moving = subtree(source)
+        moving.each do |entry|
+          buffer_for(entry) if entry.buffer
+          destination = target + entry.path.delete_prefix(source)
+          other = @nodes[destination] || @workspace.buffers[destination]
+          raise Error, "rename destination has an open document" if other && !destination_nodes.include?(other) && !moving.include?(other)
+        end
+        destination_nodes.each { |entry| @nodes[entry.path] = nil }
+        moving.each do |entry|
+          old = entry.path
+          entry.path = target + old.delete_prefix(source)
+          @nodes[old] = nil
+          @nodes[entry.path] = entry
+        end
+        @operations << {kind: :rename, source: source, path: target, backup: !!previous&.exists, index: index}
+      end
+
+      def prepare_delete(change, options, index)
+        path = local_path(change.fetch("uri"))
+        node = node_at(path)
+        return if !node&.exists && options["ignoreIfNotExists"]
+        raise Error, "delete target does not exist" unless node&.exists
+        removed = subtree(path)
+        if node.kind == :directory && removed.any? { |entry| entry != node && entry.exists } && !options["recursive"]
+          raise Error, "recursive deletion must be explicit for nonempty directories"
+        end
+        protect_buffers(removed)
+        removed.each { |entry| @nodes[entry.path] = nil }
+        @operations << {kind: :delete, path: path, nodes: removed, index: index}
+      end
+    end
+  end
+end

data/lib/canopus/workspace/edit.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::Edit
+  end
+end

data/lib/canopus/workspace/file_change_aware.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::FileChangeAware
+    def start_watching
+      return if @watcher || !@project
+      native = begin
+        Zaniah::Platform.watch(@root)
+      rescue LoadError, Zaniah::Error, SystemCallError
+        nil
+      end
+      @watcher = @project.watcher(native: native)
+      @last_watch = 0
+    end
+    def poll_changes
+      return unless @watcher
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      return if now - @last_watch < (@watcher.backend == :native ? 0.05 : 1.0)
+      @last_watch = now
+      events = @watcher.poll
+      invalidate_git unless events.empty?
+      refresh_files unless events.empty?
+      events.each do |event|
+        path = File.expand_path(event.path, @root)
+        buffer = @buffers[path]
+        next unless buffer
+        if event.type == :deleted
+          @message = "File was deleted on disk: #{event.path}"
+        elsif buffer.dirty?
+          @message = "File changed on disk; unsaved edits preserved: #{event.path}"
+        else
+          buffer.reload
+        end
+      rescue SaveConflict, SystemCallError, Error => error
+        @message = error.message
+      end
+      @window&.request_frame unless events.empty?
+    end
+  end
+end

data/lib/canopus/workspace/file_previewable.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::FilePreviewable
+    # A preview never creates a tab, loads a complete file, or changes selections.
+    def file_preview(path)
+      absolute = canonical_path(path)
+      buffer = @buffers[absolute]
+      stamp = buffer ? buffer.version : [File.mtime(absolute), File.size(absolute)]
+      key = [absolute, stamp]
+      @file_previews ||= {}
+      return @file_previews[key] if @file_previews.key?(key)
+      source = if buffer
+        ending = [16_384, buffer.rope.bytesize].min
+        begin
+          buffer.rope.byteslice(0, ending).to_s
+        rescue RangeError
+          ending -= 1
+          retry
+        end
+      else
+        File.binread(absolute, 16_384).force_encoding(Encoding::UTF_8).scrub
+      end
+      rows = source.include?("\0") ? ["Binary / UTF-16 preview unavailable"] : source.lines.first(40).map { |line| line.chomp[0, 300] }
+      @file_previews.shift if @file_previews.length >= 16
+      @file_previews[key] = rows.freeze
+    rescue SystemCallError, Error => error
+      ["Preview unavailable: #{error.message}"]
+    end
+  end
+end

data/lib/canopus/workspace/git_aware.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::GitAware
+    def git
+      return @git if defined?(@git)
+      @git = Git::Repository.new(@root)
+      @git = nil unless @git.root
+    rescue ArgumentError
+      @git = nil
+    end
+    def git_status
+      return @git_status if @git_status
+      return {} unless git
+      if @window
+        unless @git_status_job&.alive?
+          generation = @git_generation
+          @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
+          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] }
+      end
+    end
+    def invalidate_git
+      @git_generation = (@git_generation || 0) + 1
+      @git_status = @git_hunk_cache = nil
+      @panes.each do |pane|
+        pane.editors.each do |current|
+          current.display_map.block_map.blocks.values.each { |block| current.display_map.remove_block(block.id) if block.kind == :git_diff }
+        end
+      end
+      nil
+    end
+    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}"
+    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)
+      buffer.path.delete_prefix(git.root + File::SEPARATOR)
+    end
+    def git_hunks(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_hunk_cache ||= {}
+      key = [buffer.object_id, path, buffer.version, git.head]
+      @git_hunk_cache.clear if @git_hunk_cache.length > 20
+      return @git_hunk_cache[key] if @git_hunk_cache.key?(key)
+      if @window && async
+        @git_hunk_jobs ||= {}
+        unless @git_hunk_jobs[buffer]&.alive?
+          snapshot = buffer.rope
+          @git_hunk_jobs[buffer] = Thread.new do
+            before = Buffer.decode_bytes(git.blob(path, reference: key.last || "HEAD").to_s).first
+            hunks = Git::Diff.hunks(before, snapshot.to_s, context: 0)
+            post { (@git_hunk_cache ||= {})[key] = hunks } unless @closed
+          rescue StandardError => error
+            post { @message = "Git diff: #{error.message}" } unless @closed
+          end
+        end
+        []
+      else
+        before = Buffer.decode_bytes(git.blob(path).to_s).first
+        @git_hunk_cache[key] = Git::Diff.hunks(before, buffer.text, context: 0)
+      end
+    end
+    def show_git_diff
+      path = git_relative_path
+      before = Buffer.decode_bytes(git.blob(path).to_s).first
+      buffer = Buffer.new(Git::Diff.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/, [])
+    end
+    def toggle_git_hunk(current = editor, row: nil)
+      row ||= current.buffer.rope.point_at(current.primary.head).row
+      hunk = git_hunks(current.buffer, async: false).find do |item|
+        (row + 1).between?([item.new_start, 1].max, [item.new_start + item.new_count - 1, item.new_start].max)
+      end
+      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]
+      map = current.display_map
+      if map.block_map.blocks.key?(id)
+        map.remove_block(id)
+        expanded = false
+      else
+        # Keep inline previews bounded; the full diff remains available in its
+        # own document for large hunks and unusually long source lines.
+        lines = ["@@ -#{hunk.old_start},#{hunk.old_count} +#{hunk.new_start},#{hunk.new_count} @@"]
+        hunk.edits.first(200).each do |edit|
+          body = edit.text.delete_suffix("\n").delete_suffix("\r")
+          lines << "#{edit.kind == :delete ? '-' : edit.kind == :insert ? '+' : ' '}#{body.slice(0, 500)}#{body.length > 500 ? '…' : ''}"
+        end
+        lines << "… #{hunk.edits.length - 200} more lines; open git.diff for the full change" if hunk.edits.length > 200
+        map.insert_block(id, row: [hunk.new_start - 1, 0].max.clamp(0, current.buffer.line_count - 1), text: lines.join("\n"), kind: :git_diff)
+        expanded = true
+      end
+      @window&.request_frame
+      expanded
+    end
+    def show_git_blame
+      path = git_relative_path
+      lines = git.blame(path)
+      @hover_card = lines.map { |line| "#{line.commit.to_s[0, 8]} #{line.author} #{line.text}" }.join
+    end
+    def revert_current_hunk
+      row = editor.buffer.rope.point_at(editor.primary.head).row + 1
+      hunk = git_hunks(async: false).find { |item| row.between?([item.new_start, 1].max, [item.new_start + item.new_count - 1, item.new_start].max) }
+      raise Error, "No change at the cursor" unless hunk
+      replacement = Git::Diff.revert(editor.buffer.text, hunk)
+      editor.buffer.edit([[0...editor.buffer.rope.bytesize, replacement]], kind: :revert_hunk)
+    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)
+      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
+  end
+end