thuban 0.2.0 → 0.3.0

data/lib/thuban/stash.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Thuban
+  class Repository
+    def stash_push(message: nil, include_untracked: false)
+      current_head = head
+      raise ArgumentError, "cannot stash on an unborn branch" unless current_head
+      current_index = index
+      raise ArgumentError, "cannot stash unresolved conflicts" unless current_index.conflicts.empty?
+
+      changes = status
+      untracked = changes.select { |entry| entry.index == "?" }.map(&:path)
+      return nil unless changes.any? { |entry| entry.index != "?" } || (include_untracked && !untracked.empty?)
+
+      identity = operation_signature
+      description = "#{current_head[0, 7]} #{require_commit(current_head).message.lines.first.to_s.strip}"
+      location = branch || "(no branch)"
+      stash_message = message ? "On #{location}: #{message}" : "WIP on #{location}: #{description}"
+      index_tree = write_tree_from_entries(current_index.entries)
+      index_commit = write_commit(tree: index_tree, parents: [current_head], author: identity,
+        message: "index on #{location}: #{description}")
+      parents = [current_head, index_commit]
+      if include_untracked && !untracked.empty?
+        untracked_tree = write_tree_from_entries(worktree_entries(untracked))
+        parents << write_commit(tree: untracked_tree, author: identity,
+          message: "untracked files on #{location}: #{description}")
+      end
+      worktree_tree = write_tree_from_entries(worktree_entries((tree(current_head).keys | current_index.entries.map(&:path))))
+      oid = write_commit(tree: worktree_tree, parents: parents, author: identity, message: stash_message)
+      RefStore.new(self).update("refs/stash", oid, old_oid: resolve("refs/stash"), message: stash_message) do
+        replace_repository_state(tree(current_head), tree(current_head), remove_paths: include_untracked ? untracked : [])
+      end
+      oid
+    end
+
+    def stash_list
+      stash_records.reverse.map { |record| require_commit(record_oid(record)) }
+    end
+
+    def stash_pop(index = 0)
+      raise ArgumentError, "stash index must be a non-negative Integer" unless index.is_a?(Integer) && index >= 0
+      ensure_clean_tracked_state!
+      records = stash_records
+      position = records.length - index - 1
+      raise ArgumentError, "stash not found: #{index}" if position.negative?
+
+      oid = record_oid(records.fetch(position))
+      stored = require_commit(oid)
+      raise CorruptObject, "invalid stash commit" unless stored.parents.length >= 2
+      current_head = head
+      raise ArgumentError, "cannot pop a stash on an unborn branch" unless current_head
+
+      base_tree = tree(stored.parents[0])
+      stored_index = tree(stored.parents[1])
+      index_tree = apply_tree_change(base_tree, stored_index, tree(current_head), "stash pop")
+      worktree_tree = apply_tree_change(stored_index, tree(stored.oid), index_tree, "stash pop")
+      if stored.parents[2]
+        untracked_tree = tree(stored.parents[2])
+        collisions = untracked_tree.keys & worktree_tree.keys
+        raise ArgumentError, "stash pop conflicts: #{collisions.sort.join(', ')}" unless collisions.empty?
+
+        worktree_tree = worktree_tree.merge(untracked_tree)
+      end
+      drop_stash(records, position) { replace_repository_state(worktree_tree, index_tree) }
+      oid
+    end
+
+    private
+
+    def worktree_entries(paths)
+      paths.sort.filter_map do |path|
+        absolute = worktree_path(path)
+        stat = File.lstat(absolute)
+        next unless stat.file? || stat.symlink?
+
+        contents = stat.symlink? ? File.readlink(absolute).b : File.binread(absolute)
+        mode = stat.symlink? ? 0o120000 : (stat.mode & 0o100).positive? ? 0o100755 : 0o100644
+        Index::Entry.new(path: path, oid: write_blob(contents), mode: 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, flags: 0, extended_flags: 0)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+    end
+
+    def stash_records
+      path = File.join(common_dir, "logs", "refs", "stash")
+      return [] unless File.file?(path)
+
+      RefStore.new(self).send(:validate_storage_path, path)
+      File.readlines(path, chomp: true, encoding: Encoding::BINARY)
+    end
+
+    def record_oid(record)
+      oid = record.split(" ", 3)[1]
+      raise CorruptObject, "invalid stash reflog" unless oid&.match?(/\A[0-9a-f]{40}\z/)
+
+      oid
+    end
+
+    def drop_stash(records, position)
+      kept = records.dup
+      kept.delete_at(position)
+      ref_path = File.join(common_dir, "refs", "stash")
+      log_path = File.join(common_dir, "logs", "refs", "stash")
+      locks = {}
+      [ref_path, log_path].sort.each do |path|
+        RefStore.new(self).send(:prepare_storage_path, path)
+        locks[path] = File.open(path + ".lock", File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o644)
+      end
+      unchanged = resolve("refs/stash") == record_oid(records.last) && stash_records == records
+      raise RefLockError, "stash changed" unless unchanged
+      metadata = [ref_path, log_path].to_h do |path|
+        [path, File.file?(path) ? [File.binread(path), File.stat(path).mode & 0o777] : nil]
+      end
+      unless kept.empty?
+        locks.fetch(ref_path).write("#{record_oid(kept.last)}\n")
+        locks.fetch(log_path).write(kept.join("\n") + "\n")
+        locks.each_value { |file| file.flush; file.fsync; file.close }
+      end
+      rollback = yield
+      begin
+        if kept.empty?
+          File.unlink(ref_path) if File.file?(ref_path)
+          File.unlink(log_path) if File.file?(log_path)
+        else
+          [log_path, ref_path].each do |path|
+            File.rename(locks.fetch(path).path, path)
+            locks.delete(path)
+          end
+        end
+      rescue StandardError
+        restore_stash_metadata(metadata)
+        rollback.call if rollback.respond_to?(:call)
+        raise
+      end
+    rescue Errno::EEXIST => error
+      raise RefLockError, "stash is locked: #{error.message}"
+    ensure
+      locks&.each_value do |file|
+        file.close unless file.closed?
+        File.unlink(file.path) if File.exist?(file.path)
+      end
+    end
+
+    def restore_stash_metadata(metadata)
+      metadata.each do |path, backup|
+        if backup
+          atomic_write(path, *backup)
+        elsif File.file?(path) || File.symlink?(path)
+          File.unlink(path)
+        end
+      end
+    end
+  end
+end

data/lib/thuban/version.rb

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

data/lib/thuban/worktree_files.rb

@@ -12,9 +12,7 @@ module Thuban
     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)
+      rules = IgnoreMatcher.load(@root)
       walk("", rules, {}, &block)
       self
     end
@@ -26,10 +24,6 @@ module Thuban
       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"
 

data/lib/thuban.rb

@@ -11,8 +11,17 @@ require_relative "thuban/ignore_matcher"
 require_relative "thuban/worktree_files"
 require_relative "thuban/object_database"
 require_relative "thuban/index"
+require_relative "thuban/index_writer"
 require_relative "thuban/status"
 require_relative "thuban/blame"
 require_relative "thuban/commit"
 require_relative "thuban/tree_entry"
+require_relative "thuban/signature"
 require_relative "thuban/repository"
+require_relative "thuban/object_writer"
+require_relative "thuban/ref_lock_error"
+require_relative "thuban/ref_store"
+require_relative "thuban/commit_writer"
+require_relative "thuban/history_writer"
+require_relative "thuban/stash"
+require_relative "thuban/pack_writer"

data/sig/thuban.rbs

@@ -6,9 +6,16 @@ module Thuban
     def edits: (Porrima::lines, Porrima::lines) -> Array[Porrima::Edit]
   end
 
+  interface _PackOutput
+    def write: (String) -> Integer
+  end
+
   class CorruptObject < StandardError
   end
 
+  class RefLockError < StandardError
+  end
+
   class Commit < Struct[untyped]
     attr_accessor oid: String
     attr_accessor tree: String?
@@ -26,6 +33,14 @@ module Thuban
     def self.new: (path: String, oid: String, mode: Integer) -> instance
   end
 
+  class Signature < Struct[untyped]
+    attr_accessor name: String
+    attr_accessor email: String
+    attr_accessor time: Time | Integer | nil
+    attr_accessor offset: String | Integer | nil
+    def self.new: (name: String, email: String, ?time: Time | Integer, ?offset: String | Integer?) -> instance
+  end
+
   class IgnoreMatcher
     class Rule < Struct[untyped]
       attr_accessor base: String
@@ -63,6 +78,24 @@ module Thuban
     def status: () -> Array[Status::Entry]
     def blame: (String path, ?reference: String, ?differ: _Differ) -> Array[Blame::Line]
     def checkout: (String name) -> String
+    def write_blob: (String content) -> String
+    def write_tree: (Array[TreeEntry] entries) -> String
+    def write_commit: (tree: String, ?parents: Array[String], author: Signature, ?committer: Signature?, message: String) -> String
+    def update_ref: (String name, String new_oid, ?old_oid: String | Symbol | nil, ?message: String?) -> String
+    def delete_ref: (String name, ?old_oid: String | Symbol | nil) -> String
+    def create_branch: (String name, String oid) -> String
+    def delete_branch: (String name) -> String
+    def symbolic_ref: (String name, String target) -> String
+    def reflog: (String name) -> Array[String]
+    def write_tree_from_index: () -> String
+    def commit!: (message: String, author: Signature, ?amend: bool) -> String
+    def merge_base: (String a, String b) -> String?
+    def reset: (String oid, ?mode: :soft | :mixed | :hard) -> String
+    def cherry_pick: (String oid) -> String
+    def revert: (String oid) -> String
+    def stash_push: (?message: String?, ?include_untracked: bool) -> String?
+    def stash_pop: (?Integer index) -> String
+    def stash_list: () -> Array[Commit]
   end
 
   class ObjectDatabase
@@ -71,6 +104,18 @@ module Thuban
     def self.hash: (String type, String data) -> String
     def read: (String oid, ?Array[String] seen) -> object
     def packs: () -> Array[Pack]
+    def exist?: (String oid) -> bool
+    def write: (String type, String data) -> String
+    def write_loose: (String type, String data) -> String
+  end
+
+  class RefStore
+    ZERO_OID: String
+    def initialize: (Repository repository) -> void
+    def update: (String name, String new_oid, ?old_oid: String | Symbol | nil, ?message: String?) -> String
+    def delete: (String name, ?old_oid: String | Symbol | nil) -> String
+    def symbolic: (String name, String target) -> String
+    def reflog: (String name) -> Array[String]
   end
 
   class Pack
@@ -82,6 +127,7 @@ module Thuban
     def include?: (String oid) -> bool
     def read: (String oid) ?{ (String) -> object } -> object
     def self.apply_delta: (String base, String delta) -> String
+    def self.write: (_PackOutput io, Enumerable[object] objects) ?{ (Integer current, Integer total) -> void } -> String
   end
 
   class Index
@@ -105,13 +151,20 @@ module Thuban
       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 extensions: Array[String]
     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
+    def self.encode: (Array[Entry] entries, ?extensions: Array[String], ?version: Integer) -> String
+    def write: () -> Index
+    def stage: (String path, String oid, Integer mode, ?stat: File::Stat | Hash[Symbol, untyped]?) -> Entry
+    def unstage: (String path) -> Array[Entry]
+    def remove: (String path) -> Array[Entry]
+    def conflicts: () -> Array[Entry]
+    def resolve: (String path, String oid, Integer mode) -> Entry
   end
 
   class Status

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thuban
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -35,12 +35,21 @@ files:
 - lib/thuban.rb
 - lib/thuban/blame.rb
 - lib/thuban/commit.rb
+- lib/thuban/commit_writer.rb
 - lib/thuban/corrupt_object.rb
+- lib/thuban/history_writer.rb
 - lib/thuban/ignore_matcher.rb
 - lib/thuban/index.rb
+- lib/thuban/index_writer.rb
 - lib/thuban/object_database.rb
+- lib/thuban/object_writer.rb
 - lib/thuban/pack.rb
+- lib/thuban/pack_writer.rb
+- lib/thuban/ref_lock_error.rb
+- lib/thuban/ref_store.rb
 - lib/thuban/repository.rb
+- lib/thuban/signature.rb
+- lib/thuban/stash.rb
 - lib/thuban/status.rb
 - lib/thuban/tree_entry.rb
 - lib/thuban/version.rb
@@ -70,5 +79,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A pure Ruby Git repository reader
+summary: A pure Ruby implementation for local Git repositories
 test_files: []