canopus 0.1.0 → 0.2.0

data/lib/canopus/git/repository.rb

@@ -1,313 +0,0 @@
-# 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

@@ -1,74 +0,0 @@
-# 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

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

data/lib/canopus/git.rb

@@ -1,15 +0,0 @@
-# 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/sig/git.rbs

@@ -1,140 +0,0 @@
-module Canopus
-  module Git
-    type object = [String, String]
-    type lines = String | Array[String]
-    class CorruptObject < StandardError
-    end
-    class Commit < Struct[untyped]
-      attr_accessor oid: String
-      attr_accessor tree: String?
-      attr_accessor parents: Array[String]
-      attr_accessor author: String?
-      attr_accessor committer: String?
-      attr_accessor message: String
-      def self.new: (oid: String, ?tree: String?, parents: Array[String], ?author: String?, ?committer: String?, message: String) -> instance
-    end
-    class TreeEntry < Struct[untyped]
-      attr_accessor path: String
-      attr_accessor oid: String
-      attr_accessor mode: Integer
-      def self.new: (path: String, oid: String, mode: Integer) -> instance
-    end
-    class Repository
-      attr_reader root: String?
-      attr_reader git_dir: String
-      attr_reader common_dir: String
-      attr_reader odb: ObjectDatabase
-      def initialize: (String path) -> void
-      def object: (String oid) -> object
-      def index: () -> Index
-      def head: () -> String?
-      def branch: () -> String?
-      def refs: () -> Hash[String, String?]
-      def branches: () -> Array[String]
-      def resolve: (String name, ?Array[String] seen) -> String?
-      def commit: (?String reference) -> Commit?
-      def tree: (?String reference) -> Hash[String, TreeEntry]
-      def blob: (String path, ?reference: String) -> String?
-      def status: () -> Array[Status::Entry]
-      def blame: (String path, ?reference: String) -> Array[Blame::Line]
-      def diff: (String path, ?staged: bool, ?context: Integer) -> Array[Diff::Hunk]
-      def worktree_content: (String path) -> String?
-      def worktree_path: (String path, ?replacing: Array[String]) -> String
-      def revert_hunk: (String path, Diff::Hunk hunk) -> String
-      def checkout: (String name) -> String
-    end
-    class ObjectDatabase
-      attr_reader directory: String
-      def initialize: (String directory) -> void
-      def self.hash: (String type, String data) -> String
-      def read: (String oid, ?Array[String] seen) -> object
-      def packs: () -> Array[Pack]
-    end
-    class Pack
-      TYPES: Hash[Integer, String]
-      MAX_OBJECT_SIZE: Integer
-      attr_reader path: String
-      attr_reader offsets: Hash[String, Integer]
-      def initialize: (String index_path) -> void
-      def include?: (String oid) -> bool
-      def read: (String oid) ?{ (String) -> object } -> object
-      def self.apply_delta: (String base, String delta) -> String
-    end
-    class Index
-      include Enumerable[Entry]
-      class Entry < Struct[untyped]
-        attr_accessor path: String
-        attr_accessor oid: String
-        attr_accessor mode: Integer
-        attr_accessor size: Integer
-        attr_accessor mtime: Integer
-        attr_accessor mtime_nsec: Integer
-        attr_accessor ctime: Integer
-        attr_accessor ctime_nsec: Integer
-        attr_accessor dev: Integer
-        attr_accessor ino: Integer
-        attr_accessor uid: Integer
-        attr_accessor gid: Integer
-        attr_accessor stage: Integer
-        attr_accessor flags: Integer?
-        attr_accessor extended_flags: Integer?
-        def self.new: (path: String, oid: String, mode: Integer, size: Integer, mtime: Integer, mtime_nsec: Integer, ctime: Integer, ctime_nsec: Integer, dev: Integer, ino: Integer, uid: Integer, gid: Integer, stage: Integer, ?flags: Integer?, ?extended_flags: Integer?) -> instance
-      end
-      attr_reader entries: Array[Entry]
-      attr_reader version: Integer
-      attr_reader path: String
-      def initialize: (String path) -> void
-      def each: () -> Enumerator[Entry, Array[Entry]]
-              | () { (Entry) -> void } -> Array[Entry]
-      def []: (String path) -> Entry?
-      def self.encode: (Array[Entry] entries) -> String
-    end
-    module Diff
-      class Edit < Struct[untyped]
-        attr_accessor kind: :equal | :insert | :delete
-        attr_accessor old_line: Integer
-        attr_accessor new_line: Integer
-        attr_accessor text: String
-        def self.new: (kind: :equal | :insert | :delete, old_line: Integer, new_line: Integer, text: String) -> instance
-      end
-      class Hunk < Struct[untyped]
-        attr_accessor old_start: Integer
-        attr_accessor old_count: Integer
-        attr_accessor new_start: Integer
-        attr_accessor new_count: Integer
-        attr_accessor edits: Array[Edit]
-        def self.new: (old_start: Integer, old_count: Integer, new_start: Integer, new_count: Integer, edits: Array[Edit]) -> instance
-        def old_text: () -> String
-        def new_text: () -> String
-      end
-      def self.edits: (lines before, lines after) -> Array[Edit]
-      def self.hunks: (lines before, lines after, ?context: Integer) -> Array[Hunk]
-      def self.revert: (String text, Hunk hunk) -> String
-      def self.unified: (lines before, lines after, ?old_name: String, ?new_name: String, ?context: Integer) -> String
-    end
-    class Status
-      class Entry < Struct[untyped]
-        attr_accessor path: String
-        attr_accessor index: String
-        attr_accessor worktree: String
-        def self.new: (path: String, index: String, worktree: String) -> instance
-        def code: () -> String
-      end
-      def initialize: (Repository repository) -> void
-      def call: () -> Array[Entry]
-    end
-    class Blame
-      class Line < Struct[untyped]
-        attr_accessor line: Integer
-        attr_accessor text: String
-        attr_accessor commit: String
-        attr_accessor author: String?
-        attr_accessor original_line: Integer
-        attr_accessor path: String
-        def self.new: (line: Integer, text: String, commit: String, author: String?, original_line: Integer, path: String) -> instance
-      end
-      def initialize: (Repository repository) -> void
-      def call: (String path, ?reference: String) -> Array[Line]
-    end
-  end
-end