canopus 0.1.0

data/lib/canopus/git/repository.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Git
+    class Repository
+      attr_reader :root, :git_dir, :common_dir, :odb
+
+      def initialize(path)
+        directory = File.expand_path(path)
+        directory = File.dirname(directory) unless File.directory?(directory)
+        loop do
+          location = File.join(directory, ".git")
+          if File.directory?(location)
+            @root, @git_dir = directory, location
+            break
+          elsif File.file?(location)
+            value = File.read(location).strip
+            raise ArgumentError, "invalid gitdir file" unless value.start_with?("gitdir: ")
+            @root, @git_dir = directory, File.expand_path(value.delete_prefix("gitdir: "), directory)
+            break
+          elsif File.file?(File.join(directory, "HEAD")) && File.directory?(File.join(directory, "objects"))
+            @root, @git_dir = nil, directory
+            break
+          end
+          parent = File.dirname(directory)
+          raise ArgumentError, "not a Git repository: #{path}" if parent == directory
+          directory = parent
+        end
+        common = File.join(git_dir, "commondir")
+        @common_dir = File.file?(common) ? File.expand_path(File.read(common).strip, git_dir) : git_dir
+        config = File.join(common_dir, "config")
+        raise ArgumentError, "SHA-256 repositories are not supported" if File.file?(config) && File.read(config).match?(/objectformat\s*=\s*sha256/i)
+        @odb = ObjectDatabase.new(File.join(common_dir, "objects"))
+      end
+
+      def object(oid) = odb.read(resolve(oid) || oid)
+      def index = Index.new(File.join(git_dir, "index"))
+      def head = resolve("HEAD")
+
+      def branch
+        text = File.read(File.join(git_dir, "HEAD")).strip
+        text.start_with?("ref: refs/heads/") ? text.delete_prefix("ref: refs/heads/") : nil
+      end
+
+      def refs
+        result = {}
+        packed = File.join(common_dir, "packed-refs")
+        if File.file?(packed)
+          File.foreach(packed) do |line|
+            next if line.start_with?("#", "^")
+            oid, name = line.strip.split(" ", 2)
+            result[name] = oid if name && /\A[0-9a-f]{40}\z/.match?(oid)
+          end
+        end
+        Dir[File.join(common_dir, "refs", "**", "*")].sort.each do |path|
+          next unless File.file?(path)
+          name = path.delete_prefix(common_dir + "/")
+          result[name] = resolve(name)
+        end
+        result
+      end
+
+      def branches = refs.keys.grep(%r{\Arefs/heads/}).map { |ref| ref.delete_prefix("refs/heads/") }.sort
+
+      def resolve(name, seen = [])
+        return name if /\A[0-9a-f]{40}\z/.match?(name.to_s)
+        raise ArgumentError, "invalid Git reference" unless name.is_a?(String) && !name.empty? && !name.start_with?("/") && !name.split("/").any? { |piece| piece == ".." || piece.empty? } && !name.match?(/[\x00-\x20\\]/)
+        raise CorruptObject, "cyclic symbolic reference" if seen.include?(name) || seen.length > 32
+        candidates = name == "HEAD" || name.start_with?("refs/") ? [name] : ["refs/heads/#{name}", "refs/tags/#{name}", "refs/remotes/#{name}"]
+        candidates.each do |candidate|
+          directory = candidate == "HEAD" ? git_dir : common_dir
+          path = File.join(directory, candidate)
+          if File.file?(path)
+            value = File.read(path).strip
+            return resolve(value.delete_prefix("ref: "), seen + [name]) if value.start_with?("ref: ")
+            raise CorruptObject, "invalid reference #{candidate}" unless value.match?(/\A[0-9a-f]{40}\z/)
+            return value
+          end
+          packed = File.join(common_dir, "packed-refs")
+          next unless File.file?(packed)
+          File.foreach(packed) do |line|
+            oid, reference = line.strip.split(" ", 2)
+            return oid if reference == candidate && oid.match?(/\A[0-9a-f]{40}\z/)
+          end
+        end
+        nil
+      end
+
+      def commit(reference = "HEAD")
+        oid = resolve(reference)
+        return nil unless oid
+        seen = []
+        loop do
+          type, data = odb.read(oid)
+          if type == "tag"
+            raise CorruptObject, "cyclic annotated tag" if seen.include?(oid)
+            seen << oid
+            oid = data.lines.find { |line| line.start_with?("object ") }&.split&.last
+            next
+          end
+          raise ArgumentError, "reference is not a commit" unless type == "commit"
+          headers, message = data.split("\n\n", 2)
+          values = headers.lines.reject { |line| line.start_with?(" ") }.map { |line| line.chomp.split(" ", 2) }
+          return Commit.new(oid: oid, tree: values.assoc("tree")&.last,
+            parents: values.select { |key, _| key == "parent" }.map(&:last),
+            author: values.assoc("author")&.last, committer: values.assoc("committer")&.last,
+            message: message.to_s.force_encoding(Encoding::UTF_8))
+        end
+      end
+
+      def tree(reference = "HEAD")
+        revision = commit(reference)
+        revision ? read_tree(revision.tree) : {}
+      end
+
+      def blob(path, reference: "HEAD")
+        entry = tree(reference)[path]
+        entry && entry.mode != 0o160000 ? odb.read(entry.oid).last : nil
+      end
+
+      def status = Status.new(self).call
+      def blame(path, reference: "HEAD") = Blame.new(self).call(path, reference: reference)
+
+      def diff(path, staged: false, context: 3)
+        entry = index[path]
+        staged_content = entry ? odb.read(entry.oid).last : ""
+        before = staged ? blob(path).to_s : staged_content
+        after = staged ? staged_content : worktree_content(path).to_s
+        Diff.hunks(before, after, context: context)
+      end
+
+      def worktree_content(path)
+        absolute = worktree_path(path)
+        return File.readlink(absolute).b if File.symlink?(absolute)
+        File.file?(absolute) ? File.binread(absolute) : nil
+      end
+
+      def worktree_path(path, replacing: [])
+        raise ArgumentError, "bare repository has no worktree" unless root
+        raise ArgumentError, "unsafe worktree path" if path.empty? || path.start_with?("/") || path.split("/").any? { |part| ["..", ".git", ""].include?(part) }
+        absolute = File.expand_path(path, root)
+        raise ArgumentError, "path outside worktree" unless absolute.start_with?(root + "/")
+        parent = File.dirname(absolute)
+        while parent != root
+          raise ArgumentError, "worktree parent is a symlink" if File.symlink?(parent) && !replacing.include?(parent.delete_prefix(root + "/"))
+          parent = File.dirname(parent)
+        end
+        absolute
+      end
+
+      def revert_hunk(path, hunk)
+        absolute = worktree_path(path)
+        raise ArgumentError, "cannot revert a symlink hunk" if File.symlink?(absolute)
+        content = File.binread(absolute)
+        updated = Diff.revert(content, hunk)
+        atomic_write(absolute, updated, File.stat(absolute).mode & 0o777)
+        updated
+      end
+
+      # Checkout is deliberately limited to a clean index and tracked worktree.
+      # Untracked files are retained and any collision aborts before the first write.
+      def checkout(name)
+        raise ArgumentError, "unknown branch: #{name}" unless branches.include?(name)
+        raise ArgumentError, "worktree/index must be clean" if status.any? { |entry| entry.index != "?" }
+        target = tree("refs/heads/#{name}")
+        current = index.entries.to_h { |entry| [entry.path, entry] }
+        raise ArgumentError, "submodule checkout requires separate worktree handling" if (target.values + current.values).any? { |entry| entry.mode == 0o160000 }
+        removed = current.keys - target.keys
+        target.each_key do |path|
+          absolute = worktree_path(path, replacing: removed)
+          unless current.key?(path)
+            if File.directory?(absolute) && !File.symlink?(absolute)
+              Find.find(absolute) do |entry|
+                next if File.directory?(entry) && !File.symlink?(entry)
+                raise ArgumentError, "untracked checkout collision: #{path}" unless removed.include?(entry.delete_prefix(root + "/"))
+              end
+            elsif File.exist?(absolute) || File.symlink?(absolute)
+              raise ArgumentError, "untracked checkout collision: #{path}"
+            end
+          end
+          parent = File.dirname(absolute)
+          until parent == root
+            if (File.file?(parent) || File.symlink?(parent)) && !removed.include?(parent.delete_prefix(root + "/"))
+              raise ArgumentError, "untracked checkout collision: #{parent}"
+            end
+            parent = File.dirname(parent)
+          end
+        end
+        contents = target.to_h { |path, entry| [path, odb.read(entry.oid).last] }
+        backups = current.to_h { |path, entry| [path, [worktree_content(path), entry.mode]] }
+        backups.each do |path, (data, _)|
+          raise ArgumentError, "worktree changed before checkout: #{path}" unless data && ObjectDatabase.hash("blob", data) == current[path].oid
+        end
+        index_path = File.join(git_dir, "index")
+        head_path = File.join(git_dir, "HEAD")
+        old_index = File.binread(index_path) if File.exist?(index_path)
+        old_head = File.binread(head_path)
+        locks = []
+        changed = false
+        begin
+          [index_path, head_path].each { |path| locks << File.open(path + ".lock", File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o644) }
+          changed = true
+          removed.sort_by { |path| -path.count("/") }.each { |path| File.unlink(worktree_path(path)) }
+          prune_empty_directories(removed)
+          target.each do |path, entry|
+            absolute = worktree_path(path)
+            Dir.rmdir(absolute) if File.directory?(absolute) && !File.symlink?(absolute)
+            FileUtils.mkdir_p(File.dirname(absolute))
+            File.unlink(absolute) if File.symlink?(absolute)
+            if entry.mode == 0o120000
+              File.unlink(absolute) if File.exist?(absolute)
+              File.symlink(contents[path], absolute)
+            else
+              atomic_write(absolute, contents[path], entry.mode & 0o777)
+            end
+          end
+          entries = target.map do |path, entry|
+            stat = File.lstat(worktree_path(path))
+            Index::Entry.new(path: path, oid: entry.oid, mode: entry.mode, size: stat.size,
+              mtime: stat.mtime.to_i, mtime_nsec: stat.mtime.nsec, ctime: stat.ctime.to_i, ctime_nsec: stat.ctime.nsec,
+              dev: stat.dev, ino: stat.ino, uid: stat.uid, gid: stat.gid, stage: 0)
+          end
+          locks[0].write(Index.encode(entries))
+          locks[1].write("ref: refs/heads/#{name}\n")
+          locks.each { |file| file.flush; file.fsync; file.close }
+          File.rename(index_path + ".lock", index_path)
+          File.rename(head_path + ".lock", head_path)
+        rescue StandardError
+          if changed
+            (target.keys - current.keys).each do |path|
+              absolute = worktree_path(path)
+              File.unlink(absolute) if File.file?(absolute) || File.symlink?(absolute)
+            end
+            prune_empty_directories(target.keys - current.keys)
+            backups.each do |path, (data, mode)|
+              absolute = worktree_path(path)
+              Dir.rmdir(absolute) if File.directory?(absolute) && !File.symlink?(absolute)
+              FileUtils.mkdir_p(File.dirname(absolute))
+              File.unlink(absolute) if File.symlink?(absolute)
+              if mode == 0o120000
+                File.unlink(absolute) if File.exist?(absolute)
+                File.symlink(data, absolute)
+              else
+                atomic_write(absolute, data, mode & 0o777)
+              end
+            end
+            old_index ? atomic_write(index_path, old_index, 0o644) : File.unlink(index_path) if old_index || File.exist?(index_path)
+            atomic_write(head_path, old_head, 0o644)
+          end
+          raise
+        ensure
+          locks.each do |file|
+            file.close unless file.closed?
+            File.unlink(file.path) if File.exist?(file.path)
+          end
+        end
+        name
+      end
+
+      private
+
+      def prune_empty_directories(paths)
+        paths.sort_by { |path| -path.count("/") }.each do |path|
+          parent = File.dirname(File.join(root, path))
+          until parent == root
+            begin
+              Dir.rmdir(parent)
+            rescue Errno::ENOTEMPTY, Errno::EEXIST, Errno::ENOENT, Errno::ENOTDIR
+              break
+            end
+            parent = File.dirname(parent)
+          end
+        end
+      end
+
+      def atomic_write(path, data, mode)
+        Tempfile.create([".canopus-", ".tmp"], File.dirname(path)) do |file|
+          file.binmode
+          file.chmod(mode)
+          file.write(data)
+          file.flush
+          file.fsync
+          file.close
+          File.rename(file.path, path)
+        end
+      end
+
+      def read_tree(oid, prefix = "", stack = [])
+        raise CorruptObject, "tree nesting exceeds limit" if stack.length > 256 || stack.include?(oid)
+        type, data = odb.read(oid)
+        raise CorruptObject, "expected tree object" unless type == "tree"
+        result = {}
+        offset = 0
+        while offset < data.bytesize
+          ending = data.index("\0", offset)
+          raise CorruptObject, "truncated tree entry" unless ending && ending + 21 <= data.bytesize
+          mode, name = data[offset...ending].split(" ", 2)
+          raise CorruptObject, "unsafe tree entry" unless mode&.match?(/\A[0-7]+\z/) && name && !["", ".", "..", ".git"].include?(name) && !name.include?("/")
+          path = (prefix + name).force_encoding(Encoding::UTF_8)
+          object = data[ending + 1, 20].unpack1("H*")
+          mode = mode.to_i(8)
+          if mode == 0o40000
+            result.merge!(read_tree(object, path + "/", stack + [oid]))
+          else
+            result[path] = TreeEntry.new(path: path, oid: object, mode: mode)
+          end
+          offset = ending + 21
+        end
+        result
+      end
+    end
+  end
+end

data/lib/canopus/git/status.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Git
+    class Status
+      Entry = Struct.new(:path, :index, :worktree, keyword_init: true) do
+        def code = index + worktree
+      end
+
+      def initialize(repository)
+        @repository = repository
+      end
+
+      def call
+        repository = @repository
+        index = repository.index
+        head = repository.tree
+        tracked = index.entries.group_by(&:path)
+        result = []
+        (head.keys | tracked.keys).sort.each do |path|
+          entries = tracked[path]
+          if entries&.any? { |entry| entry.stage != 0 }
+            stages = entries.map(&:stage)
+            code = {[1] => "DD", [2] => "AU", [3] => "UA", [1, 2] => "UD", [1, 3] => "DU", [2, 3] => "AA", [1, 2, 3] => "UU"}.fetch(stages.sort, "UU")
+            result << Entry.new(path: path, index: code[0], worktree: code[1])
+            next
+          end
+          staged = entries&.first
+          original = head[path]
+          x = if !original then "A"
+          elsif !staged then "D"
+          elsif original.mode != staged.mode || original.oid != staged.oid then "M"
+          else " " end
+          y = staged ? worktree_status(staged, index.path) : " "
+          result << Entry.new(path: path, index: x, worktree: y) unless x == " " && y == " "
+        end
+        submodules = index.entries.select { |entry| entry.mode == 0o160000 }.map { |entry| entry.path + "/" }
+        Project.new(repository.root).files(include_symlinks: true).each do |path|
+          next if submodules.any? { |prefix| path.start_with?(prefix) }
+          result << Entry.new(path: path, index: "?", worktree: "?") unless tracked.key?(path)
+        end
+        result.sort_by(&:path)
+      end
+
+      private
+
+      def worktree_status(entry, index_path)
+        absolute = @repository.worktree_path(entry.path)
+        stat = File.lstat(absolute)
+        if entry.mode == 0o160000
+          return "T" unless stat.directory?
+          begin
+            return Repository.new(absolute).head == entry.oid ? " " : "M"
+          rescue ArgumentError
+            return "M"
+          end
+        end
+        mode = stat.symlink? ? 0o120000 : stat.file? ? 0o100000 | ((stat.mode & 0o100).positive? ? 0o755 : 0o644) : 0
+        return "T" if (mode & 0o170000) != (entry.mode & 0o170000)
+        return "M" if mode != entry.mode
+        return " " if (entry.extended_flags.to_i & 0x4000).positive? # skip-worktree
+        index_time = File.mtime(index_path)
+        if stat.size == entry.size && stat.mtime.to_i == entry.mtime && stat.mtime.nsec == entry.mtime_nsec &&
+            stat.ctime.to_i == entry.ctime && stat.ctime.nsec == entry.ctime_nsec && stat.mtime.to_i < index_time.to_i
+          return " "
+        end
+        content = stat.symlink? ? File.readlink(absolute).b : File.binread(absolute)
+        ObjectDatabase.hash("blob", content) == entry.oid ? " " : "M"
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        (entry.extended_flags.to_i & 0x4000).positive? ? " " : "D"
+      end
+    end
+  end
+end

data/lib/canopus/git/tree_entry.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Canopus
+  module Git
+    TreeEntry = Struct.new(:path, :oid, :mode, keyword_init: true)
+  end
+end

data/lib/canopus/git.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "find"
+require "tempfile"
+require_relative "project"
+require_relative "git/object_database"
+require_relative "git/index"
+require_relative "git/diff"
+require_relative "git/status"
+require_relative "git/blame"
+require_relative "git/commit"
+require_relative "git/tree_entry"
+
+require_relative "git/repository"

data/lib/canopus/icon_theme.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Canopus
+  # Theme JSON maps file/directory/expanded_directory and extensions to local SVGs.
+  class IconTheme
+    FILE = '<svg viewBox="0 0 16 16"><path d="M3 1h6l4 4v10H3z M9 1v4h4" fill="none" stroke="currentColor" stroke-linejoin="round"/></svg>'
+    FOLDER = '<svg viewBox="0 0 16 16"><path d="M1 4V2h5l2 2h7v10H1z" fill="none" stroke="currentColor" stroke-linejoin="round"/></svg>'
+    def initialize(path = nil)
+      @icons, @extensions = {}, {}
+      if path
+        raise Error, "icon theme exceeds 256 KiB" if File.size(path) > 262_144
+        document = Kochab.parse(File.read(path))
+        raise Error, "invalid icon theme" unless document.valid? && document.value.is_a?(Hash)
+        @root, @definition = File.realpath(File.dirname(path)), document.value
+        @extensions = @definition.fetch("extensions", {})
+        raise Error, "icon extensions must be a map with at most 256 entries" unless @extensions.is_a?(Hash) && @extensions.length <= 256
+        paths = @definition.values_at("file", "directory", "expanded_directory").compact + @extensions.values
+        paths.uniq.each { |value| load_icon(value) }
+      else
+        @definition = {}
+      end
+      @icons[:file] = Zaniah::SVG.new(FILE)
+      @icons[:directory] = Zaniah::SVG.new(FOLDER)
+    end
+    def texture(path, directory: false, expanded: false, size: 16, scale: 1, color: "#999")
+      key = if directory
+        @definition[expanded ? "expanded_directory" : "directory"] || @definition["directory"] || :directory
+      else
+        @extensions[File.extname(path)] || @extensions[File.basename(path)] || @definition["file"] || :file
+      end
+      pixels = (size * scale).ceil
+      @icons.fetch(key).texture(width: pixels, height: pixels, color: color)
+    end
+    private
+    def load_icon(relative)
+      raise Error, "icon filename must be a string" unless relative.is_a?(String)
+      full = File.realpath(File.expand_path(relative, @root))
+      raise Error, "icon must remain inside the theme directory" unless full.start_with?(@root + File::SEPARATOR)
+      raise Error, "icon exceeds 2 MiB" if File.size(full) > 2_097_152
+      @icons[relative] = Zaniah::SVG.open(full)
+    end
+  end
+end

data/lib/canopus/language/background_analysis/job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Canopus::Language::BackgroundAnalysis::Job
+  attr_accessor :future, :inner
+  def cancel
+    @cancelled = true
+    @inner&.cancel
+  end
+  def check!
+    raise Zaniah::Task::Cancelled, "superseded language analysis" if @cancelled
+  end
+end

data/lib/canopus/language/background_analysis/scheduler.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# Two preparation threads and two named-handler processes are shared by
+# all documents. No unbounded per-document threads or queued snapshots.
+class Canopus::Language::BackgroundAnalysis::Scheduler
+  BackgroundAnalysis = Canopus::Language.const_get(:BackgroundAnalysis, false)
+  private_constant :BackgroundAnalysis
+
+  @lock = Mutex.new
+  class << self
+    def acquire
+      @lock.synchronize do
+        @shared ||= new
+        @owners = (@owners || 0) + 1
+        @shared
+      end
+    end
+    def release(scheduler)
+      close = @lock.synchronize do
+        next false unless @shared.equal?(scheduler)
+        @owners -= 1
+        if @owners.zero?
+          @shared = nil
+          true
+        end
+      end
+      scheduler.shutdown if close
+    end
+  end
+
+  def initialize
+    @executor = Zaniah::TaskExecutor.new(workers: 2)
+    @lock, @pool_lock, @jobs = Mutex.new, Mutex.new, []
+  end
+  def submit(snapshot, prior_syntax: nil)
+    job = @lock.synchronize do
+      return if @closed || @jobs.length >= 2
+      BackgroundAnalysis::Job.new.tap { |value| @jobs << value }
+    end
+    job.future = @executor.background do
+      begin
+        job.check!
+        payload = BackgroundAnalysis.prepare(snapshot, job)
+        job.check!
+        pool = @pool_lock.synchronize do
+          job.check!
+          @pool ||= Zaniah::ProcessPool.new(workers: 2,
+            handler: "Canopus::Language::SyntaxWorker",
+            requires: [File.expand_path("../syntax_worker.rb", __dir__)],
+            load_paths: [File.expand_path("..", __dir__)], max_pending: 4, max_bytes: 16 << 20)
+        end
+        job.inner = pool.submit(payload)
+        job.check!
+        response = job.inner.await(timeout: 5)
+        job.check!
+        BackgroundAnalysis.decode(response, prior_syntax: prior_syntax)
+      ensure
+        job.inner&.cancel unless job.inner&.done?
+        @lock.synchronize { @jobs.delete(job) }
+      end
+    end
+    job
+  end
+  def shutdown
+    @lock.synchronize { @closed = true; @jobs.each(&:cancel) }
+    @pool_lock.synchronize { @pool&.shutdown }
+  ensure
+    @executor.shutdown
+  end
+end