thuban 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41d8c298a842a358db7f9ec204f0b25eb9a11c6b1baa1ac7206f230d148c9874
+  data.tar.gz: 3ca82e618bf82cc6f40851ac4bd230179a242dc1ba96059379e42e3c4826e6ef
+SHA512:
+  metadata.gz: 121c47d02bb849760a8e7ca06c8a272dc29bcdc7165401c43064146950207f763dd141118dcfdeb279baa1cc80e02d79a9086077c788ff7a2be9704aa451affe
+  data.tar.gz: e1bc999f1a766a6ddc7602c6aae005ea5fc5a90530c2646820b9b9b66f3dad0440dc6fe0fd117b31a6e0410b5fe9126d1a96cb287b7e0524ffb6b21154b61059

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 0.1.0 - 2026-09-12
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# Thuban
+
+Thuban is a pure Ruby reader for local Git repositories. It reads SHA-1
+objects, packfiles, refs, commits, trees, blobs, indexes, status, and blame,
+and supports a guarded checkout.
+
+## Installation
+
+```ruby
+gem "thuban", "~> 0.1.0"
+```
+
+## Usage
+
+```ruby
+require "thuban"
+
+repo = Thuban::Repository.new(Dir.pwd)
+repo.head
+repo.branch
+repo.blob("README.md")
+repo.staged_blob("README.md")
+repo.worktree_content("README.md")
+repo.status
+repo.blame("README.md")
+```
+
+Text comparison stays explicit:
+
+```ruby
+diff = Porrima.diff(
+  repo.staged_blob("README.md").to_s,
+  repo.worktree_content("README.md").to_s
+)
+
+hunk = diff.hunks.first
+repo.write("README.md", Porrima.revert(repo.worktree_content("README.md"), hunk)) if hunk
+```
+
+`Repository#write` rejects symlinks, preserves the file mode, and replaces the
+file atomically. `Repository#checkout` requires a clean tracked worktree and
+aborts on untracked collisions.
+
+## Scope
+
+Thuban does not implement a diff algorithm; blame delegates line matching to
+Porrima through the injectable `differ:` argument. It does not perform network
+operations such as fetch or push. Writes are limited to atomic worktree
+replacement and checkout; it does not rewrite history.
+
+Thuban targets SHA-1 repositories. It supports the index and pack formats
+covered by its test suite, not every optional Git extension. Submodule checkout
+is deliberately excluded.
+
+## Development
+
+```sh
+bundle install
+bundle exec rake
+ruby tools/check_isolation.rb
+bundle exec rbs -I sig -r porrima validate
+gem build --strict thuban.gemspec
+```
+
+## License
+
+Thuban is available under the MIT License.

data/lib/thuban/blame.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Thuban
+  class Blame
+    Line = Struct.new(:line, :text, :commit, :author, :original_line, :path, keyword_init: true)
+
+    def initialize(repository)
+      @repository = repository
+    end
+
+    def call(path, reference: "HEAD", differ: Porrima)
+      revision = @repository.commit(reference)
+      return [] unless revision
+      current = @repository.blob(path, reference: revision.oid)
+      return [] unless current
+      result = Array.new(current.lines.length)
+      pending = [[revision, path, current, result.each_index.to_h { |index| [index, index] }]]
+      until pending.empty?
+        commit, current_path, contents, unresolved = pending.pop
+        commit.parents.each do |parent_oid|
+          break if unresolved.empty?
+          parent = @repository.commit(parent_oid)
+          parent_tree = @repository.tree(parent_oid)
+          parent_path = current_path
+          unless parent_tree.key?(current_path)
+            current_oid = @repository.tree(commit.oid)[current_path]&.oid
+            parent_path = parent_tree.values.find { |entry| entry.oid == current_oid }&.path
+          end
+          next unless parent_path
+          previous = @repository.blob(parent_path, reference: parent_oid)
+          next unless previous
+          inherited = {}
+          differ.edits(previous, contents).each do |edit|
+            next unless edit.kind == :equal && unresolved.key?(edit.new_line - 1)
+            inherited[edit.old_line - 1] = unresolved.delete(edit.new_line - 1)
+          end
+          pending << [parent, parent_path, previous, inherited] unless inherited.empty?
+        end
+        lines = contents.lines
+        unresolved.each do |original, target|
+          result[target] = Line.new(line: target + 1, text: lines[original].force_encoding(Encoding::UTF_8),
+            commit: commit.oid, author: commit.author, original_line: original + 1, path: current_path)
+        end
+      end
+      result
+    end
+  end
+end

data/lib/thuban/commit.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Thuban
+  Commit = Struct.new(:oid, :tree, :parents, :author, :committer, :message, keyword_init: true)
+end

data/lib/thuban/corrupt_object.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Thuban
+  class CorruptObject < StandardError; end
+end

data/lib/thuban/ignore_matcher.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Thuban
+  class IgnoreMatcher
+    Rule = Struct.new(:base, :expression, :negated, :directory, keyword_init: true)
+
+    def initialize(rules = [])
+      @rules = rules.freeze
+    end
+
+    def add(source, base: "")
+      rules = source.lines.filter_map do |line|
+        line = line.delete_suffix("\n").delete_suffix("\r")
+        line = line.sub(/(?<!\\)(?:\\\\)*\K +\z/, "")
+        next if line.empty? || line.start_with?("#")
+
+        negated = line.start_with?("!")
+        line = line[1..] if negated
+        directory = line.end_with?("/")
+        line = line.delete_suffix("/") if directory
+        anchored = line.start_with?("/") || line.include?("/")
+        line = line.delete_prefix("/")
+        next if line.empty?
+
+        expression = Regexp.new((anchored ? "\\A" : "(?:\\A|/)") + glob(line) + "\\z")
+        Rule.new(base: base.delete_suffix("/"), expression: expression, negated: negated, directory: directory)
+      rescue RegexpError
+        nil
+      end
+      self.class.new(@rules + rules)
+    end
+
+    def ignored?(path, directory: false)
+      ignored = false
+      @rules.each do |rule|
+        next if rule.directory && !directory
+        next unless rule.base.empty? || path.start_with?(rule.base + "/")
+
+        local = rule.base.empty? ? path : path[(rule.base.length + 1)..]
+        ignored = !rule.negated if rule.expression.match?(local)
+      end
+      ignored
+    end
+
+    private
+
+    def glob(pattern)
+      result = +""
+      index = 0
+      while index < pattern.length
+        char = pattern[index]
+        case char
+        when "\\"
+          index += 1
+          result << Regexp.escape(pattern[index] || "\\")
+        when "*"
+          finish = index
+          finish += 1 while pattern[finish + 1] == "*"
+          if finish > index && (index.zero? || pattern[index - 1] == "/") && (finish == pattern.length - 1 || pattern[finish + 1] == "/")
+            if pattern[finish + 1] == "/"
+              result << "(?:[^/]+/)*"
+              finish += 1
+            else
+              result << ".*"
+            end
+          else
+            result << "[^/]*"
+          end
+          index = finish
+        when "?"
+          result << "[^/]"
+        when "["
+          cursor = index + 1
+          cursor += 1 if ["!", "^"].include?(pattern[cursor])
+          cursor += 1 if pattern[cursor] == "]"
+          finish = nil
+          while cursor < pattern.length
+            if pattern[cursor, 2] == "[:" && (ending = pattern.index(":]", cursor + 2))
+              cursor = ending + 2
+              next
+            end
+            if pattern[cursor] == "]"
+              finish = cursor
+              break
+            end
+            cursor += pattern[cursor] == "\\" ? 2 : 1
+          end
+          if finish
+            content = pattern[(index + 1)...finish].sub(/\A!/, "^")
+            content = content.gsub(/(?<!\\)(.)-(.)/) { Regexp.last_match(1).ord > Regexp.last_match(2).ord ? Regexp.last_match(1) : Regexp.last_match(0) }
+            result << "(?!/)[#{content}]"
+            index = finish
+          else
+            result << "\\["
+          end
+        else
+          result << Regexp.escape(char)
+        end
+        index += 1
+      end
+      result
+    rescue RegexpError
+      Regexp.escape(pattern)
+    end
+  end
+end

data/lib/thuban/index.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module Thuban
+  class Index
+    Entry = Struct.new(:path, :oid, :mode, :size, :mtime, :mtime_nsec, :ctime, :ctime_nsec,
+      :dev, :ino, :uid, :gid, :stage, :flags, :extended_flags, keyword_init: true)
+    include Enumerable
+    attr_reader :entries, :version, :path
+
+    def initialize(path)
+      @path = path
+      @entries = []
+      @version = 2
+      parse(File.binread(path)) if File.file?(path)
+    end
+
+    def each(&block) = entries.each(&block)
+    def [](path) = entries.find { |entry| entry.path == path && entry.stage.zero? }
+
+    def self.encode(entries)
+      bytes = +"DIRC".b << [2, entries.length].pack("N2")
+      entries.sort_by { |entry| [entry.path.b, entry.stage || 0] }.each do |entry|
+        name = entry.path.b
+        fields = %i[ctime ctime_nsec mtime mtime_nsec dev ino mode uid gid size].map { |field| entry.public_send(field).to_i & 0xffffffff }
+        record = fields.pack("N10") + [entry.oid].pack("H*") + [[name.bytesize, 0xfff].min | ((entry.stage || 0) << 12)].pack("n") + name + "\0"
+        record << "\0" * ((8 - record.bytesize % 8) % 8)
+        bytes << record
+      end
+      bytes + Digest::SHA1.digest(bytes)
+    end
+
+    private
+
+    def parse(bytes)
+      raise CorruptObject, "invalid Git index" unless bytes.bytesize >= 32 && bytes.start_with?("DIRC")
+      raise CorruptObject, "Git index checksum mismatch" unless Digest::SHA1.digest(bytes[0...-20]) == bytes[-20, 20]
+      @version, count = bytes[4, 8].unpack("N2")
+      raise CorruptObject, "unsupported Git index version #{version}" unless [2, 3, 4].include?(version)
+      offset = 12
+      previous = "".b
+      count.times do
+        start = offset
+        raise CorruptObject, "truncated Git index entry" if offset + 62 > bytes.bytesize - 20
+        fields = bytes[offset, 40].unpack("N10")
+        oid = bytes[offset + 40, 20].unpack1("H*")
+        flags = bytes[offset + 60, 2].unpack1("n")
+        offset += 62
+        extended = 0
+        if (flags & 0x4000).positive?
+          raise CorruptObject, "invalid index extended flags" if version == 2 || offset + 2 > bytes.bytesize - 20
+          extended = bytes[offset, 2].unpack1("n")
+          offset += 2
+        end
+        if version == 4
+          byte = bytes.getbyte(offset)
+          raise CorruptObject, "truncated index path prefix" unless byte
+          offset += 1
+          strip = byte & 0x7f
+          while (byte & 0x80).positive?
+            byte = bytes.getbyte(offset)
+            raise CorruptObject, "invalid index path prefix" unless byte && strip <= previous.bytesize
+            offset += 1
+            strip = ((strip + 1) << 7) | (byte & 0x7f)
+          end
+          raise CorruptObject, "index path prefix outside previous path" if strip > previous.bytesize
+        end
+        ending = bytes.index("\0", offset)
+        raise CorruptObject, "unterminated index path" unless ending && ending < bytes.bytesize - 20
+        name = bytes[offset...ending]
+        name = previous.byteslice(0, previous.bytesize - strip) + name if version == 4
+        raise CorruptObject, "unsafe index path" if name.empty? || name.start_with?("/") || name.split("/").any? { |part| part == ".." || part == ".git" }
+        previous = name
+        offset = ending + 1
+        offset += (8 - (offset - start) % 8) % 8 unless version == 4
+        values = %i[ctime ctime_nsec mtime mtime_nsec dev ino mode uid gid size].zip(fields).to_h
+        entries << Entry.new(**values, path: name.force_encoding(Encoding::UTF_8), oid: oid,
+          flags: flags, extended_flags: extended, stage: (flags >> 12) & 3)
+      end
+      while offset < bytes.bytesize - 20
+        raise CorruptObject, "truncated index extension" if offset + 8 > bytes.bytesize - 20
+        signature = bytes[offset, 4]
+        size = bytes[offset + 4, 4].unpack1("N")
+        # Lowercase extensions change index interpretation (e.g. split index).
+        raise CorruptObject, "unsupported mandatory index extension #{signature}" if signature[0].match?(/[a-z]/)
+        offset += 8 + size
+        raise CorruptObject, "truncated index extension payload" if offset > bytes.bytesize - 20
+      end
+    end
+  end
+end

data/lib/thuban/object_database.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "pack"
+
+module Thuban
+  class ObjectDatabase
+    attr_reader :directory
+
+    def initialize(directory)
+      @directory = File.expand_path(directory)
+      @packs = nil
+    end
+
+    def self.hash(type, data) = Digest::SHA1.hexdigest("#{type} #{data.bytesize}\0".b + data.b)
+
+    def read(oid, seen = [])
+      raise ArgumentError, "expected a full SHA-1 object id" unless /\A[0-9a-f]{40}\z/.match?(oid.to_s)
+      raise CorruptObject, "cyclic object reference" if seen.include?(oid) || seen.length > 128
+      loose = File.join(directory, oid[0, 2], oid[2..])
+      object = if File.file?(loose)
+        inflated = Zlib::Inflate.inflate(File.binread(loose))
+        header, data = inflated.split("\0", 2)
+        type, size = header.split(" ", 2)
+        raise CorruptObject, "invalid loose object header" unless %w[commit tree blob tag].include?(type) && size&.match?(/\A\d+\z/) && data && data.bytesize == size.to_i
+        [type, data]
+      else
+        pack = packs.find { |entry| entry.include?(oid) }
+        unless pack
+          @packs = nil # New packs may appear during background GC.
+          pack = packs.find { |entry| entry.include?(oid) }
+        end
+        raise KeyError, "Git object not found: #{oid}" unless pack
+        pack.read(oid) { |base| read(base, seen + [oid]) }
+      end
+      raise CorruptObject, "object SHA-1 mismatch: #{oid}" unless self.class.hash(*object) == oid
+      object
+    rescue Zlib::Error => error
+      raise CorruptObject, error.message
+    end
+
+    def packs = @packs ||= Dir[File.join(directory, "pack", "*.idx")].sort.map { |path| Pack.new(path) }
+  end
+end

data/lib/thuban/pack.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "digest/sha1"
+require_relative "corrupt_object"
+
+module Thuban
+  class Pack
+    TYPES = {1 => "commit", 2 => "tree", 3 => "blob", 4 => "tag"}.freeze
+    MAX_OBJECT_SIZE = 512 * 1024 * 1024
+    attr_reader :path, :offsets
+
+    def initialize(index_path)
+      @path = index_path.sub(/\.idx\z/, ".pack")
+      @offsets = read_index(File.binread(index_path))
+      File.open(path, "rb") do |file|
+        header = file.read(12)
+        raise CorruptObject, "invalid pack header" unless header&.bytesize == 12 && header[0, 4] == "PACK" && [2, 3].include?(header[4, 4].unpack1("N"))
+        raise CorruptObject, "pack/index object count mismatch" unless header[8, 4].unpack1("N") == offsets.length
+        file.seek(-20, IO::SEEK_END)
+        raise CorruptObject, "pack/index checksum mismatch" unless file.read(20) == @pack_checksum
+      end
+      @cache = {}
+    end
+
+    def include?(oid) = offsets.key?(oid)
+
+    def read(oid, &resolve)
+      offset = offsets[oid]
+      raise KeyError, "object not in pack: #{oid}" unless offset
+      read_at(offset, [], &resolve)
+    end
+
+    def self.apply_delta(base, delta)
+      cursor = 0
+      read_size = lambda do
+        size = shift = 0
+        loop do
+          byte = delta.getbyte(cursor)
+          raise CorruptObject, "truncated delta header" unless byte && shift <= 63
+          cursor += 1
+          size |= (byte & 0x7f) << shift
+          break if (byte & 0x80).zero?
+          shift += 7
+        end
+        size
+      end
+      source_size = read_size.call
+      target_size = read_size.call
+      raise CorruptObject, "delta base size mismatch" unless base.bytesize == source_size
+      raise CorruptObject, "delta too large" if target_size > MAX_OBJECT_SIZE
+      output = +"".b
+      while cursor < delta.bytesize
+        opcode = delta.getbyte(cursor)
+        cursor += 1
+        if (opcode & 0x80).positive?
+          offset = length = 0
+          7.times do |bit|
+            next if (opcode & (1 << bit)).zero?
+            byte = delta.getbyte(cursor)
+            raise CorruptObject, "truncated delta copy" unless byte
+            cursor += 1
+            bit < 4 ? offset |= byte << (bit * 8) : length |= byte << ((bit - 4) * 8)
+          end
+          length = 0x10000 if length.zero?
+          raise CorruptObject, "delta copy outside base" if offset + length > base.bytesize
+          output << base.byteslice(offset, length)
+        elsif opcode.positive?
+          raise CorruptObject, "truncated delta insert" if cursor + opcode > delta.bytesize
+          output << delta.byteslice(cursor, opcode)
+          cursor += opcode
+        else
+          raise CorruptObject, "invalid delta opcode"
+        end
+        raise CorruptObject, "delta exceeds target size" if output.bytesize > target_size
+      end
+      raise CorruptObject, "delta target size mismatch" unless output.bytesize == target_size
+      output
+    end
+
+    private
+
+    def read_index(bytes)
+      raise CorruptObject, "truncated pack index" if bytes.bytesize < 1064
+      raise CorruptObject, "pack index checksum mismatch" unless Digest::SHA1.digest(bytes[0...-20]) == bytes[-20, 20]
+      @pack_checksum = bytes[-40, 20]
+      version = bytes.start_with?("\xfftOc".b) ? bytes[4, 4].unpack1("N") : 1
+      raise CorruptObject, "unsupported pack index version #{version}" unless [1, 2].include?(version)
+      start = version == 1 ? 0 : 8
+      fanout = bytes[start, 1024].unpack("N*")
+      raise CorruptObject, "invalid pack index fanout" unless fanout.each_cons(2).all? { |a, b| a <= b }
+      count = fanout.last
+      cursor = start + 1024
+      minimum = cursor + count * (version == 1 ? 24 : 28) + 40
+      raise CorruptObject, "truncated pack index entries" if minimum > bytes.bytesize
+      if version == 1
+        return count.times.to_h do |index|
+          position = cursor + index * 24
+          [bytes[position + 4, 20].unpack1("H*"), bytes[position, 4].unpack1("N")]
+        end
+      end
+      names = cursor
+      positions = cursor + count * 24
+      large_positions = positions + count * 4
+      count.times.to_h do |index|
+        offset = bytes[positions + index * 4, 4].unpack1("N")
+        if offset >= 0x80000000
+          location = large_positions + (offset & 0x7fffffff) * 8
+          raise CorruptObject, "truncated 64-bit pack offset" if location + 8 > bytes.bytesize - 40
+          offset = bytes[location, 8].unpack1("Q>")
+        end
+        [bytes[names + index * 20, 20].unpack1("H*"), offset]
+      end
+    end
+
+    def read_at(offset, stack, &resolve)
+      return @cache[offset] if @cache.key?(offset)
+      raise CorruptObject, "cyclic or excessive pack delta chain" if stack.include?(offset) || stack.length > 128
+      stack = stack + [offset]
+      type = data = base_offset = base_oid = nil
+      File.open(path, "rb") do |file|
+        raise CorruptObject, "object offset outside pack" unless offset >= 12 && offset < file.size - 20
+        file.seek(offset)
+        byte = file.getbyte
+        type = (byte >> 4) & 7
+        size = byte & 15
+        shift = 4
+        while (byte & 0x80).positive?
+          byte = file.getbyte
+          raise CorruptObject, "truncated pack object size" unless byte && shift <= 63
+          size |= (byte & 0x7f) << shift
+          shift += 7
+        end
+        raise CorruptObject, "pack object too large" if size > MAX_OBJECT_SIZE
+        if type == 6
+          byte = file.getbyte
+          raise CorruptObject, "truncated delta offset" unless byte
+          distance = byte & 0x7f
+          count = 0
+          while (byte & 0x80).positive?
+            byte = file.getbyte
+            count += 1
+            raise CorruptObject, "invalid delta offset" unless byte && count <= 9
+            distance = ((distance + 1) << 7) | (byte & 0x7f)
+          end
+          base_offset = offset - distance
+          raise CorruptObject, "invalid delta base offset" unless base_offset >= 12 && base_offset < offset
+        elsif type == 7
+          raw = file.read(20)
+          raise CorruptObject, "truncated delta reference" unless raw&.bytesize == 20
+          base_oid = raw.unpack1("H*")
+        elsif !TYPES.key?(type)
+          raise CorruptObject, "invalid packed object type #{type}"
+        end
+        inflater = Zlib::Inflate.new
+        begin
+          data = +"".b
+          until inflater.finished?
+            chunk = file.read(16_384)
+            raise CorruptObject, "truncated compressed object" unless chunk
+            inflater.inflate(chunk) do |part|
+              data << part
+              raise CorruptObject, "packed object exceeds declared size" if data.bytesize > size
+            end
+          end
+        rescue Zlib::Error => error
+          raise CorruptObject, error.message
+        ensure
+          inflater.close
+        end
+        raise CorruptObject, "packed object size mismatch" unless data.bytesize == size
+      end
+      object = if base_offset || base_oid
+        base_type, base = base_offset ? read_at(base_offset, stack, &resolve) : resolve.call(base_oid)
+        [base_type, self.class.apply_delta(base, data)]
+      else
+        [TYPES.fetch(type), data]
+      end
+      # ponytail: bound object cache by count; byte budgeting if large blobs dominate.
+      @cache.shift if @cache.length >= 128
+      @cache[offset] = object.map(&:freeze).freeze
+    end
+  end
+end

data/lib/thuban/repository.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+module Thuban
+  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 staged_blob(path)
+      entry = index[path]
+      entry ? odb.read(entry.oid).last : nil
+    end
+
+    def status = Status.new(self).call
+    def blame(path, reference: "HEAD", differ: Porrima) = Blame.new(self).call(path, reference: reference, differ: differ)
+
+    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 write(path, content)
+      absolute = worktree_path(path)
+      raise ArgumentError, "cannot write through a symlink" if File.symlink?(absolute)
+      atomic_write(absolute, content, File.stat(absolute).mode & 0o777)
+      content
+    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
+
+    # 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([".thuban-", ".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

data/lib/thuban/status.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Thuban
+  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 + "/" }
+      WorktreeFiles.new(repository.root, repository.common_dir).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

data/lib/thuban/tree_entry.rb

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

data/lib/thuban/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Thuban
+  VERSION = "0.1.0"
+end

data/lib/thuban/worktree_files.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Thuban
+  class WorktreeFiles
+    include Enumerable
+
+    def initialize(root, common_dir)
+      @root = File.realpath(root)
+      @common_dir = common_dir
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block
+
+      rules = IgnoreMatcher.new
+      exclude = File.join(@common_dir, "info", "exclude")
+      rules = rules.add(File.read(exclude), base: "") if File.file?(exclude)
+      walk("", rules, {}, &block)
+      self
+    end
+
+    private
+
+    def walk(directory, rules, visited, &block)
+      stat = File.stat(path(directory))
+      return if visited[[stat.dev, stat.ino]]
+
+      visited[[stat.dev, stat.ino]] = true
+      %w[.gitignore .ignore].each do |name|
+        source = path(directory.empty? ? name : File.join(directory, name))
+        rules = rules.add(File.read(source, encoding: "UTF-8"), base: directory) if File.file?(source)
+      end
+      Dir.children(path(directory)).sort.each do |name|
+        next if name == ".git"
+
+        relative = directory.empty? ? name : File.join(directory, name)
+        absolute = path(relative)
+        entry = File.lstat(absolute)
+        if entry.symlink?
+          yield relative unless rules.ignored?(relative)
+        elsif !rules.ignored?(relative, directory: entry.directory?)
+          if entry.directory?
+            walk(relative, rules, visited, &block)
+          elsif entry.file?
+            yield relative
+          end
+        end
+      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+        next
+      end
+    end
+
+    def path(relative) = File.expand_path(relative, @root)
+  end
+end

data/lib/thuban.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "thuban/version"
+
+require "fileutils"
+require "find"
+require "tempfile"
+require "porrima"
+
+require_relative "thuban/ignore_matcher"
+require_relative "thuban/worktree_files"
+require_relative "thuban/object_database"
+require_relative "thuban/index"
+require_relative "thuban/status"
+require_relative "thuban/blame"
+require_relative "thuban/commit"
+require_relative "thuban/tree_entry"
+require_relative "thuban/repository"

data/sig/thuban.rbs

@@ -0,0 +1,128 @@
+module Thuban
+  VERSION: String
+  type object = [String, String]
+
+  interface _Differ
+    def edits: (Porrima::lines, Porrima::lines) -> Array[Porrima::Edit]
+  end
+
+  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 staged_blob: (String path) -> String?
+    def worktree_content: (String path) -> String?
+    def worktree_path: (String path, ?replacing: Array[String]) -> String
+    def write: (String path, String content) -> String
+    def status: () -> Array[Status::Entry]
+    def blame: (String path, ?reference: String, ?differ: _Differ) -> Array[Blame::Line]
+    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
+
+  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, ?differ: _Differ) -> Array[Line]
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: thuban
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: porrima
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/thuban.rb
+- lib/thuban/blame.rb
+- lib/thuban/commit.rb
+- lib/thuban/corrupt_object.rb
+- lib/thuban/ignore_matcher.rb
+- lib/thuban/index.rb
+- lib/thuban/object_database.rb
+- lib/thuban/pack.rb
+- lib/thuban/repository.rb
+- lib/thuban/status.rb
+- lib/thuban/tree_entry.rb
+- lib/thuban/version.rb
+- lib/thuban/worktree_files.rb
+- sig/thuban.rbs
+homepage: https://github.com/noxdea/thuban
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/noxdea/thuban
+  changelog_uri: https://github.com/noxdea/thuban/blob/main/CHANGELOG.md
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.19
+specification_version: 4
+summary: A pure Ruby Git repository reader
+test_files: []