thuban 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fd4f8874fc442816b49cd9d29963c6c318a733771f50466350cb84040a0242d
-  data.tar.gz: 67a2e2496b0f3775f9619c181771ce8ae92a6e57063b5cd0dd383f4e7571e439
+  metadata.gz: 73f95adb20a42969a69908bab030d4939a94a1bd0bc9ddcacbb9b95dff3dd6a9
+  data.tar.gz: 8ebf2299e31de698cfae6b7487a7722703f50d4fd5a0820adf6e6c35d1eb2616
 SHA512:
-  metadata.gz: 7ae73ad1b5ff6a95e5c221b3382316bc3860d25aff5e5272170468c4f65288fbd0055bff324485bca4c7c3fd896843815d540cb6536a3d50aa9ef29b0e87841f
-  data.tar.gz: aa7b91df7056ee82de5bec2d27eff57ca38bf51bd393d3505034ebe2639d9a8aee76d3047b80d4aef5a3caa1c8432e7a79cfb4da98a62ecf695cfd020c7ded28
+  metadata.gz: 97e8fe6cbbfa497234aafc55a4c49f0d9775721451c2e32a1882d4d15066d079cf1544ef41c48bff61230297ad7191b64da8de5b2a63636a6224516037d9b9da
+  data.tar.gz: 889372feb5805cdfb126a1f9668700abda26307b6617be36556e917050c90270aff58e9e193dc3bad832d9be2aa15f41b885466801c3f8f5bed27de38588945c

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+## 0.5.0 - 2026-09-17
+
+- Expose parsed commit signatures and separate author and committer identities in `commit!`
+- Add current author and committer identity lookup with `Repository#signature`
+- Add bounded commit history traversal with `Repository#each_commit`
+- Add cancellable high-level fetch and push controls and fast-forward-only pull
+- Honor `core.filemode` when reporting worktree changes
+
 ## 0.4.1 - 2026-09-17
 
 - Load remote transport providers only when remote operations are used

data/README.md

@@ -48,7 +48,7 @@ repository operations work directly with Git data without invoking the Git execu
 Add Thuban to your Gemfile:
 
 ```ruby
-gem "thuban", "~> 0.3.0"
+gem "thuban", "~> 0.5.0"
 ```
 
 Then install it:
@@ -76,6 +76,9 @@ repo.status.each do |entry|
 end
 ```
 
+Status checks honor the repository's `core.filemode` setting; `repo.filemode?`
+exposes the effective value.
+
 ## Usage
 
 ### Read Repository Data
@@ -84,6 +87,7 @@ end
 repo.refs
 repo.branches
 repo.commit
+repo.each_commit(limit: 100)
 repo.tree
 repo.blob("README.md")
 repo.index
@@ -98,6 +102,10 @@ repo.tree("main")
 repo.blob("README.md", reference: "v0.1.0")
 ```
 
+`each_commit` returns an Enumerator without a block. It visits the selected tip
+and then its parents in deterministic parent order, yields merge ancestors only
+once, and requires a positive `limit` so UI history reads remain bounded.
+
 ### Compare and Restore Changes
 
 Thuban exposes staged and worktree content for explicit comparison with
@@ -135,14 +143,25 @@ index = repo.index
 index.stage(path, oid, 0o100644, stat: File.stat(path))
 index.write
 
-author = Thuban::Signature.new(
-  name: "Example Author",
-  email: "author@example.com",
-  time: Time.now
-)
+author = repo.signature(role: :author)
 commit = repo.commit!(message: "Update README", author: author)
 ```
 
+`Repository#signature` reads the matching `GIT_AUTHOR_NAME` /
+`GIT_AUTHOR_EMAIL` or `GIT_COMMITTER_NAME` / `GIT_COMMITTER_EMAIL` first,
+then `user.name` / `user.email` from Git configuration. It returns the current
+time and UTC offset and raises `ArgumentError` when either identity value is
+missing or invalid.
+
+To amend without changing the original author or author timestamp, read the
+author signature from the commit and provide a separate current committer:
+
+```ruby
+original = repo.commit
+committer = repo.signature(role: :committer)
+repo.commit!(message: "Update README", author: original.signature(role: :author), committer: committer, amend: true)
+```
+
 `Index#write` uses Git's `index.lock`, retains optional extensions as raw bytes,
 and invalidates entry-dependent cache extensions after mutation. `unstage`
 removes the stage-zero entry; stage the corresponding HEAD entry to restore a
@@ -279,6 +298,11 @@ repo.fetch("origin", depth: 1) { |event| warn "#{event.phase}: #{event.bytes}" }
 repo.fetch("origin", filter: "blob:none")
 ```
 
+High-level fetch, push, and pull accept `credentials:`, `ssh:`, `timeout:`, and
+a zero-argument `cancelled:` callback. Cancellation closes a blocked transport
+and raises `Thuban::Cancelled`. A push may already have been applied remotely
+when cancellation is observed, so callers must refresh remote refs before retrying.
+
 `depth:` accepts positive 32-bit integers and `filter:` currently accepts only
 `"blob:none"`. Thuban negotiates only features advertised by the server. Shallow
 boundaries are atomically maintained in Git's `shallow` file. For configured
@@ -302,6 +326,15 @@ repo.push("origin", refspecs: [
 ], atomic: true) { |progress| warn "#{progress.phase}: #{progress.current}/#{progress.total}" }
 ```
 
+Pull updates the current branch, index, and worktree only when the named remote
+branch is a fast-forward. Tracked changes, detached HEADs, bare repositories,
+and untracked collisions are rejected; fetched objects and tracking refs remain
+available when the fast-forward cannot be applied:
+
+```ruby
+repo.pull("origin", branch: "main")
+```
+
 Remote names, direct paths, `file://` URLs, HTTP(S), and SSH URLs are accepted.
 At the lower level, `Connection#push` accepts `[ref, old_oid, new_oid]` updates;
 the old object ID is an optimistic lease, and `nil` uses the advertised value.

data/lib/thuban/commit.rb

@@ -1,5 +1,14 @@
 # frozen_string_literal: true
 
 module Thuban
-  Commit = Struct.new(:oid, :tree, :parents, :author, :committer, :message, keyword_init: true)
+  Commit = Struct.new(:oid, :tree, :parents, :author, :committer, :message, keyword_init: true) do
+    def signature(role: :author)
+      raise ArgumentError, "role must be :author or :committer" unless %i[author committer].include?(role)
+
+      match = public_send(role).to_s.match(/\A(.+) <([^<>]+)> (-?\d+) ([+-]\d{4})\z/)
+      raise CorruptObject, "invalid commit signature" unless match
+
+      Signature.new(name: match[1], email: match[2], time: Integer(match[3]), offset: match[4])
+    end
+  end
 end

data/lib/thuban/commit_writer.rb

@@ -9,13 +9,13 @@ module Thuban
       write_tree_from_entries(current.entries)
     end
 
-    def commit!(message:, author:, amend: false)
+    def commit!(message:, author:, committer: nil, amend: false)
       previous = head
       current = previous && commit(previous)
       raise ArgumentError, "cannot amend an unborn branch" if amend && !current
 
       parents = amend ? current.parents : previous ? [previous] : []
-      oid = write_commit(tree: write_tree_from_index, parents: parents, author: author, message: message)
+      oid = write_commit(tree: write_tree_from_index, parents: parents, author: author, committer: committer, message: message)
       subject = message.lines.first.to_s.strip
       action = if amend
         "commit (amend): #{subject}"

data/lib/thuban/history_writer.rb

@@ -2,6 +2,17 @@
 
 module Thuban
   class Repository
+    def each_commit(reference = "HEAD", limit:)
+      raise ArgumentError, "limit must be a positive integer" unless limit.is_a?(Integer) && limit.positive?
+      return enum_for(__method__, reference, limit: limit) unless block_given?
+
+      start = commit(reference)
+      return unless start
+
+      walk_commits(start.oid, limit: limit) { |_, revision| yield revision }
+      nil
+    end
+
     def merge_base(a, b)
       left = require_commit(a).oid
       right = require_commit(b).oid
@@ -36,7 +47,7 @@ module Thuban
       raise ArgumentError, "cannot cherry-pick a merge commit" if source.parents.length > 1
 
       base = source.parents.empty? ? {} : tree(source.parents.first)
-      apply_commit_change(source, base, tree(source.oid), author: signature_from(source.author), message: source.message,
+      apply_commit_change(source, base, tree(source.oid), author: source.signature(role: :author), message: source.message,
         action: "cherry-pick")
     end
 
@@ -56,7 +67,7 @@ module Thuban
       commit(reference) || raise(ArgumentError, "unknown commit: #{reference}")
     end
 
-    def walk_commits(start)
+    def walk_commits(start, limit: nil)
       queue = [start]
       seen = {}
       cursor = 0
@@ -65,9 +76,11 @@ module Thuban
         cursor += 1
         next if seen[oid]
 
+        revision = require_commit(oid)
         seen[oid] = true
-        yield oid
-        queue.concat(require_commit(oid).parents)
+        queue.concat(revision.parents) unless limit && seen.length >= limit
+        yield oid, revision
+        break if limit && seen.length >= limit
       end
     end
 
@@ -166,6 +179,8 @@ module Thuban
       end
       owns_lock = true
       begin
+        raise RefLockError, "Git index changed since it was read" unless current_index.send(:source_unchanged?)
+
         write_worktree_tree(worktree_tree, contents, removed)
         extensions = current_index.extensions.reject { |extension| Index::ENTRY_DEPENDENT_EXTENSIONS.include?(extension.byteslice(0, 4)) }
         lock.write(Index.encode(index_entries(index_tree), extensions: extensions, version: current_index.version))
@@ -303,15 +318,8 @@ module Thuban
       nil
     end
 
-    def signature_from(value)
-      match = value.to_s.match(/\A(.+) <([^<>]+)> (-?\d+) ([+-]\d{4})\z/)
-      raise CorruptObject, "invalid commit signature" unless match
-
-      Signature.new(name: match[1], email: match[2], time: Integer(match[3]), offset: match[4])
-    end
-
     def operation_signature
-      RefStore.new(self).send(:reflog_signature)
+      current_signature(:committer, fallback: true)
     end
   end
 end

data/lib/thuban/index.rb

@@ -14,7 +14,12 @@ module Thuban
       @entries = []
       @extensions = []
       @version = 2
-      parse(File.binread(path)) if File.file?(path)
+      @source_checksum = nil
+      if File.file?(path)
+        bytes = File.binread(path)
+        @source_checksum = Digest::SHA1.digest(bytes)
+        parse(bytes)
+      end
     end
 
     def each(&block) = entries.each(&block)

data/lib/thuban/index_writer.rb

@@ -10,12 +10,16 @@ module Thuban
       FileUtils.mkdir_p(File.dirname(path))
       file = File.open(lock_path, File::WRONLY | File::CREAT | File::EXCL | File::BINARY, 0o644)
       owns_lock = true
-      file.write(self.class.encode(entries, extensions: extensions, version: version))
+      raise RefLockError, "Git index changed since it was read" unless source_unchanged?
+
+      contents = self.class.encode(entries, extensions: extensions, version: version)
+      file.write(contents)
       file.flush
       file.fsync
       file.close
       File.rename(lock_path, path)
       owns_lock = false
+      @source_checksum = Digest::SHA1.digest(contents)
       self
     rescue Errno::EEXIST
       raise IOError, "Git index is locked: #{lock_path}"
@@ -62,6 +66,14 @@ module Thuban
 
     private
 
+    def source_unchanged?
+      @source_checksum == Digest::SHA1.digest(File.binread(path))
+    rescue Errno::ENOENT
+      @source_checksum.nil? && !File.symlink?(path)
+    rescue SystemCallError
+      false
+    end
+
     def validate_entry(path, oid, mode)
       validate_path(path)
       raise ArgumentError, "expected a full SHA-1 object id" unless /\A[0-9a-f]{40}\z/.match?(oid.to_s)

data/lib/thuban/ref_store.rb

@@ -168,8 +168,7 @@ module Thuban
     end
 
     def reflog_signature
-      Signature.new(name: ENV["GIT_COMMITTER_NAME"] || config_value("name") || ENV["USER"] || "unknown",
-        email: ENV["GIT_COMMITTER_EMAIL"] || config_value("email") || "unknown@localhost", time: Time.now)
+      repository.send(:current_signature, :committer, fallback: true)
     end
 
     def validate_storage_path(path)
@@ -211,21 +210,6 @@ module Thuban
       root
     end
 
-    def config_value(key)
-      section = nil
-      File.foreach(File.join(repository.common_dir, "config"), encoding: "UTF-8") do |line|
-        stripped = line.strip
-        if (section_match = stripped.match(/\A\[\s*([^\s\]"]+)/))
-          section = section_match[1].downcase
-        elsif section == "user" && (value_match = stripped.match(/\A#{key}\s*=\s*(.*)\z/i))
-          return value_match[1].strip.delete_prefix("\"").delete_suffix("\"")
-        end
-      end
-      nil
-    rescue Errno::ENOENT, Errno::EACCES
-      nil
-    end
-
     def rewrite_packed_refs(file, path, name)
       lines = File.readlines(path, mode: "rb")
       kept = []

data/lib/thuban/remote/credentials.rb

@@ -125,7 +125,8 @@ module Thuban
 
         def terminate(waiter, grouped)
           unless grouped
-            Process.kill("KILL", waiter.pid)
+            killed = system("taskkill", "/PID", waiter.pid.to_s, "/T", "/F", out: File::NULL, err: File::NULL)
+            Process.kill("KILL", waiter.pid) unless killed
             waiter.join
             return
           end

data/lib/thuban/remote/repository.rb

@@ -6,9 +6,10 @@ module Thuban
       remote_settings.transform_values { |settings| settings[:url] }.compact
     end
 
-    def fetch(remote = "origin", refspecs: nil, depth: nil, filter: nil)
+    def fetch(remote = "origin", refspecs: nil, depth: nil, filter: nil, credentials: nil, ssh: nil, timeout: 30, cancelled: nil)
       depth = Remote::Protocol.validate_depth(depth)
       filter = Remote::Protocol.validate_filter(filter)
+      validate_cancelled(cancelled)
       settings = remote_settings[remote]
       direct = direct_remote?(remote)
       url = settings&.fetch(:url, nil) || (remote if direct)
@@ -21,27 +22,38 @@ module Thuban
         specs = ["+refs/heads/*:refs/remotes/#{remote}/*"] if specs.empty?
       end
       specs = normalize_fetch_refspecs(specs)
-      connection = Remote.open(url)
-      advertised = connection.refs
-      updates = select_fetch_refs(advertised, specs)
-      wants = updates.map { |ref, _| ref.oid }.compact.uniq
-      previous = updates.filter_map { |_, destination| [destination, resolve(destination)] if destination }.to_h
-      unless wants.empty?
-        haves = refs.values.compact.uniq.select { |oid| odb.exist?(oid) }
-        connection.fetch(self, wants: wants, haves: haves, depth: depth, filter: filter) do |progress|
-          yield progress if block_given?
+      check_cancellation!(cancelled)
+      connection = Remote.open(url, credentials: credentials, ssh: ssh, timeout: timeout)
+      advertised, updates, previous, publish = with_transfer(connection, cancelled) do |check_cancelled|
+        advertised = connection.refs
+        check_cancelled.call
+        updates = select_fetch_refs(advertised, specs)
+        wants = updates.map { |ref, _| ref.oid }.compact.uniq
+        previous = updates.filter_map { |_, destination| [destination, resolve(destination)] if destination }.to_h
+        unless wants.empty?
+          haves = refs.values.compact.uniq.select { |oid| odb.exist?(oid) }
+          connection.fetch(self, wants: wants, haves: haves, depth: depth, filter: filter) do |progress|
+            yield progress if block_given?
+            check_cancelled.call
+          end
+          check_cancelled.call
         end
+        check_cancelled.call
+        [advertised, updates, previous, !wants.empty?]
+      end
+      check_cancellation!(cancelled)
+      if publish
         record_promisor(remote, filter) if filter && settings
         updates.each do |ref, destination|
           update_ref(destination, ref.oid, old_oid: previous.fetch(destination), message: "fetch #{remote}: #{ref.name}") if destination && ref.oid
         end
       end
       advertised
-    ensure
-      connection&.close
     end
 
-    def push(remote = "origin", refspecs:, force: false, lease: nil, atomic: false)
+    def push(remote = "origin", refspecs:, force: false, lease: nil, atomic: false,
+      credentials: nil, ssh: nil, timeout: 30, cancelled: nil)
+      validate_cancelled(cancelled)
       settings = remote_settings[remote]
       direct = direct_remote?(remote)
       url = settings&.fetch(:pushurl, nil) || settings&.fetch(:url, nil) || (remote if direct)
@@ -50,16 +62,101 @@ module Thuban
       raise ArgumentError, "force must be true or false" unless [true, false].include?(force)
       raise ArgumentError, "atomic must be true or false" unless [true, false].include?(atomic)
 
-      connection = Remote.open(url)
-      advertised = connection.send(:receive_refs)
-      updates = push_updates(refspecs, force: force, lease: lease, advertised: advertised)
-      connection.push(self, updates, atomic: atomic) { |progress| yield progress if block_given? }
-    ensure
-      connection&.close
+      check_cancellation!(cancelled)
+      connection = Remote.open(url, credentials: credentials, ssh: ssh, timeout: timeout)
+      with_transfer(connection, cancelled) do |check_cancelled|
+        advertised = connection.send(:receive_refs)
+        check_cancelled.call
+        updates = push_updates(refspecs, force: force, lease: lease, advertised: advertised)
+        result = connection.push(self, updates, atomic: atomic) do |progress|
+          yield progress if block_given?
+          check_cancelled.call
+        end
+        check_cancelled.call
+        result
+      end
+    end
+
+    def pull(remote = "origin", branch: nil, ff_only: true, credentials: nil, ssh: nil, timeout: 30, cancelled: nil, &progress)
+      raise ArgumentError, "only fast-forward pulls are supported" unless ff_only == true
+      validate_cancelled(cancelled)
+      check_cancellation!(cancelled)
+      raise ArgumentError, "bare repository has no worktree" unless root
+      local_branch = self.branch
+      raise ArgumentError, "cannot pull with a detached HEAD" unless local_branch
+      remote_branch = branch || local_branch
+      raise ArgumentError, "invalid remote branch" unless valid_refspec_name?("refs/heads/#{remote_branch}")
+      ensure_clean_tracked_state!
+      current = head
+
+      settings = remote_settings[remote]
+      destination = settings && "refs/remotes/#{remote}/#{remote_branch}"
+      spec = "refs/heads/#{remote_branch}:#{destination}"
+      spec = "refs/heads/#{remote_branch}" unless destination
+      advertised = fetch(remote, refspecs: spec, credentials: credentials, ssh: ssh, timeout: timeout,
+        cancelled: cancelled, &progress)
+      check_cancellation!(cancelled)
+      target = advertised.find { |ref| ref.name == "refs/heads/#{remote_branch}" }&.oid
+      raise TransportError, "remote branch not found: #{remote_branch}" unless target
+      return target if current == target
+      raise TransportError, "pull is not a fast-forward" if current && merge_base(current, target) != current
+
+      check_cancellation!(cancelled)
+      RefStore.new(self).update("HEAD", target, old_oid: current, message: "pull #{remote} #{remote_branch}: fast-forward") do
+        raise RefLockError, "HEAD changed during pull" unless self.branch == local_branch
+        ensure_clean_tracked_state!
+        check_cancellation!(cancelled)
+        replace_repository_state(tree(target), tree(target))
+      end
     end
 
     private
 
+    def validate_cancelled(cancelled)
+      return if cancelled.nil?
+
+      callable = cancelled.respond_to?(:call) && cancelled.method(:call)
+      valid = callable && callable.parameters.none? { |kind, _| %i[req keyreq].include?(kind) }
+      raise TypeError, "cancelled must be a zero-argument callable" unless valid
+    end
+
+    def check_cancellation!(cancelled)
+      raise Cancelled, "transfer cancelled" if cancelled&.call
+    end
+
+    def with_transfer(connection, cancelled)
+      state = {done: false, cancelled: false}
+      lock = Mutex.new
+      check = lambda do
+        requested = lock.synchronize { state[:cancelled] } || cancelled&.call
+        lock.synchronize { state[:cancelled] = true } if requested
+        raise Cancelled, "transfer cancelled" if requested
+      end
+      check.call
+      watcher = if cancelled
+        Thread.new do
+          loop do
+            sleep 0.01
+            break if lock.synchronize { state[:done] }
+            next unless cancelled.call
+
+            lock.synchronize { state[:cancelled] = true }
+            connection.close
+            break
+          end
+        end
+      end
+      yield check
+    rescue TransportError
+      raise Cancelled, "transfer cancelled" if lock&.synchronize { state[:cancelled] }
+
+      raise
+    ensure
+      lock&.synchronize { state[:done] = true }
+      watcher&.join
+      connection&.close
+    end
+
     def direct_remote?(remote)
       value = remote.to_s
       value.match?(/\A(?:https?|ssh|file):\/\//i) || (!value.include?("://") && value.include?(":")) ||

data/lib/thuban/remote.rb

@@ -3,6 +3,7 @@
 module Thuban
   class Error < StandardError; end
   class TransportError < Error; end
+  class Cancelled < TransportError; end
   class AuthenticationError < TransportError; end
 
   Ref = Struct.new(:name, :oid, :symref_target, :peeled, keyword_init: true)

data/lib/thuban/repository.rb

@@ -36,6 +36,14 @@ module Thuban
     def index = Index.new(File.join(git_dir, "index"))
     def head = resolve("HEAD")
 
+    def signature(role: :author)
+      current_signature(role, fallback: false)
+    end
+
+    def filemode?
+      !%w[false no off 0].include?(git_config_value("core", "filemode").to_s.downcase)
+    end
+
     def branch
       text = File.read(File.join(git_dir, "HEAD")).strip
       text.start_with?("ref: refs/heads/") ? text.delete_prefix("ref: refs/heads/") : nil
@@ -253,6 +261,33 @@ module Thuban
 
     private
 
+    def current_signature(role, fallback:)
+      prefix = case role
+      when :author then "GIT_AUTHOR"
+      when :committer then "GIT_COMMITTER"
+      else raise ArgumentError, "role must be :author or :committer"
+      end
+      name = ENV["#{prefix}_NAME"] || git_config_value("user", "name")
+      email = ENV["#{prefix}_EMAIL"] || git_config_value("user", "email")
+      if fallback
+        name ||= ENV["USER"] || "unknown"
+        email ||= "unknown@localhost"
+      end
+      missing = {name: name, email: email}.filter_map { |key, value| key if value.nil? || value.empty? }
+      raise ArgumentError, "Git #{role} identity is missing #{missing.join(' and ')}" unless missing.empty?
+
+      now = Time.now
+      value = Signature.new(name: name, email: email, time: now, offset: now.utc_offset)
+      format_signature(value)
+      value
+    end
+
+    def git_config_value(section, key)
+      files = IgnoreMatcher.send(:git_config_files, root || common_dir)
+      files << File.join(common_dir, "config") unless root
+      files.uniq.filter_map { |path| IgnoreMatcher.send(:config_value, path, section, key) }.last
+    end
+
     def prune_empty_directories(paths)
       paths.sort_by { |path| -path.count("/") }.each do |path|
         parent = File.dirname(File.join(root, path))

data/lib/thuban/status.rb

@@ -14,6 +14,7 @@ module Thuban
       repository = @repository
       index = repository.index
       head = repository.tree
+      filemode = repository.filemode?
       tracked = index.entries.group_by(&:path)
       result = []
       (head.keys | tracked.keys).sort.each do |path|
@@ -30,7 +31,7 @@ module Thuban
         elsif !staged then "D"
         elsif original.mode != staged.mode || original.oid != staged.oid then "M"
         else " " end
-        y = staged ? worktree_status(staged, index.path) : " "
+        y = staged ? worktree_status(staged, index.path, filemode) : " "
         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 + "/" }
@@ -43,7 +44,7 @@ module Thuban
 
     private
 
-    def worktree_status(entry, index_path)
+    def worktree_status(entry, index_path, filemode)
       absolute = @repository.worktree_path(entry.path)
       stat = File.lstat(absolute)
       if entry.mode == 0o160000
@@ -56,7 +57,7 @@ module Thuban
       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 "M" if filemode && 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 &&

data/lib/thuban/version.rb

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

data/sig/thuban.rbs

@@ -27,6 +27,9 @@ module Thuban
   class TransportError < Error
   end
 
+  class Cancelled < TransportError
+  end
+
   class AuthenticationError < TransportError
   end
 
@@ -85,6 +88,7 @@ module Thuban
     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
+    def signature: (?role: :author | :committer) -> Signature
   end
 
   class TreeEntry < Struct[untyped]
@@ -126,10 +130,14 @@ module Thuban
     def index: () -> Index
     def head: () -> String?
     def branch: () -> String?
+    def signature: (?role: :author | :committer) -> Signature
+    def filemode?: () -> bool
     def refs: () -> Hash[String, String?]
     def branches: () -> Array[String]
     def resolve: (String name, ?Array[String] seen) -> String?
     def commit: (?String reference) -> Commit?
+    def each_commit: (?String reference, limit: Integer) -> Enumerator[Commit, nil]
+                   | (?String reference, limit: Integer) { (Commit) -> void } -> nil
     def tree: (?String reference) -> Hash[String, TreeEntry]
     def blob: (String path, ?reference: String) -> String?
     def staged_blob: (String path) -> String?
@@ -149,7 +157,7 @@ module Thuban
     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 commit!: (message: String, author: Signature, ?committer: 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
@@ -158,8 +166,9 @@ module Thuban
     def stash_pop: (?Integer index) -> String
     def stash_list: () -> Array[Commit]
     def remotes: () -> Hash[String, String]
-    def fetch: (?String remote, ?refspecs: String | Enumerable[String]?, ?depth: Integer?, ?filter: String?) ?{ (Progress) -> void } -> Array[Ref]
-    def push: (?String remote, refspecs: String | Enumerable[String], ?force: bool, ?lease: String | Hash[String, String]?, ?atomic: bool) ?{ (Progress) -> void } -> Array[Ref]
+    def fetch: (?String remote, ?refspecs: String | Enumerable[String]?, ?depth: Integer?, ?filter: String?, ?credentials: untyped, ?ssh: Remote::ssh_command?, ?timeout: Numeric, ?cancelled: ^() -> bool?) ?{ (Progress) -> void } -> Array[Ref]
+    def push: (?String remote, refspecs: String | Enumerable[String], ?force: bool, ?lease: String | Hash[String, String]?, ?atomic: bool, ?credentials: untyped, ?ssh: Remote::ssh_command?, ?timeout: Numeric, ?cancelled: ^() -> bool?) ?{ (Progress) -> void } -> Array[Ref]
+    def pull: (?String remote, ?branch: String?, ?ff_only: bool, ?credentials: untyped, ?ssh: Remote::ssh_command?, ?timeout: Numeric, ?cancelled: ^() -> bool?) ?{ (Progress) -> void } -> String
   end
 
   class ObjectDatabase

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thuban
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Yudai Takada