canopus 0.1.0

data/lib/canopus/workspace/project_searchable.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::ProjectSearchable
+    SearchSource = Data.define(:buffer, :version, :rope, :encoding, :bom, :digest, :line_ending, :dirty, :read_only)
+    SearchPreparation = Struct.new(:sources, :buffers, :editor, :count, :settings) do
+      def close
+        editor&.dispose
+        editor&.buffer&.close
+        buffers.each_value(&:close)
+      end
+    end
+    private_constant :SearchSource, :SearchPreparation
+
+    # Capture immutable open-buffer snapshots on the foreground. File IO,
+    # scanning and the complete private result Editor are prepared off-thread.
+    def search_project(query, regexp: false, case_sensitive: true, whole_word: false, async: true)
+      raise Error, "Workspace closed" if @closed
+      raise Error, "Search query cannot be empty" if query.empty?
+      expression = regexp ? query : Regexp.escape(query)
+      expression = "\\b(?:#{expression})\\b" if whole_word
+      pattern = Regexp.new(expression, case_sensitive ? 0 : Regexp::IGNORECASE, timeout: 0.25)
+      cancel_project_search
+      @message = "Searching project…" if async
+      prepare_project_search(pattern, @search_generation, search_sources, settings: search_editor_settings, async: async)
+    end
+
+    def cancel_project_search
+      prepared = (@search_prepare_lock ||= Mutex.new).synchronize do
+        @search_generation = (@search_generation || 0) + 1
+        saved, @search_prepared = @search_prepared, nil
+        saved
+      end
+      prepared&.close
+      nil
+    end
+
+    def replace_in_buffer(pattern, replacement, **options)
+      if editor.buffer.is_a?(MultiBuffer)
+        changes = editor.replacement_edits(pattern, replacement, **options).select do |range, _text|
+          editor.buffer.excerpts.any? { |excerpt| range.begin >= excerpt.view_start && range.end <= excerpt.view_end }
+        end
+        editor.edit(changes, kind: :replace_all)
+        changes.length
+      else
+        editor.replace_all(pattern, replacement, **options)
+      end
+    end
+
+    private
+
+    def search_sources
+      @buffers.values.each_with_object({}) do |buffer, sources|
+        path = buffer.path
+        next unless path&.start_with?(@root + File::SEPARATOR)
+        sources[path] = SearchSource.new(buffer, buffer.version, buffer.rope, buffer.encoding,
+          buffer.bom, buffer.disk_digest, buffer.line_ending, buffer.dirty?, buffer.read_only)
+      end.freeze
+    end
+
+    def search_cancelled?(generation) = @closed || generation != @search_generation
+
+    def search_editor_settings
+      settings = @settings.for_language("text")
+      [settings["tab_size"], settings["use_tabs"], settings["soft_wrap"]].freeze
+    end
+
+    def prepare_project_search(pattern, generation, sources, settings:, paths: nil, async: true)
+      work = lambda do
+        prepared = nil
+        paths ||= @project.search(pattern, workers: 4, limit: 10_000,
+          cancelled: -> { search_cancelled?(generation) }).map(&:path).uniq.freeze
+        next if search_cancelled?(generation)
+        prepared = build_search_preparation(pattern, generation, sources, paths, settings)
+        next unless prepared
+        if async
+          accepted = @search_prepare_lock.synchronize do
+            @search_prepared = prepared unless search_cancelled?(generation)
+          end
+          if accepted
+            prepared = nil # Queued callbacks must not retain disposed private buffers.
+            queue_search_install(pattern, generation, paths)
+          end
+        else
+          result = install_search_preparation(prepared, pattern, generation, paths, async: false)
+          prepared = nil
+          result
+        end
+      rescue StandardError => error
+        raise unless async
+        queue_search_error(generation, error.message)
+      ensure
+        prepared&.close
+      end
+      async ? @search_job = Thread.new(&work) : work.call
+    end
+
+    def build_search_preparation(pattern, generation, sources, paths, settings)
+      prepared = SearchPreparation.new(sources, {}, nil, 0, settings)
+      excerpts = []
+      candidates = paths.map { |relative| File.join(@root, relative) } | sources.keys
+      candidates.sort.each do |candidate|
+        return if search_cancelled?(generation)
+        path = sources.key?(candidate) ? candidate : File.realpath(candidate)
+        next unless path.start_with?(@root + File::SEPARATOR)
+        next if prepared.buffers.key?(path) # Canonical aliases share one source.
+        snapshot = sources[path]
+        next if snapshot && (snapshot.read_only || snapshot.rope.bytesize > 10 << 20)
+        next if !snapshot && File.size(path) > 10 << 20
+        buffer = if snapshot
+          # Nonempty text supplies the source's original line-ending metadata;
+          # rope: shares the immutable snapshot, without materializing its text.
+          Buffer.new(snapshot.line_ending, path: path, rope: snapshot.rope, encoding: snapshot.encoding,
+            bom: snapshot.bom, disk_digest: snapshot.digest, draft: snapshot.dirty)
+        else
+          Buffer.open(path)
+        end
+        prepared.buffers[path] = buffer
+        if buffer.read_only || buffer.rope.bytesize > 10 << 20
+          prepared.buffers.delete(path)
+          buffer.close
+          next
+        end
+        ranges, matches = search_excerpt_ranges(buffer.rope, pattern, 10_000 - prepared.count, generation)
+        return if search_cancelled?(generation)
+        prepared.count += matches
+        relative = path.delete_prefix(@root + File::SEPARATOR)
+        ranges.each { |range| excerpts << [buffer, range, "#{relative}:#{buffer.rope.point_at(range.begin).row + 1}"] }
+        break if prepared.count >= 10_000
+      rescue Errno::ENOENT, Errno::EACCES
+        next
+      end
+      projection = MultiBuffer.new(excerpts: excerpts)
+      return if search_cancelled?(generation)
+      prepared.editor = Editor.new(projection, tab_size: settings[0], wrap_width: settings[2] ? 100 : nil)
+      prepared.editor.use_tabs = settings[1]
+      result, prepared = prepared, nil
+      result
+    ensure
+      projection&.close if prepared && !prepared.editor
+      prepared&.close
+    end
+
+    def search_excerpt_ranges(rope, pattern, limit, generation)
+      ranges, count = [], 0
+      rope.to_s.to_enum(:scan, pattern).each do
+        break if search_cancelled?(generation)
+        match = Regexp.last_match
+        row, last_row = rope.point_at(match.bytebegin(0)).row, rope.point_at(match.byteend(0)).row
+        first = rope.line_start([row - 1, 0].max)
+        last = last_row + 2 < rope.line_count ? rope.line_start(last_row + 2) : rope.bytesize
+        ranges.last && first <= ranges.last.end ? ranges[-1] = ranges.last.begin...[ranges.last.end, last].max : ranges << (first...last)
+        count += 1
+        break if count >= limit
+      end
+      [ranges, count]
+    end
+
+    def queue_search_install(pattern, generation, paths)
+      post do
+        prepared = @search_prepare_lock.synchronize do
+          next if search_cancelled?(generation)
+          saved, @search_prepared = @search_prepared, nil
+          saved
+        end
+        install_search_preparation(prepared, pattern, generation, paths) if prepared
+      rescue StandardError => error
+        @message = error.message unless search_cancelled?(generation)
+      end
+    end
+
+    def queue_search_error(generation, message)
+      post { @message = message unless search_cancelled?(generation) }
+    end
+
+    def install_search_preparation(prepared, pattern, generation, paths, async: true)
+      return if search_cancelled?(generation)
+      current = search_sources
+      settings = search_editor_settings
+      unchanged = settings == prepared.settings && current.keys == prepared.sources.keys && current.all? do |path, source|
+        before = prepared.sources.fetch(path)
+        source.buffer.equal?(before.buffer) && source.version == before.version && source.rope.equal?(before.rope) && source.read_only == before.read_only
+      end
+      unless unchanged
+        prepared.close
+        prepared = nil
+        return prepare_project_search(pattern, generation, current, settings: settings, paths: paths, async: async)
+      end
+      projection = prepared.editor.buffer
+      bound = prepared.sources.empty? ? {} : projection.excerpts.to_h { |excerpt| [excerpt.buffer, true] }
+      replacements = prepared.sources.each_with_object({}) do |(path, source), result|
+        clone = prepared.buffers[path]
+        result[clone] = source.buffer if clone && bound.key?(clone)
+      end
+      projection.attach_sources(replacements)
+      prepared.buffers.each { |path, buffer| @buffers[path] ||= buffer unless prepared.sources.key?(path) }
+      @buffers[projection.object_id] = projection
+      @active_pane.editors << prepared.editor
+      @active_pane.activate(@active_pane.editors.length - 1)
+      @message = "#{prepared.count} matches — edit excerpts, then Save to save source files"
+      @window&.request_frame
+      prepared = nil
+      projection
+    ensure
+      prepared&.close
+    end
+  end
+end

data/lib/canopus/workspace/project_tree_editable.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Canopus
+  module Workspace::ProjectTreeEditable
+    def project_tree
+      files
+      @project_tree ||= Project::Tree.new(@project_entries || [], expanded: @expanded_directories ||= Set.new).tap do |tree|
+        tree.reveal(editor.buffer.path.delete_prefix(@root + File::SEPARATOR)) if editor&.buffer&.path
+      end
+    end
+    def project_path(relative)
+      path = @project.path(relative)
+      parent = path
+      parent = File.dirname(parent) until File.exist?(parent) || File.symlink?(parent)
+      actual = File.realpath(parent)
+      raise Error, "project operation follows a symlink outside the project" unless actual == @root || actual.start_with?(@root + File::SEPARATOR)
+      raise Error, "cannot modify project root or Git metadata" if path == @root || path.delete_prefix(@root + "/").split("/").include?(".git")
+      path
+    end
+    def create_project_entry(relative, directory: false)
+      path = project_path(relative)
+      raise Error, "path already exists" if File.exist?(path) || File.symlink?(path)
+      directory ? Dir.mkdir(path) : File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0o644, &:close)
+      refresh_files
+      open(path) unless directory
+      path
+    end
+    def rename_project_entry(relative, destination)
+      source, target = project_path(relative), project_path(destination)
+      raise Error, "source does not exist" unless File.exist?(source) || File.symlink?(source)
+      raise Error, "destination exists" if File.exist?(target) || File.symlink?(target)
+      raise Error, "cannot move a directory inside itself" if target.start_with?(source + File::SEPARATOR)
+      if @buffers.values.any? { |buffer| buffer.path && (buffer.path == target || buffer.path.start_with?(target + File::SEPARATOR)) }
+        raise Error, "destination is open in another buffer"
+      end
+      File.rename(source, target)
+      invalidate_git
+      @buffers.keys.grep(String).each do |old|
+        next unless old == source || old.start_with?(source + File::SEPARATOR)
+        buffer = @buffers.delete(old)
+        new_path = target + old.delete_prefix(source)
+        begin
+          close_language_documents(buffer)
+        rescue StandardError => error
+          @message = "Path moved; language server close failed: #{error.message}"
+          @opened_lsp_documents&.delete_if { |(_, document), _| document.equal?(buffer) }
+        end
+        buffer.relocate(new_path)
+        @buffers[new_path] = buffer
+        @panes.each do |pane|
+          pane.editors.each do |current|
+            next unless current.buffer.equal?(buffer)
+            current.language = definition_for(new_path)
+            apply_editor_settings(current)
+          end
+        end
+      end
+      refresh_files
+      target
+    end
+    # Deletion is recoverable and never follows directory symlinks.
+    def trash_project_entry(relative)
+      source = @project.path(relative)
+      raise Error, "cannot trash project root or Git metadata" if source == @root || relative.split("/").include?(".git")
+      raise Error, "cannot trash the recovery directory" if source == @project.path(".canopus") || source == @project.path(".canopus/trash")
+      affected = @buffers.values.select { |buffer| buffer.path && (buffer.path == source || buffer.path.start_with?(source + File::SEPARATOR)) }
+      raise Error, "save or discard changes before deleting this path" if affected.any?(&:dirty?)
+      parent = File.realpath(File.dirname(source))
+      raise Error, "path outside project" unless parent == @root || parent.start_with?(@root + File::SEPARATOR)
+      trash = @project.path(".canopus/trash")
+      project_path(".canopus/trash")
+      FileUtils.mkdir_p(trash)
+      destination = File.join(trash, "#{Time.now.utc.strftime('%Y%m%dT%H%M%S')}-#{SecureRandom.hex(4)}-#{File.basename(source)}")
+      File.rename(source, destination)
+      @message = "Moved to #{destination}; recoverable by moving it back"
+      refresh_files
+      destination
+    end
+  end
+end

data/lib/canopus/workspace/session_persistable.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::SessionPersistable
+    def save_session(path)
+      records = {}
+      record = lambda do |buffer|
+        id = buffer.object_id.to_s
+        return id if records.key?(id)
+        records[id] = if buffer.is_a?(MultiBuffer)
+          {excerpts: buffer.excerpts.map do |excerpt|
+            {buffer: record.call(excerpt.buffer), first: excerpt.buffer.resolve(excerpt.first),
+              last: excerpt.buffer.resolve(excerpt.last), title: excerpt.title}
+          end}
+        else
+          {path: buffer.path, draft: buffer.dirty? || !buffer.path ? buffer.text : nil,
+            digest: buffer.disk_digest, encoding: buffer.encoding.name, bom: buffer.bom.unpack1("H*"), read_only: buffer.read_only}
+        end
+        id
+      end
+      state = {version: 2, root: @root, layout: encode_layout(@layout), recent_files: @recent_files || [],
+        active_pane: @panes.index(@active_pane), docks: @docks,
+        panes: @panes.map do |pane|
+          {active: pane.active_index, tabs: pane.editors.map do |current|
+            {buffer_id: record.call(current.buffer), cursor: current.primary.head, pinned: pane.pinned.include?(current),
+              selections: current.selections.map { |selection| {anchor: selection.anchor, head: selection.head} },
+              scroll_x: current.scroll_x, scroll_y: current.scroll_y}
+          end}
+        end, buffers: records}
+      state[:background_buffers] = @buffers.values.select(&:dirty?).map { |buffer| record.call(buffer) }
+      FileUtils.mkdir_p(File.dirname(path))
+      Tempfile.create([".session-", ".json"], File.dirname(path)) do |file|
+        file.write(JSON.pretty_generate(state))
+        file.flush
+        file.fsync
+        file.close
+        File.rename(file.path, path)
+      end
+    end
+
+    def restore_session(path)
+      data = JSON.parse(File.read(path))
+      raise Error, "unsupported session" unless [1, 2].include?(data["version"]) && data["panes"].is_a?(Array) && data["panes"].length.between?(1, 100)
+      records = data.fetch("buffers", {})
+      raise Error, "invalid session buffers" unless records.is_a?(Hash) && records.length <= 10_000
+      loaded, restored_buffers, restored_panes = {}, {}, []
+      load_buffer = lambda do |id|
+        return loaded[id] if loaded.key?(id)
+        entry = records.fetch(id)
+        raise Error, "invalid session buffer" unless entry.is_a?(Hash)
+        if entry["excerpts"]
+          excerpts = entry["excerpts"]
+          raise Error, "invalid session excerpts" unless excerpts.is_a?(Array) && excerpts.length <= 10_000
+          sources = excerpts.map do |excerpt|
+            source_id = excerpt.fetch("buffer")
+            raise Error, "nested or cyclic excerpt source" if records.fetch(source_id).key?("excerpts")
+            source = load_buffer.call(source_id)
+            raise Error, "excerpt source no longer exists" unless source
+            first, last = excerpt.values_at("first", "last")
+            raise Error, "invalid excerpt range" unless first.is_a?(Integer) && last.is_a?(Integer) && first <= last
+            [source, first...last, excerpt["title"]]
+          end
+          buffer = MultiBuffer.new(excerpts: sources)
+        elsif entry["draft"]
+          buffer = Buffer.new(entry["draft"], path: entry["path"], draft: true, disk_digest: entry["digest"],
+            encoding: Encoding.find(entry.fetch("encoding", "UTF-8")), bom: [entry.fetch("bom", "")].pack("H*"), read_only: entry.fetch("read_only", false))
+        elsif entry["path"] && File.file?(entry["path"])
+          buffer = Buffer.open(entry["path"])
+        end
+        loaded[id] = buffer
+        if buffer
+          key = buffer.path ? canonical_path(buffer.path) : buffer.object_id
+          if restored_buffers.key?(key)
+            buffer.close
+            raise Error, "duplicate session buffer path"
+          end
+          restored_buffers[key] = buffer
+        end
+        buffer
+      end
+      data["panes"].each do |saved|
+        pane = Pane.new
+        restored_panes << pane
+        tabs = saved.fetch("tabs")
+        raise Error, "invalid session tabs" unless tabs.is_a?(Array) && tabs.length <= 1000
+        tabs.each do |tab|
+          if data["version"] == 1
+            tab["buffer_id"] = tab["path"] || "draft:#{tab.object_id}"
+            records[tab["buffer_id"]] ||= tab
+          end
+          buffer = load_buffer.call(tab.fetch("buffer_id"))
+          next unless buffer
+          current = pane.open(buffer)
+          current.language = definition_for(buffer.path)
+          apply_editor_settings(current)
+          if tab["selections"]
+            selections = tab["selections"]
+            raise Error, "invalid session selections" unless selections.is_a?(Array) && selections.length.between?(1, 10_000)
+            selections.each_with_index do |selection, index|
+              anchor, head = selection.values_at("anchor", "head")
+              raise Error, "invalid session cursor" unless anchor.is_a?(Integer) && head.is_a?(Integer)
+              current.select(anchor, head, add: index.positive?)
+            end
+          else
+            begin
+              current.select(tab.fetch("cursor", 0).clamp(0, buffer.rope.bytesize))
+            rescue RangeError
+              current.select(0)
+            end
+          end
+          coordinates = [tab.fetch("scroll_x", 0), tab.fetch("scroll_y", 0)]
+          raise Error, "invalid session scroll position" unless coordinates.all? { |value| value.is_a?(Numeric) && value.finite? && value >= 0 }
+          current.scroll(dx: coordinates.first, dy: coordinates.last)
+          pane.pin(current) if tab["pinned"]
+        end
+        pane.active_index = saved.fetch("active", 0).clamp(0, [pane.editors.length - 1, 0].max)
+      end
+      restored_layout = decode_layout(data.fetch("layout"), panes: restored_panes)
+      layout_panes, pending = [], [restored_layout]
+      until pending.empty?
+        node = pending.pop
+        node[:pane] ? layout_panes << node[:pane] : pending.concat(node[:children])
+      end
+      raise Error, "session layout must include each pane exactly once" unless layout_panes.length == restored_panes.length && layout_panes.uniq.length == restored_panes.length
+      background = data.fetch("background_buffers", [])
+      raise Error, "invalid background buffers" unless background.is_a?(Array) && background.length <= 10_000
+      background.each { |id| load_buffer.call(id) }
+      restored_docks = @docks.transform_values(&:dup)
+      data.fetch("docks", {}).each do |side, value|
+        next unless restored_docks.key?(side.to_sym)
+        raise Error, "invalid session dock" unless value.is_a?(Hash) && [true, false].include?(value["visible"]) && value["size"].is_a?(Numeric) && value["size"].finite? && value["size"].positive?
+        restored_docks[side.to_sym] = {visible: value["visible"], size: value["size"].clamp(40, 4000)}
+      end
+      active = data.fetch("active_pane", 0)
+      raise Error, "invalid active pane" unless active.is_a?(Integer) && active.between?(0, restored_panes.length - 1)
+      clear_vim_states
+      close_language_documents
+      @panes.each { |pane| pane.editors.each(&:dispose) }
+      @buffers.each_value(&:close)
+      @panes, @buffers, @layout, @docks = restored_panes, restored_buffers, restored_layout, restored_docks
+      @active_pane = @panes[active]
+      @recent_files = Array(data["recent_files"]).select { |item| item.is_a?(String) && File.file?(item) }.first(100)
+      new_buffer unless editor
+      self
+    rescue StandardError
+      unless @panes.equal?(restored_panes)
+        restored_panes&.each { |pane| pane.editors.each(&:dispose) }
+        restored_buffers&.each_value(&:close)
+      end
+      raise
+    end
+  end
+end

data/lib/canopus/workspace/settings_aware.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Workspace::SettingsAware
+    def icon_theme
+      require_relative "../icon_theme"
+      @icon_theme ||= IconTheme.new(@settings["icon_theme"] && File.expand_path(@settings["icon_theme"], @root))
+    end
+    def settings_path = File.join(@root, ".canopus", "settings.jsonc")
+    def open_settings
+      FileUtils.mkdir_p(File.dirname(settings_path))
+      current = open(settings_path)
+      current.buffer.edit([[0...0, "// Project settings override user settings.\n{\n  \"tab_size\": #{@settings['tab_size']}\n}\n"]], kind: :settings) if current.buffer.rope.empty?
+      @message = "Edit JSONC and save; Ctrl-Space completes setting names"
+      current
+    end
+    def settings_completions
+      raise Error, "Open a settings document first" unless settings_document?(editor.buffer)
+      self.palette = {kind: :settings_keys, query: +"", index: 0, matches: Settings::DEFAULTS.keys}
+    end
+    def settings_document?(buffer)
+      buffer.path && (buffer.path == settings_path || @settings.paths.any? { |path| File.expand_path(path) == buffer.path })
+    end
+    def configure_text_system(cache_dir: @window.text_system&.cache_dir)
+      database = Zaniah::TextSystem::FontDB.new
+      system = Zaniah::TextSystem::Renderer.new(font_db: database, font: database.find(family: @settings["font_family"]), cache_dir: cache_dir)
+      system.scale_factor = @window.scale_factor
+      old, @window.text_system = @window.text_system, system
+      old&.close
+      @applied_font_family = @settings["font_family"]
+      system
+    end
+    def apply_settings
+      servers = language_server_settings_plan
+      clear_vim_states unless @settings["vim_mode"]
+      name = @settings["theme"]
+      if name == "auto"
+        name = @window&.respond_to?(:appearance) && @window.appearance == :light ? "Canopus Light" : "Canopus Dark"
+      end
+      target_theme = File.file?(File.expand_path(name, @root)) ? Theme.load(File.expand_path(name, @root)) : Theme.new(name: name)
+      if @applied_icon_theme != @settings["icon_theme"]
+        require_relative "../icon_theme"
+        @icon_theme = IconTheme.new(@settings["icon_theme"] && File.expand_path(@settings["icon_theme"], @root))
+      end
+      @panes.each do |pane|
+        pane.editors.each do |current|
+          apply_editor_settings(current)
+        end
+      end
+      self.theme = target_theme
+      if @window&.text_system && !@window.is_a?(Zaniah::Platform::TUI::Window) && @applied_font_family != @settings["font_family"]
+        configure_text_system
+      end
+      @applied_font_family = @settings["font_family"]
+      @applied_icon_theme = @settings["icon_theme"]
+      reload_language_servers(servers)
+      @window&.request_frame
+    end
+    def poll_settings(force: false)
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      return if !force && @last_settings_poll && now - @last_settings_poll < 1
+      @last_settings_poll = now
+      state = @settings.paths.map do |path|
+        stat = File.stat(path)
+        [path, stat.mtime, stat.size, stat.ino]
+      rescue Errno::ENOENT
+        [path, nil]
+      end
+      return if state == @settings_state && !force
+      initial = !defined?(@settings_state)
+      @settings_state = state
+      return if initial && !force
+      replacement = @settings.reload
+      old, @settings = @settings, replacement
+      apply_settings
+      @message = "Settings reloaded"
+    rescue StandardError => error
+      @settings = old if old
+      @message = "Settings unchanged: #{error.message}"
+    end
+
+    private
+    def apply_editor_settings(current)
+      values = @settings.for_language(current.language_document.definition.name)
+      current.tab_size = values["tab_size"]
+      current.use_tabs = values["use_tabs"]
+      current.display_map.tab_size = current.tab_size
+      current.display_map.wrap_width = values["soft_wrap"] ? 100 : nil unless current.buffer.read_only
+    end
+  end
+end