NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
crates.io
crates.io, #1408 most downloaded on crates.io
Interact with git repositories just like git would
Latest stable
0.90.0
Last release 1 months ago
22 Oct 2026
Ships on a steady schedule
a new release about every 4 weeks
Nearly every release is documented
notes for 60 of the last 60 stable releases
12 versions withdrawn
withdrawn after publishing
4 years old
75 releases · first in 2023
Drag across the ruler to compare, or tap a release to open it.
add worktree locking and a lock override that preserves changes
add worktree locking and a lock override that preserves changes
Expose Worktree::set_lock(Option<&BStr>) and worktree::Proxy::set_lock()
so callers can protect linked worktrees from pruning, moving, or removal,
including when their checkout is offline. Implement file handling in
gix_worktree::set_lock(): preserve byte-oriented reasons, append Git's
trailing newline when needed, and make unlocking idempotent. Reject the
main worktree in the porcelain and avoid writing through lock-file symlinks.
Previously Force::OverrideLock also discarded local changes and initialized
submodules. Add Force::OverrideLockKeepChanges to bypass just the lock check,
retaining status and submodule validation. This expands an exhaustive public
enum, so adapt the Tix caller in the same commit; existing CLI force levels
retain their behavior.
Git reference: v2.56.0-116-g6de20f6092
(6de20f6092dcf9bdb1c8efe03db4b70c82b423dd), builtin/worktree.c
lock/unlock/removal, wrapper.c newline encoding, and
t/t2403-worktree-move.sh. Git's worktree remove -ff bypasses both lock and
cleanliness checks; the new mode deliberately permits bypassing only the lock.
exposes a pre-existing unresolved with_fetch_options link in clone docs.
max-performance-safe feature
gix always uses zlib-rs, so the safe bundle no longer differs frommax-performance. Make max-performance own the default cache setup andmax-performance instead.add Submodule::resolved_url() for cloning
Definitely went through the tests quickly, besides the usual
'make it a shell script', but poked the URL resolution and Windows
special cases.
Some of the newly added drive-prefix tests are truly from another world,
and I don't think I could ever have written those, for better or worse.
Relative submodule URLs in .gitmodules refer to the superproject's
upstream, even when that upstream uses ssh://, git://, or SCP syntax.
Passing the existing Submodule::url() result directly to a clone treats
./ and ../ entries as local paths instead.
Document url() as the raw configured accessor and add resolved_url()
for cloning or fetching. Port Git's byte-oriented relative_url() rules
from remote.c, select the current branch's remote or the default remote,
and fall back to the superproject itself when the selected URL is missing.
Make local paths absolute so the result does not depend on the caller's
working directory. Honor configuration overrides as initialized URLs,
avoiding a second remote-relative resolution of local URLs written by
git submodule init.
Validate transport and local URLs, traversal errors, default-remote
selection, initialized overrides, unborn and bare repositories, and
non-UTF-8 local paths in disposable repositories. Compare resolution with
git submodule init; include native-separator coverage for Windows.
expose selected global attribute paths
Allow callers that retain detached diff results to track the attribute files
selected by the repository. Reuse the existing resolver so permissions,
configuration interpolation, fallback paths, and precedence stay consistent
with the attribute stack.
Return selected paths even when files are missing so their later creation can
invalidate cached results. Per-directory attributes and info/attributes
remain separate because their locations are already known to the caller.
provide safe interrupt setup and handle SIGHUP
Applications that only need the shared cancellation flag should not have to
supply an unsafe signal callback. Add interrupt::init_handler_default() as a
safe entry point while preserving the callback and grace policy of an existing
registration, including when a UI runs inside the gix command.
Treat Unix SIGHUP like the other termination signals so long-running work can
observe cancellation and callers can restore terminal state before exiting.
It previously bypassed the shared flag and terminated immediately. Repeated
signals retain the existing forced-termination policy.
Exercise all supported termination signals and nested safe registration in
isolated subprocesses. Four interrupt tests pass with the feature enabled and
two pass without it.
add Remote::default_branch() to learn the default branch of a remote without connecting to it.
git clone and git remote set-head record the default branch of a remote in the symbolic reference
refs/remotes/<name>/HEAD, which points to the remote-tracking branch of that branch, like
refs/remotes/origin/main. Since Git 2.48, git fetch also creates it if it's missing.
make repository paths absolute without reloading
Went through the tests quite quickly, thinking their are deep and thorough
as usual.
Relative repository paths depend on the process current directory. Changing it
after opening a repository can redirect checkout validation, Git-link handling,
HEAD and object reads, or index persistence away from the intended repository.
Add Repository::make_paths_absolute() to anchor the selected Git directory,
common directory, worktree, index, and object database to the CWD captured at
opening. Unlike reload(), this keeps runtime configuration, reference namespaces,
and in-memory objects. Join paths lexically so missing worktrees remain supported
and destination symlinks are still rejected. Leave existing clones unchanged,
avoid partial updates on failure, and make repeated calls a no-op.
Recreate relative reference and object stores through their existing APIs.
Reset caches carrying relative index paths or store-specific pack IDs while
preserving outstanding snapshots.
Use an anchored repository view for initial checkout, and anchor global attribute
paths before optional-file metadata checks. Document the interpolation helper
and its captured-directory behavior.
Cover CWD changes, main and linked worktrees, bare repositories, missing checkouts,
index overrides, retained runtime state, idempotence, and failed reconstruction.
Include a Windows-only test for rejecting unresolved drive-relative index paths
without partially updating the repository.
separate linked worktree registration from checkout
Skipped over the tests, knowing they are very detailed
can be trusted by now.
Add Repository::prepare_add_worktree() with consuming checkout and explicit
persistence. Persisted repositories can run their initial checkout later, even
after their checkout directory is removed, while failed unpersisted checkouts
roll back their owned data.
create SHA-256 repositories for object_hash: None in SHA-256-only builds
Previously a SHA-1 repository was created that the same build couldn't open.
Now None falls back to the build's default object format.
respect section trust for filesystem path protections
GHSA-q54r-jf2p-rfr2 reports that path-protection configuration did not
respect the section filter used for security-relevant settings. Use the
filter for core.protectHFS, core.protectNTFS, and
gitoxide.core.protectWindows, including the latter's early read for the
reference store. Keep platform defaults and boolean error handling intact.
Read-only fixtures exercise local and worktree configuration, full and
reduced trust, custom filters, trusted API overrides, and malformed
values in strict and lenient mode. Before the fix, reduced-trust settings
replaced the defaults and a rejected malformed Windows setting prevented
opening. Validation also exercises representative path names.
Git baseline: the local Git reference identifies itself as v2.56.GIT.
Its t/t1014-read-tree-confusing.sh and read-cache.c:verify_path_internal
cover filesystem-specific path protections. Git's ownership policy in
setup.c:ensure_valid_ownership rejects dubious ownership, whereas gix
supports reduced trust by filtering configuration.
match Git clone reference handling and preserve offline defaults
The prior CI run failed check-mode because make_clone_refs.sh had a
shebang without its executable bit. Its ARM32 tests also ran Git 2.47.3,
which rejects clone --revision; the matrix mistook that unsupported
option for a clone failure and disagreed with successful gix clones.
Mark the fixture executable and detect revision support from git clone -h.
Skip only revision baselines on older Git, retaining all 72 other cases
and the independent gix revision tests. Modern Git still exercises all
81 baseline cases. Capture help despite its expected nonzero exit status.
match Git clone reference handling and preserve offline defaults
gix clones recorded remote HEAD as a direct object ID, losing the
branch relationship needed by later fetches and Remote::default_branch().
Bare clones also used the ordinary remote-tracking layout, while detached
remote heads and custom destinations selected different references from
git clone.
Match Git's clone orchestration and reference selection:
refs/heads/*, without a default persistedHEAD, or branch upstream configuration. KeepWithWorktree plus fetch_only()HEAD, preferring init.defaultBranch, then master, then theHEAD, including overwriting a branch namedHEAD; omit tracking HEAD when the selected target is excluded.HEAD, and align shallow selection, tag policy, initial packed-referencePreserve fetch-source identity when deriving an offline default branch.
Recognize refs/heads/ sources and exact heads/<name> sources, including
an exact source whose mapping was deduplicated against a glob. Return
None for sources whose branch cannot be identified offline, count all
ambiguous mappings, and share reverse mapping with upstream-branch lookup.
Consult Git's builtin/clone.c and remote.c, and add deterministic
Git-produced baselines for 27 cases in normal, no-checkout, and bare modes.
Compare complete references, relevant configuration, reflog IDs, checkout
contents, shallow boundaries, and success or failure with installed Git.
Keep source fixtures read-only and read their existing refs through gix.
Update API docs, CLI help and update printing, and affected clone/fetch tests.
Known difference: replacing a direct branch named HEAD with the tracking
symref logs a null old object ID in gix-ref; Git logs the resolved target.
The baseline test explicitly checks this exception. Replacement-only custom
refspecs remain a gix extension rather than being compared with Git's
supplementary clone mappings.
resolve linked worktree submodules in their private Git directory
Git stores each linked superproject's submodule repositories under
.git/worktrees/<id>/modules/<name>, separately from the main worktree's
.git/modules/<name> repositories. Using common_dir() for
Submodule::git_dir() could open the main worktree's submodule before
initialization or after deinitialization of the linked submodule.
Derive the path from the superproject's git_dir() instead. Preserve name
validation and the precedence of an existing submodule .git file.
Cover initial checkout, initialization, and deinitialization using Git to
populate a disposable linked worktree created by gix. Check that the main
submodule remains populated and that linked repository state and opening
follow its own lifecycle.
honor replacement refs and bypass stale commit graphs
Enable standard replacement refs by default and honor core.useReplaceRefs
with the same polarity as Git. The presence of GIT_NO_REPLACE_OBJECTS
disables them regardless of its value.
Commit graphs contain original parent links, so skip them while object
replacements are active, including when a caller forces or supplies a
cache. Per-handle raw reads can still use the graph. Document the corrected
opening and graph behavior.
The regression first failed on the original code, then passed for ordinary
open/discovery in bare and non-bare repositories, reopening after a graft,
configuration and environment disablement, explicit raw reads, supplied
and forced graphs, merge-base, and graph removal. All 503 gix integration
tests passed; the regression also passed with only revision,sha1 enabled.
Native rebuilt gix log and tix show match Git across two grafts in both
repository kinds with pre-existing raw graphs.
Commit::short_id() doctest (75ca154)object_hash: None in SHA-256-only builds (521b3b2)Submodule::resolved_url() for cloning (41cb46f)SIGHUP (840faa0)Remote::default_branch() to learn the default branch of a remote without connecting to it. (2ddcae4)core.longpaths when initializing linked-submodule fixtures (7edbf02)max-performance-safe feature (7467af0)Your coding agent can read these notes before it upgrades. Set up the MCP server →
Adapt gitoxide-core and gix-tix callers in the same breaking change, removing explicit conversions that became identities.
replace fs with gix-fs
gix-fs already provides the filesystem helpers and recursive walkers.
Keeping their duplicate implementation in gix-features adds unnecessary
filesystem dependencies to the foundational feature crate.
Remove the fs module and the walkdir and fs-read-dir features. Migrate
workspace callers to gix_fs, move traversal requests to gix-fs/walkdir,
and update the manifests, lockfile, traversal documentation, and feature
check script together.
use gix::Result throughout the public API
The error migration left public gix methods, iterators, callbacks, and
configuration validators returning a mixture of exceptions, I/O errors,
custom error enums, and even the rejected input itself. Callers still had
to adapt these separately despite the common gix::Error boundary.
Use the crate-level Result throughout APIs defined by gix, including
fallible configuration inputs and owned TryFrom implementations. Keep
underlying causes, classifications, and diagnostic metadata available
through gix::Error. Configuration adapters accept arbitrary caller errors
without panicking or losing their causes. Object kind conversions report
validation errors. Re-exported plumbing APIs and error types required by
external traits retain their existing contracts.
Adapt gitoxide-core and gix-tix callers in the same breaking change,
removing explicit conversions that became identities.
remove linked worktrees safely
Expose safe linked-worktree removal through gix, using the gix-worktree
removal plumbing. Validate the selected worktree, inspect dirty and locked
states, and preserve the checkout unless the requested removal policy permits
deleting it.
Enable removal through worktree-mutation and report progress and cleanup
outcomes to callers. Keep branch deletion explicit, adding compare-and-swap
branch removal for callers that have already inspected a target so concurrent
branch changes are not lost. Cover porcelain removal behavior and conditional
branch deletion in disposable repositories.
add and check out linked worktrees
Expose Repository::add_worktree() for existing local branches and detached
commits. Prepare the links, initialize HEAD and its reflog, check out
the commit, and write the index, rolling back created files on failure or
interruption.
Inherit worktree configuration and common attributes before checkout. Enumerate
the main and linked repositories consistently so additions and branch deletion
protect branches checked out or reserved by bisect and rebase, while matching
Git's default namespace behavior.
Support worktree.useRelativePaths with its repository-format upgrade and
extensions.relativeWorktrees validation. Compare behavior with Git for
bare parents, separate Git directories, moved relative links, configuration
inheritance, invalid destinations, and rollback.
Format already-registered worktree destinations with Path::display().
honor section trust when merging submodule overrides
A report describes reduced-trust repository configuration overriding
submodule settings, including command-valued updates. Apply the repository's
existing configurable section filter for worktree, index, and HEAD module
sources, and retain each copied section's origin metadata.
Keep trusted API overrides usable and restrict module enumeration to the
original module definitions. The regressions first reproduced both the trust
bypass and lost provenance, then covered custom filters and every source.
Git reference: setup.c::ensure_valid_ownership, submodule-config.c, and
builtin/submodule--helper.c at d38352cd43ab9745686d697872408bc3249a153f
distinguish shared module definitions from trusted local overrides.
read the target reflog when a symbolic ref has no log
Reflog specifications such as refs/symref@{0} failed when the symbolic
reference had no log of its own, even though its final target had one.
Follow symbolic references only when their own reflog is absent, retaining
precedence of an existing log. Reuse the reference-following helper for
chained references, cycle detection, and missing-ref errors.
The regression compares indexed and dated queries, chained references,
and existing-log precedence against isolated Git invocations in a
disposable repository.
Git reference: /Users/byron/dev/github.com/git/git,
refs.c::repo_dwim_log() prefers a reference's own log, then its resolved
target's log. Runtime comparisons used Git 2.54.0 (Apple Git-157).
resolve HEAD tracking branches through the current branch
Repository::rev_parse_single() rejected HEAD@{upstream}, HEAD@{u},
and HEAD@{push} because it looked for tracking configuration on HEAD
instead of the currently checked out branch.
Follow HEAD before looking up tracking configuration, reusing the existing
symbolic-reference resolution helper and retaining missing-ref errors.
The regression compares all three tracking aliases with their implicit
forms and isolated Git invocations in a disposable repository.
Git reference: /Users/byron/dev/github.com/git/git,
remote.c::repo_branch_get() treats HEAD as the current branch.
Runtime comparisons used Git 2.54.0 (Apple Git-157).
match equivalent Windows paths when removing worktrees
The Windows fast-test job failed in Tix associated-branch cleanup:
C:\Users\RUNNER~1\...\topic was reported as not registered even
though Git had created the worktree. Git can record the long-name path,
while callers retain a short-name or verbatim path for the same directory.
The shared-base removal resolver only compared path components after
symlink resolution, which does not expand Windows short names.
After the existing component comparison fails on Windows, compare
canonical paths when both exist. Apply this at the shared equality helper
used for target selection and backlink validation. Keep the original
comparison and missing-path behavior so absent or inaccessible checkouts
can still be unregistered. Add a Windows regression that registers a
worktree with Git and removes it via its canonical path, and document
equivalent path selection.
don't apply the caller's GIT_INDEX_FILE or GIT_WORK_TREE to a new clone
preserve caller locations in native error adapters
Passing a #[track_caller] constructor directly to map_err() records
the FnOnce shim in core as the caller. Use or_error() for native
error adapters in gix, gix-actor, and gix-config so diagnostics record
the adapter and use the usual exception formatting, including with
tree-error.
Keep Error::from_boxed() inside a closure for boxed trait-object errors,
which ResultExt does not accept. Add a regression for invalid branch
merge references and document when constructors still require closures.
anchor worktree removal paths to the repository CWD
A repository opened through a relative path retains the CWD that gives its
paths meaning. Changing the process CWD before worktree removal made exact
lookup and suffix disambiguation resolve registrations against the wrong
location. Registration scans, lock checks, and reopening a selected worktree
also depended on the process CWD.
Resolve registered checkout paths with repo.current_dir(). Anchor proxy
private Git directories and reopened common directories to that captured
CWD, so enumeration, lookup by ID, locks, status, and removal keep using the
original repository. Keep caller-supplied relative targets relative to the
current process CWD. Document that proxy paths are now absolute.
Extend the isolated relative-path removal test with a CWD change and lock
checks, and cover absolute lookup, ambiguous suffix disambiguation, repository
inspection, and main-worktree protection from both main and linked handles.
The new CWD cases failed before the fix.
HEAD tracking branches through the current branch (ab83e97)fs with gix-fs (cf1ba49)GIT_INDEX_FILE or GIT_WORK_TREE to a new clone (90bdb18)gix::Result throughout the public API (9a5777e)Include all downstream adaptations in this breaking change so the stack remains buildable.
preserve causes across fallible conversions
Rubber stamp, looked at diff. This is a cleanup commit.
There is going to be considerable cleanup done later as well.
Parsers and adapters discarded encoding, integer, date, signature, and
object-access failures when replacing them with context. Preserve their
concrete causes so classification and downcasting keep working after
conversion to gix::Error or an I/O error.
Return Exn from fallible path, command-line, gitdir, and pack-entry
conversions where necessary, and adapt their consumers in the same change.
Packed-ref and reflog errors retain their parser sources and input details;
reflog recovery reports the actual recovery failure. Loose-object verification
now propagates lookup and enumeration failures instead of treating every
lookup error as retryable or silently skipping failed enumeration.
Remove unnecessary UTF-8 conversions for ASCII suffixes and check span bounds
before narrowing. Parsers that only return () explicitly destructure it.
No production map_err() closure still discards a wildcard-bound error.
Also preserve causes in formatting-only CLI and commit-graph adapters, where
stringification previously lost checksum corruption classifications.
locate vi/vim in Git's core directory on Windows; change Repository::editor() -> Option<gix_command::Prepare>
On Windows, Git's bundled vi may not be available through PATH. Resolve the
default editor in Git's core directory first and retain the bare command as
fallback.
return the local branches actually deleted
Callers that needed to know whether branch deletion removed anything had
to look up each reference separately. That duplicated reference reads and
could report stale existence information by the time deletion took its
locks.
Return sorted, deduplicated full names from the committed reference edits
whose previous values were observed under lock. Missing branches are
excluded while their stale local configuration is still removed. Expose
the same list as deleted in delete::Error::Cleanup so callers can recover
it when only configuration cleanup fails; retain references as the full
requested batch.
The success value changes from () to Vec<FullName>, and Cleanup gains
a deleted field. Strengthen the existing tests for loose, packed, dangling
symbolic, duplicate, missing, empty, and linked-worktree branch requests.
remove redundant error aliases
rubberstamp
The crate-by-crate migration retained operation-specific error aliases to
limit downstream churn. With the migration complete, those names only hide
the shared error types and keep otherwise empty API namespaces alive.
Use the underlying gix_error types directly throughout the workspace,
including indirect aliases, renamed exports, test helpers, and the URL fuzz
target. Remove namespaces and files that only held forwarding aliases, and
update documentation and migration guidance to use the canonical types.
Adjust the source locations recorded in error snapshots after deleting the
alias declarations.
Keep gix::{Error, Exn} and gix::error as the central facade, along with
unrenamed canonical re-exports, required associated types, concrete errors,
and aliases that add structure. Preserve each Exn parameter, conditional
error alternative, error message, and source chain. Include all downstream
adaptations in this breaking change so the stack remains buildable.
consolidate public API failures under gix::Error
rubberstamp
raise MSRV to Rust 1.88
The newly published dua-core 3.3 release used by linked-worktree removal
requires Rust 1.88, so raise every workspace crate and the advertised badge
together.
Keep the MSRV checks buildable by selecting the latest sysinfo and rusqlite
release lines that support Rust 1.88.
add Repository::config_path()
Callers with a repository currently have to select local and worktree
configuration paths themselves before falling back to gix::config_path().
Expose that selection on Repository, using its common directory for
Source::Local, its Git directory for Source::Worktree, and its opening
options with the existing resolver for global sources.
Keep the worktree path available even when extensions.worktreeConfig is
disabled, so callers can locate and prepare that physical file. Preserve
the existing errors for disabled sources and sources without a file.
Git reference: builtin/config.c and Documentation/git-config.adoc in
the local Git checkout at 1630431f326e15fcde608827b5ff38422528eb59.
The executable baseline was Git 2.50.1 (Apple Git-155).
expose standalone configuration paths with config_path()
Callers need to locate a configuration file before starting a
config_mut() transaction so they can inspect it, prepare its parent
directory, or load it themselves.
Extract the existing path selection into gix::config_path(source, options) and use it from config_mut(). Preserve source and environment
permissions, explicit path overrides, and current-directory anchoring.
Path lookup succeeds without existing parent directories or valid
configuration contents, and does not acquire a transaction lock or
evaluate transaction settings.
Git reference: v2.55.0-782-g1630431f32, config.c functions
git_system_config() and git_global_config_paths(), plus the global and
system override tests in t/t1300-config.sh. The shared resolver retains
the existing source-specific path and override behavior.
add standalone config_mut() transactions
Callers can load global configuration with gix::config(), but editing
one physical file previously required a repository. Add a sibling that
accepts config::Source and open::Options and returns the existing
config::FileTransaction.
Share source-path resolution and core.configLockTimeout parsing with
configuration loading and repository transactions. Honor source and
environment permissions, preserve source metadata, and keep physical
edits lossless without persisting includes or runtime overrides.
Global files use normal filesystem permissions; missing files can be
created on commit when their parent directory already exists.
allow presetting system configuration paths
Callers that already know the Git-installation and system configuration files
can now provide both paths through gix::open::Options. The paths flow through
repository opening and standalone configuration loading, while the existing
source permissions continue to decide whether each file is read.
Preset paths replace path discovery, but must not bypass Git's explicit
GIT_CONFIG_NOSYSTEM switch. Read the permitted environment value once before
selecting Git-installation and system sources, preserving the behavior already
implemented by gix_config::Source::storage_location().
add worktreeProxy::is_prunable() + fix
Expose worktree::Proxy::is_prunable() with Git-compatible semantics: locked
worktrees are retained, while unreadable gitdir files and missing checkout
targets are prunable. Treat any filesystem entry at locked as a lock,
including symlinks.
When opening a proxy as a repository, use the common directory already known
by its parent instead of relying on the linked worktree’s optional commondir
file. This prevents incomplete administration from being mistaken for a
standalone repository and keeps HEAD access routed through the repository ref
store for backend compatibility.
Fetch can consequently inspect linked-worktree heads without failing for missing
checkouts, locks, or missing and malformed commondir files.
edit physical configuration files atomically with Repository::config_file_mut()
Add Repository::config_file_mut() as a transaction over one physical
configuration file. It acquires a symlink-aware lock before reading, parses
without expanding includes, preserves formatting and existing permissions, and
resolves relative paths against the opening CWD.
Lock acquisition honors the discoverable core.configLockTimeout key
with Git-compatible parsing and a 1000 ms default. New files also honor
core.sharedRepository after the process umask, including named, boolean,
compatibility, and explicit octal modes.
Committing only writes the file atomically. Repository state changes through
an explicit full reload, which retains normal Git-compatible validation and
rebuilds include- and bootstrap-dependent state without a second partial-refresh
path.
add Repository::committer_or_set_fallback()
Applications that configure gitoxide.committer.*Fallback unconditionally can
override a complete user.* identity because these keys resolve first.
Add Repository::committer_or_set_fallback() so callers can provide a
last-resort identity without changing normal configured-user behavior. Keep the
generic helper as a wrapper, and document and test the precedence.
propagate failed fetch ancestry checks
Looked at this in detail to understand how error handling improvements
were made. It all makes sense, and teaches me to... not ignore or
skip over errors, ever, it's basically a bug unless there is a test
that proves it's not a bug.
Fetch ref updates discarded commit decoding and traversal setup errors,
treating any such failure as permission to force the update. A malformed
local or remote commit could therefore overwrite a ref without a force
refspec. Traversal errors were also ignored when looking for the ancestor.
Propagate those failures with their original causes and context. Check
object kinds explicitly to retain the existing behavior for non-commit
targets without mistaking corruption for an object-kind mismatch.
Keep rust workspace tests inside disposable repositories and isolated environments
Direct Git launches inherited repository selectors and user configuration even
when tests supplied a fixture working directory. Tests of default-environment
APIs and local Git transports also shared the runner's environment. A few
journey tests wrote beneath source directories or used the source checkout as
the repository under test.
Use the shared gix-testtools Git command builder for subprocess setup, isolated
repository options for fixtures, and isolated child processes where the real
environment-reading API must be exercised. Scope CWD changes, copy the fixture
used by an object-write test, and run shell journeys through jtt run. Keep
journey worktrees and example output within their disposable sandboxes and
replace the attributes checkout test with a representative fixture repository.
Prompt examples also run in isolated children and must build successfully; the
old tests could ignore build failures and execute stale cached binaries.
The affected Rust crate suites, internal test-tool build, and max-pure journey
suite pass from a source copy without Git metadata. Signing and Git-daemon
checks use only disposable keys, repositories, and local sockets.
find bundled signature programs on Windows
Git for Windows makes its bundled gpg, gpgsm, and ssh-keygen available
by prepending installation directories to PATH. Gitoxide can run outside that
prepared environment, so bare defaults may not resolve.
Use gix_path::env::installation_program() for unconfigured defaults on Windows
and retain the bare name as fallback. Explicit configuration and non-Windows
behavior stay unchanged.
interpolate signature verifier program paths
Git treats gpg.*.program values as pathnames and expands a leading tilde
before launching the verifier. Signing already did this, but verification kept
the raw configured string, which fails with direct program invocation.
Resolve OpenPGP, X.509, and SSH verifier programs through the existing
trusted-path handling while preserving defaults and the legacy gpg.program
fallback.
normalize safe-directory paths before trust checks
Windows canonicalization can produce verbatim paths with a \\?\ prefix while
included configuration metadata uses an ordinary drive path. Comparing those
representations directly prevents an explicitly safe config file from being
promoted to full trust, including after repository reloads.
Canonicalize both the path under test and configured safe-directory paths
through the filesystem before exact or wildcard comparison. Retain the existing
lexical realpath fallback for missing paths.
make identity fallbacks true last-resort values
gitoxide.{author,committer}.*Fallback shared its configuration slot with the
corresponding environment overrides. This placed application fallbacks before
user.*, while also placing GIT_{AUTHOR,COMMITTER}_* after role-specific
configuration.
Store environment overrides under author.* and committer.*, then resolve
explicit fallback keys only after user.*. This matches Git precedence and lets
applications configure fallbacks without replacing a valid user identity.
worktreeProxy::is_prunable() + fix (0af2f91)gix API boundaries (ba2c7f2)gix Cargo example (2bab44c)Repository::config_path() (76502a0)config_path() (707818c)config_mut() transactions (18ac842)Repository::config_file_mut() (913f631)Repository::committer_or_set_fallback() (c355827)vi/vim in Git's core directory on Windows; change Repository::editor() -> Option<gix_command::Prepare> (b76cc28)<csr-id-76502a02f43d26139ce264a54860951f07f0ca1f/> add Repository::config_path()
<!-- agent -->
Callers with a repository currently have to select local and worktree
configuration paths themselves before falling back to gix::config_path().
Expose that selection on Repository, using its common directory for
Source::Local, its Git directory for Source::Worktree, and its opening
options with the existing resolver for global sources.
Keep the worktree path available even when extensions.worktreeConfig is
disabled, so callers can locate and prepare that physical file. Preserve
the existing errors for disabled sources and sources without a file.
Git reference: builtin/config.c and Documentation/git-config.adoc in
the local Git checkout at 1630431f326e15fcde608827b5ff38422528eb59.
The executable baseline was Git 2.50.1 (Apple Git-155).
<csr-id-707818c2c0ec32190592511b2e841ef6ce1d187b/> expose standalone configuration paths with config_path()
<!-- agent -->
Callers need to locate a configuration file before starting a
config_mut() transaction so they can inspect it, prepare its parent
directory, or load it themselves.
Extract the existing path selection into gix::config_path(source, options) and use it from config_mut(). Preserve source and environment
permissions, explicit path overrides, and current-directory anchoring.
Path lookup succeeds without existing parent directories or valid
configuration contents, and does not acquire a transaction lock or
evaluate transaction settings.
Git reference: v2.55.0-782-g1630431f32, config.c functions
git_system_config() and git_global_config_paths(), plus the global and
system override tests in t/t1300-config.sh. The shared resolver retains
the existing source-specific path and override behavior.
<csr-id-18ac842a0f0205bba306cce8f83973eabbba4e27/> add standalone config_mut() transactions
<!-- agent -->
Callers can load global configuration with gix::config(), but editing
one physical file previously required a repository. Add a sibling that
accepts config::Source and open::Options and returns the existing
config::FileTransaction.
Share source-path resolution and core.configLockTimeout parsing with
configuration loading and repository transactions. Honor source and
environment permissions, preserve source metadata, and keep physical
edits lossless without persisting includes or runtime overrides.
Global files use normal filesystem permissions; missing files can be
created on commit when their parent directory already exists.
<csr-id-653c002ced09eed26f2e132427f73e5c77f139aa/> allow presetting system configuration paths
<!-- agent -->
Callers that already know the Git-installation and system configuration files
can now provide both paths through gix::open::Options. The paths flow through
repository opening and standalone configuration loading, while the existing
source permissions continue to decide whether each file is read.
Preset paths replace path discovery, but must not bypass Git's explicit
GIT_CONFIG_NOSYSTEM switch. Read the permitted environment value once before
selecting Git-installation and system sources, preserving the behavior already
implemented by gix_config::Source::storage_location().
<csr-id-0af2f919245950cc05b01c9a0202eba63f4fe4f7/> add worktreeProxy::is_prunable() + fix
<!-- agent -->
Expose worktree::Proxy::is_prunable() with Git-compatible semantics: locked
worktrees are retained, while unreadable gitdir files and missing checkout
targets are prunable. Treat any filesystem entry at locked as a lock,
including symlinks.
When opening a proxy as a repository, use the common directory already known
by its parent instead of relying on the linked worktree’s optional commondir
file. This prevents incomplete administration from being mistaken for a
standalone repository and keeps HEAD access routed through the repository ref
store for backend compatibility.
Fetch can consequently inspect linked-worktree heads without failing for missing
checkouts, locks, or missing and malformed commondir files.
<csr-id-913f63128be5c31ca3870caeafbf79ec1a76e826/> edit physical configuration files atomically with Repository::config_file_mut()
<!-- agent -->
Add Repository::config_file_mut() as a transaction over one physical
configuration file. It acquires a symlink-aware lock before reading, parses
without expanding includes, preserves formatting and existing permissions, and
resolves relative paths against the opening CWD.
Lock acquisition honors the discoverable core.configLockTimeout key with Git-compatible parsing and a 1000 ms default. New files also honor core.sharedRepository after the process umask, including named, boolean, compatibility, and explicit octal modes.
Committing only writes the file atomically. Repository state changes through an explicit full reload, which retains normal Git-compatible validation and rebuilds include- and bootstrap-dependent state without a second partial-refresh path.
<csr-id-c35582765f67605a160a5c022f9ed3d1f64273d6/> add Repository::committer_or_set_fallback()
<!-- agent -->
Applications that configure gitoxide.committer.*Fallback unconditionally can
override a complete user.* identity because these keys resolve first.
Add Repository::committer_or_set_fallback() so callers can provide a
last-resort identity without changing normal configured-user behavior. Keep the
generic helper as a wrapper, and document and test the precedence.
<csr-id-0b2a5c40b25db63f57837b8455c537f759a887ed/> propagate failed fetch ancestry checks Looked at this in detail to understand how error handling improvements were made. It all makes sense, and teaches me to... not ignore or skip over errors, ever, it's basically a bug unless there is a test that proves it's not a bug.
<!-- agent --> Fetch ref updates discarded commit decoding and traversal setup errors, treating any such failure as permission to force the update. A malformed local or remote commit could therefore overwrite a ref without a force refspec. Traversal errors were also ignored when looking for the ancestor.
Propagate those failures with their original causes and context. Check object kinds explicitly to retain the existing behavior for non-commit targets without mistaking corruption for an object-kind mismatch.
<csr-id-4e0f8ff9b920e75d9554eb58c76e396e50502346/> Keep rust workspace tests inside disposable repositories and isolated environments <!-- agent --> Direct Git launches inherited repository selectors and user configuration even when tests supplied a fixture working directory. Tests of default-environment APIs and local Git transports also shared the runner's environment. A few journey tests wrote beneath source directories or used the source checkout as the repository under test.
Use the shared gix-testtools Git command builder for subprocess setup, isolated
repository options for fixtures, and isolated child processes where the real
environment-reading API must be exercised. Scope CWD changes, copy the fixture
used by an object-write test, and run shell journeys through jtt run. Keep
journey worktrees and example output within their disposable sandboxes and
replace the attributes checkout test with a representative fixture repository.
Prompt examples also run in isolated children and must build successfully; the
old tests could ignore build failures and execute stale cached binaries.
The affected Rust crate suites, internal test-tool build, and max-pure journey
suite pass from a source copy without Git metadata. Signing and Git-daemon
checks use only disposable keys, repositories, and local sockets.
<csr-id-3c45a7d57bdc707f65f1abee44a4746e8c0f4e3c/> find bundled signature programs on Windows
<!-- agent -->
Git for Windows makes its bundled gpg, gpgsm, and ssh-keygen available
by prepending installation directories to PATH. Gitoxide can run outside that
prepared environment, so bare defaults may not resolve.
Use gix_path::env::installation_program() for unconfigured defaults on Windows
and retain the bare name as fallback. Explicit configuration and non-Windows
behavior stay unchanged.
<csr-id-ec6350566e25d39495a495000ba38a2b71a8ad4c/> interpolate signature verifier program paths
Git treats gpg.*.program values as pathnames and expands a leading tilde
before launching the verifier. Signing already did this, but verification kept
the raw configured string, which fails with direct program invocation.
Resolve OpenPGP, X.509, and SSH verifier programs through the existing
trusted-path handling while preserving defaults and the legacy gpg.program
fallback.
<csr-id-c48fe1ea437fdfc8f9bfaa667d6ae4a23a18de8a/> normalize safe-directory paths before trust checks
<!-- agent -->
Windows canonicalization can produce verbatim paths with a \\?\ prefix while
included configuration metadata uses an ordinary drive path. Comparing those
representations directly prevents an explicitly safe config file from being
promoted to full trust, including after repository reloads.
Canonicalize both the path under test and configured safe-directory paths through the filesystem before exact or wildcard comparison. Retain the existing lexical realpath fallback for missing paths.
<csr-id-d23127ac52768dc78dc9dc7042885647acf8ddea/> make identity fallbacks true last-resort values
<!-- agent -->
gitoxide.{author,committer}.*Fallback shared its configuration slot with the
corresponding environment overrides. This placed application fallbacks before
user.*, while also placing GIT_{AUTHOR,COMMITTER}_* after role-specific
configuration.
Store environment overrides under author.* and committer.*, then resolve
explicit fallback keys only after user.*. This matches Git precedence and lets
applications configure fallbacks without replacing a valid user identity.
<csr-id-2176245d4618faf4acd0da81e3608f4eba453192/> remove redundant error aliases <!-- Byron --> rubberstamp
<!-- agent --> The crate-by-crate migration retained operation-specific error aliases to limit downstream churn. With the migration complete, those names only hide the shared error types and keep otherwise empty API namespaces alive.
Use the underlying gix_error types directly throughout the workspace,
including indirect aliases, renamed exports, test helpers, and the URL fuzz
target. Remove namespaces and files that only held forwarding aliases, and
update documentation and migration guidance to use the canonical types.
Adjust the source locations recorded in error snapshots after deleting the
alias declarations.
Keep gix::{Error, Exn} and gix::error as the central facade, along with
unrenamed canonical re-exports, required associated types, concrete errors,
and aliases that add structure. Preserve each Exn parameter, conditional
error alternative, error message, and source chain. Include all downstream
adaptations in this breaking change so the stack remains buildable.
<csr-id-b1e31eb8990f9baf3263d97e1b3b3a6fd88f215e/> consolidate public API failures under gix::Error <!-- Byron --> rubberstamp
<csr-id-4b42e0ce80ae934cae4f102f44c392581758608f/> raise MSRV to Rust 1.88
<!-- agent -->
The newly published dua-core 3.3 release used by linked-worktree removal
requires Rust 1.88, so raise every workspace crate and the advertised badge
together.
Keep the MSRV checks buildable by selecting the latest sysinfo and rusqlite
release lines that support Rust 1.88.
<csr-id-3b6009717003b6b928ec618c9865b66277811a71/> return the local branches actually deleted <!-- agent --> Callers that needed to know whether branch deletion removed anything had to look up each reference separately. That duplicated reference reads and could report stale existence information by the time deletion took its locks.
Return sorted, deduplicated full names from the committed reference edits
whose previous values were observed under lock. Missing branches are
excluded while their stale local configuration is still removed. Expose
the same list as deleted in delete::Error::Cleanup so callers can recover
it when only configuration cleanup fails; retain references as the full
requested batch.
The success value changes from () to Vec<FullName>, and Cleanup gains
a deleted field. Strengthen the existing tests for loose, packed, dangling
symbolic, duplicate, missing, empty, and linked-worktree branch requests.
<csr-id-dcf08a412b4bad19250fab104896c8aa648aebe9/> preserve causes across fallible conversions <!-- Byron -->
Rubber stamp, looked at diff. This is a cleanup commit. There is going to be considerable cleanup done later as well.
<!-- agent -->
Parsers and adapters discarded encoding, integer, date, signature, and
object-access failures when replacing them with context. Preserve their
concrete causes so classification and downcasting keep working after
conversion to gix::Error or an I/O error.
Return Exn from fallible path, command-line, gitdir, and pack-entry
conversions where necessary, and adapt their consumers in the same change.
Packed-ref and reflog errors retain their parser sources and input details;
reflog recovery reports the actual recovery failure. Loose-object verification
now propagates lookup and enumeration failures instead of treating every
lookup error as retryable or silently skipping failed enumeration.
Remove unnecessary UTF-8 conversions for ASCII suffixes and check span bounds
before narrowing. Parsers that only return () explicitly destructure it.
No production map_err() closure still discards a wildcard-bound error.
Also preserve causes in formatting-only CLI and commit-graph adapters, where
stringification previously lost checksum corruption classifications.
<csr-id-b76cc2813c8bc27897b15f3d8ced2590ae068375/> locate vi/vim in Git's core directory on Windows; change Repository::editor() -> Option<gix_command::Prepare>
<!-- agent -->
On Windows, Git's bundled vi may not be available through PATH. Resolve the
default editor in Git's core directory first and retain the bare command as
fallback.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
worktreeProxy::is_prunable() + fix (0af2f91)37860b3)6356013)dcf08a4)0b2a5c4)9d0329a)gix API boundaries (ba2c7f2)daf73b5)2176245)b1e31eb)a5e8c4d)gix Cargo example (2bab44c)4b9ff51)2fb9b8a)c609062)4e0f8ff)4f29e0c)92b6508)2742f05)dfc8e8c)283937b)Repository::config_path() (76502a0)be7bb02)config_path() (707818c)d7551f1)3b60097)config_mut() transactions (18ac842)6b2f33d)4a870be)36b6310)653c002)87727ee)c16300c)3c45a7d)b7bedcf)ec63505)a095334)4b42e0c)b14028d)c48fe1e)Repository::config_file_mut() (913f631)7e35849)888677a)ab66595)d23127a)Repository::committer_or_set_fallback() (c355827)e3a6fa1)a1d5a55)vi/vim in Git's core directory on Windows; change Repository::editor() -> Option<gix_command::Prepare> (b76cc28)dda600d)
</details>add exact note-reference writes via note::Platform::replace_at_ref() Add Platform::replace_at_ref() for callers that already have a fully qualified no
add exact note-reference writes via note::Platform::replace_at_ref()
Add Platform::replace_at_ref() for callers that already have a fully qualified notes
reference and must avoid refs/notes shorthand expansion.
improve remote-name comparison and resolution
Remote-tracking ref names are not reliable ownership indicators because fetch
refspecs may use custom destinations. Reverse-map tracking refs against every
configured remote and require exactly one mapping, reporting both cross-remote
and within-remote ambiguity like Git.
Keep path-based inference limited to Reference::remote_name(): select the
longest configured prefix for names containing multiple slashes while avoiding a
remote-config query for ordinary one-slash names.
Allow remote::Name and the borrowed values returned by Remote::name() to compare
directly and symmetrically with str, String, BStr, and BString using exact byte
equality.
compare attached Ids and References with text
Delegate attached Id textual equality to ObjectId, preserving symmetric
canonical comparisons. Let attached references compare directly with
text, byte strings, and full names by delegating to their stored plumbing
reference.
Reference comparisons remain directional because same-name
references may have different targets.
note::Platform::add_to_ref() to ::replace_at_ref() (2c8ddd4)note::Platform::replace_at_ref() (716b89b)Ids and References with text (23bd32d)<csr-id-716b89b9ba63a41545da3938928627bb195b6a76/> add exact note-reference writes via note::Platform::replace_at_ref()
Add Platform::replace_at_ref() for callers that already have a fully qualified notes
reference and must avoid refs/notes shorthand expansion.
<csr-id-900a0f67fde2ae51e28694281525b05bafa42a3c/> improve remote-name comparison and resolution <!-- agent -->
Remote-tracking ref names are not reliable ownership indicators because fetch refspecs may use custom destinations. Reverse-map tracking refs against every configured remote and require exactly one mapping, reporting both cross-remote and within-remote ambiguity like Git.
Keep path-based inference limited to Reference::remote_name(): select the longest configured prefix for names containing multiple slashes while avoiding a remote-config query for ordinary one-slash names.
Allow remote::Name and the borrowed values returned by Remote::name() to compare directly and symmetrically with str, String, BStr, and BString using exact byte equality.
<csr-id-23bd32deea5565b9db9a2971af340a309c5fd10a/> compare attached Ids and References with text
<!--agent-->
Delegate attached Id textual equality to ObjectId, preserving symmetric
canonical comparisons. Let attached references compare directly with
text, byte strings, and full names by delegating to their stored plumbing
reference.
Reference comparisons remain directional because same-name references may have different targets.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
3ebca8b)fbebed7)note::Platform::add_to_ref() to ::replace_at_ref() (2c8ddd4)note::Platform::replace_at_ref() (716b89b)6704303)e52fe9d)900a0f6)47536a5)Ids and References with text (23bd32d)b8914ff)
</details>…but the name didn't indicate this, hence the breaking change.
Normalize the precomputed diff fixture assets to LF before writing blobs,
populating the index, and creating commits. Git for Windows may check these
assets out with CRLF, which changes their object IDs and adds carriage returns
to index paths, causing fixture setup to fail at git mv cli c.
Prevent Git Bash from rewriting revision arguments before Git sees them, and normalize the two pathspec baseline cases where Git for Windows applies native path validation to repository-format paths. Exclude a glob baseline whose backslash behavior is specific to Git for Windows rather than Git paths.
Generate pathological .gitmodules entries as configuration data instead of trying to create module directories whose names cannot be represented on Windows. Use Git Bash bundled Perl for binary fixture construction so regeneration does not depend on a separately installed Python interpreter.
Also pass a literal carriage return to sed through Bash ANSI-C quoting when normalizing the jj diff assets. Unlike GNU sed, BSD sed does not interpret backslash-r in a single-quoted expression, so the previous spelling could remove a trailing letter r on macOS instead of stripping CRLF endings.
<csr-id-d934f5b150146860b5a844218c3733869bfeb44f/> expose git notes in gix::Repository
<!-- agent -->
Add the notes feature and Repository::notes as the porcelain layer over gix-note
for repeated queries and mutations.
Select the default notes ref from core.notesRef, including the GIT_NOTES_REF
environment override represented in config::tree, and fall back to
refs/notes/commits. Discover additional display refs from notes.displayRef or
GIT_NOTES_DISPLAY_REF, expand glob patterns, preserve display order, and avoid
duplicates.
For mutations, accept conventional short notes-ref names, write note blobs and notes commits, and update refs with compare-and-swap expectations so concurrent changes are not silently overwritten.
<csr-id-61c5e1e3d61275d0e3c235fa7ff6ae13546c372f/> add Repository::delete_local_branches().
asdf
<!-- agent -->
Validate the entire batch before changing references, reject branches checked
out in any worktree, and delete references and reflogs in one transaction
without requiring commit traversal.
Remove matching local branch configuration under lock and report when configuration cleanup fails after reference deletion. Share checked-out branch discovery with fetch updates and use restricted repository opening throughout the affected tests.
<csr-id-8017175c8ce15c657ba9cb6be4d1c94a0ce02622/> add Git-compatible commit signing via Commit::sign()
<!-- agent -->
Expose repository-aware commit signing while delegating signature creation
to gix-object plumbing. Resolve gpg.format, per-format programs, signing
keys, committer identity fallback, and gpg.ssh.defaultKeyCommand from Git
configuration, including trusted paths and shell commands.
Add commit_signing_options_if_enabled() so porcelain callers honor commit.gpgSign without resolving signer configuration while signing is disabled. Preserve caller control over resolved program arguments and environment, including non-interactive GPG operation.
<csr-id-5b90699525c939ccab570f884e4dd567a7161d16/> add commit signature verification to gix-object via commit::SignedData::verify()
<!-- agent -->
Add feature-gated plumbing for verifying OpenPGP, X.509, and SSH commit
signatures with fully resolved programs, arguments, environments, trust
thresholds, and SSH policy inputs. Keep repository configuration out of
the object crate while exposing Git-compatible status, identity, key, and
fingerprint results.
Stream signed commit data directly to OpenPGP and SSH verifiers without reconstructing it. Use a temporary payload only where gpgsm requires a file, and cover Git status parsing plus unsupported and mismatched formats.
<csr-id-a9f090e7d44a44029046ee055a15e8f493472e3a/> expose Git quoting utilities in gix
<csr-id-e1c56e49f24de5cb62d4b78ef190ab2a4a39e744/> expose Git-compatible editor selection <!-- agent --> Add `Repository::editor()`` to resolve the interactive editor with Git's precedence rules. Honor GIT_EDITOR ahead of trusted core.editor, consider VISUAL only for capable terminals, fall back through EDITOR to vi, and report no editor for an unconfigured dumb terminal.
Route GIT_EDITOR through the configuration environment-override framework so isolated repositories and environment permissions remain effective. Cover precedence, dumb terminals, the no-op editor, and isolation.
<csr-id-a30f44225ce0190e4a537bfe61127a0cd9f2763b/> recognize SHA-256 commit signature headers <!-- agent --> Teach commit parsing and signature extraction about the gpgsig-sha256 header used by Git when signing SHA-256 commits. Treat it like gpgsig when locating the embedded signature while preserving the actual header name when reconstructing the signed payload.
Cover both full commit parsing and token iteration so callers observe the signature consistently through either API.
<csr-id-287ab8fe868b8857ff3ba9a72015940a386a9bce/> add support for GIT_ALLOW_PROTOCOL
<csr-id-f9b38910d5210421dba093ecd8ef9d939690b2ce/> honor GIT_INDEX_FILE when opening repositories via discover_with_environment_overrides()
<!-- agent -->
Map GIT_INDEX_FILE to the new gitoxide.core.indexFile configuration key
and use it for index reads and writes, allowing to implement hooks for the first time.
As a fix, Repository-local environment overrides are no longer inherited when opening submodules, linked worktrees, or their main repository. This prevents an alternate index, worktree, or Git directory from leaking into another repository.
The selected index path remains stable until the repository is reloaded, and empty index-file overrides are rejected.
<csr-id-b1174b69b60b478be24f0b81787e95ac08564e7e/> support cloning a single revision <!-- agent --> A full object ID passed through with_ref_name() produced an object-ID refspec mapping and panicked while clone assumed every mapping had a name. Branch and tag checkout also retained ordinary clone tracking semantics instead of offering a single-revision mode.
Add PrepareFetch::with_revision() and gix clone --revision for full refs, HEAD, and full object IDs. Revision clones use a one source-only implicit refspec, detach HEAD to the fetched commit, create no ordinary refs, persist no fetch refspec, and disable tag following. Existing with_ref_name() and --ref behavior stays unchanged.
This follows Git commit 337855629f59 (builtin/clone: teach git-clone(1) the --revision= option) and its t/t5621-clone-revision.sh behavior.
<csr-id-9923d769a1d2132dbf87c1796e12e697e667eef1/> add config() function
<!-- agent -->
Factor the non-repository portion of configuration initialization out of
repository opening and expose it as gix::config(). The new API accepts a future
git directory and the same open::Options used by open and clone, preserving
source permissions, conditional includes, environment handling, and override
precedence.
<csr-id-cb74ef670dda04c81411dcbe177036d85f8fcc8c/> don't limit is_dirty() to the current working directory
<csr-id-67467157bc5acc41546990aac2782e07701762f5/> resolve the empty pattern in <rev>^{/} like Git, instead of skipping it.
The parser dropped the find() delegate call whenever the pattern in
<rev>^{/<pattern>} was empty, turning the whole navigation step into a
no-op on the grounds that an empty pattern matches everything.
That reasoning only holds for a commit anchor and a non-negated pattern.
Git routes <rev>^{/...} through GET_OID_COMMITTISH and searches from
the peeled commit even when the pattern is empty - object-name.c notes
"$commit^{/}. Some regex implementation may reject empty regex, but this
is safe". Thus git rev-parse 'b-tag^{/}' yields the commit the
annotated tag points at, while gix returned the tag object itself. A
negated empty pattern matches no commit at all, so Git fails HEAD^{/!-}
while gix silently succeeded with HEAD.
Now the parser always forwards the pattern to Navigate::find(), whose
implementation in gix already handles the empty case correctly on both
the revparse-regex and the substring fallback paths: it peels the
anchor to a commit first and treats an empty pattern as match-all, which
fails naturally when negated. The delegate behind gix revision explain
makes no assumption about patterns and needs no change.
The make_rev_spec_parse_repos fixture gains baselines for @^{/},
@^{/!-} and b-tag^{/}; its archive needs regeneration.
<csr-id-77b5848c687efbffb1a153b41327e5e104a5fb1b/> correctly handdle GIT_PROTOCOL_FROM_USER when evaluating protocol permissions
<!-- agent -->
Align helper protocol permissions with Git by applying policy by transport
name, using the known-safe, ext, and user defaults, and parsing
GIT_PROTOCOL_FROM_USER as a Git boolean.
<csr-id-232dd1c634bbcf01e12e2a24e59ae0104d8c53bf/> peel annotated tags before navigating a rev-spec, like in Git.
<tag>^, <tag>^<n>, <tag>~<n> and <tag>^{/<text>} navigated from the tag
object itself rather than from the commit it points at. In a repository whose
annotated b-tag names the merge commit b, Git resolves b-tag^ to d,
while gix reported "Object 212d0f0 was a tag, but needed it to be a commit",
and b-tag^{/G} failed with a kind mismatch instead of resolving to g.
Git routes these forms through GET_OID_COMMITTISH, which dereferences tags
first. The three navigation sites now peel to a commit the way ^{commit}
already did, keeping the original object id as the replacement key. Peeling is
the identity on a commit, so commit anchors resolve and fail exactly as before.
A blob or tree anchor now reports that it could not be peeled to a commit.
<tag>~0 still yields the tag. The parser in gix-revision skips the delegate
call entirely for a zero-length ancestor walk, which is correct for a commit
anchor and is pinned by a test there; changing it touches the public Navigate
contract and belongs in its own change.
<csr-id-92e31337dc6c8b8293eb1d39ef83ede369058c59/> reject ./.. revspec paths that leave the worktree, like in Git.
At the worktree root, HEAD:./../this resolved to the blob at this while
HEAD:../this correctly failed. Git rejects both:
$ git rev-parse 'HEAD:./../this'
fatal: './../this' is outside repository at '/…/make_basic_repo'
Containment is delegated to Repository::normalize_path(), which normalizes
against an empty current_dir so that a .. with nothing left to consume
fails. In gix_path's normalize_inner() a leading . stays in the buffer,
so .. pushes the empty current_dir onto it, pop() removes the . and
succeeds — where the same path without the leading . pops an empty buffer,
gets false, and correctly yields None. Only the worktree root is affected;
from some/very, HEAD:./../../this already resolved and
HEAD:./../../../this already failed.
Dropping the current-directory components before normalizing keeps the fix inside the revspec parser.
The alternative is normalize_inner() itself, which is a two-line change and
would make the documented promise of Repository::normalize_path() — "Paths
which traverse outside of the repository are rejected" — true for every
caller. I left it alone because it also changes callers unrelated to this
work: gix_submodule::File::path() would start rejecting a .gitmodules
path = ./../evil that it accepts today, and gix_pathspec::Pattern::normalize()
would start rejecting ./../x. Both look like improvements, but they belong
in a change against gix-path, not in this one.
<csr-id-6171a050bedc7ce0e28db23b6db0c19195fd7a90/> resolve ./ and ../ revspec paths against the current directory, like in Git.
gitrevisions(7) states that a path starting with ./ or ../ is relative to the
current working directory and gets converted to be relative to the working tree's root
directory. gix passed these paths on verbatim, so in a repository with dir/g1.txt
committed, and with the current directory being dir/, git 2.50.1 and gix disagreed:
| revspec | git | gix |
|---|---|---|
HEAD:./g1.txt |
the blob | Could not find path "./g1.txt" in tree |
HEAD:../f1.txt |
the blob at the root | Could not find path "../f1.txt" in tree |
:./g1.txt |
the blob | Path "./g1.txt" did not exist in index at stage 0 |
HEAD:./ |
the tree of dir |
delegate.peel_until(Path("./")) failed |
gix-revision's parser forwards such paths intact on purpose, and the Navigate
delegate documentation promises the conversion, but the gix implementation of it
never performed one.
The tree lookup in peel_until() and index_lookup() now route paths with either
prefix through Repository::normalize_path(). Like Git, this requires the current
directory to be inside a worktree, and paths traversing above the worktree stay
rejected.
<csr-id-4f480b9739ee9ee006da7387b75cb83fb0405de5/> respect filter driver configuration precedence A filter driver declared in user configuration incorrectly won over a repository-local declaration with the same name. A regression test demonstrates both the local property override and inheritance of a user-level property that is not overridden.
Merge repeated named filter sections in configuration order and replace only the properties present in each later section. This matches Git's read_convert_config() behavior in convert.c as inspected at cf5497b14c.
<csr-id-ed9a6503300335aa49d18d95845955815482ba2b/> respect inherited core.symlinks when cloning. <!-- agent --> Load global configuration with the clone open options before repository initialization, and preserve an effective core.symlinks=false as a high-precedence override. Combine that result with probed filesystem capabilities so either source can disable symlinks.
Match Git initialization by persisting core.symlinks=false only when the filesystem probe fails; never write a local true that masks inherited configuration. Add a portable plumbing-built symlink fixture and cover both configuration-false/probe-true and configuration-true/probe-false clones.
<csr-id-639535e73c90f735680c0d0a42045647d7454bdc/> let GIT_WORK_TREE override core.bare
<csr-id-29aa7cd3d72cae5f575aa17bf3f01c61530ece78/> assert fetched pack contents rather than pack checksums
fetch_pack and fetch_pack_without_local_destination asserted the
data_hash/index_hash of a pack produced by the host git. Those cover
the pack's compressed bytes, so they silently encode which zlib
implementation that git is linked against: with a zlib-ng-linked git
(Arch, among others) the 219-byte commit in that pack deflates to 152 bytes
where stock zlib produces 153, making the pack 268 bytes instead of 269 and
changing both checksums.
Nothing about the fetch itself differs — re-deflating the very same object payloads with stock zlib and re-hashing reproduces the expected checksum byte for byte, and every other assertion in both tests already passes.
Assert the pack's object ids instead, read back from the index that was just
written. They hash uncompressed content, so they are identical on every host,
and they are what the checksums were standing in for. num_objects,
pack_version and index_version are untouched; Entry::crc32 is
deliberately not used, as it too is computed over compressed bytes.
<csr-id-3a4350cdaa695d34b70b45ddd6daab2f35d653f8/> remove the tree-editor feature toggle
<!-- agent -->
The workspace MSRV now exceeds Rust 1.75, which stabilized the language feature
that originally required tree editing to be gated.
Make tree-editing APIs available unconditionally.
<csr-id-15809f97614eebe4d667d6e2b1f18e4e704f431e/> add Git-compatible commit signature verification with Commit::verify()
Breaking because it also adds config::tree::Key::default_value(), which gives Any
a default_value field.
<!-- agent --> Expose repository-aware verification on commits while delegating verifier execution and result parsing to gix-object plumbing. Resolve supported signature formats, configured programs, trust thresholds, SSH allowed signers and revocations, repository-relative paths, and commit verification time according to Git configuration.
<csr-id-e768682f603608f795bdab9ea091a22ab4c0df9e/> add commit::Info::generation
That way it's evident if a commit-graph was present for this node.
Breaking, as it adds a new public field to a structure.
need-more-recent-msrv as it's not required anymore
It was mostly meant to be internal, but the name didn't indicate
this, hence the breaking change.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
ed9a650)b1174b6)ebe9095)7424676)gix::Repository (d934f5b)b2d919a)is_dirty()-to-the-current-working-directory (ea9a6d4)44ba4b4)is_dirty() to the current working directory (cb74ef6)f3bbfad)Repository::delete_local_branches(). (61c5e1e)gix-object (object signing) (723d3de)Commit::sign() (8017175)Commit::verify() (15809f9)commit::SignedData::verify() (5b90699)a9f090e)e1c56e4)a30f442)gix-testtools (0cbe539)e5452ba)gix-ref (5810922)dd8c759)gix-odb (1dc741f)gix-odb (a0b93a3)05f905e)566fea1)a8b1be5)<rev>^{/} like Git, instead of skipping it. (6746715)gix-date (613ff86)dbd162d)GIT_ALLOW_PROTOCOL (287ab8f)77b5848)gix-url (2648dc1)gix-url (62e140d)GIT_INDEX_FILE-via-gitoxide.core.indexFile (aa3b006)tree-editor feature toggle (3a4350c)need-more-recent-msrv as it's not required anymore (f1c8911)GIT_INDEX_FILE when opening repositories via discover_with_environment_overrides() (f9b3891)GIT_INDEX_FILE via gitoxide.core.indexFile (e1856d0)ef41caa)gix-refspec. (9fa50a5)95e0213)gix-blame (93d4019)7a34c17)0760b60)368438c)d14aefb)e99f637)232dd1c)5510bce)dffd5ef)./.. revspec paths that leave the worktree, like in Git. (92e3133)./ and ../ revspec paths against the current directory, like in Git. (6171a05)cc3ee80)ab4fcb0)a7e0a2e)4f480b9)5708de4)make_clone_with_symlink fixture archive (18e42fa)4a6cf9d)gix-pack uses the parallel feature (79e3478)b049777)file:// URL in the same fixture (3dabe4a)git path and the URL in the credential-helper baseline (951f40f)command -v rather than which to locate git in a fixture (51afc13)50713b0)config() function (9923d76)da71d06)f03905e)275c26a)639535e)93ad8f9)03ef906)29aa7cd)4b3bf5a)commit::Info::generation (e768682)82711e1)75444cb)ae8845a)
</details>let archived fixtures bypass Git version gates <!-- agent -->
<csr-id-1568b311bfe6babb30330183cb8b8418d23ca94c/> let archived fixtures bypass Git version gates <!-- agent -->
Git-dependent fixture tests currently skip outright when the installed Git is incompatible, even when a checked-in archive contains a known-good fixture that could run safely. This also keeps 32-bit CI pinned to Debian 12 because Debian 13 ships affected Git 2.47.x.
Use the guarded scripted-fixture loaders for minimum-version worktree tests and the shared rev-spec fixture, then return 32-bit CI to Debian stable.
Git 57fb139b5e introduced reversed :/<text> traversal in 2.47.x; Git 0ff919e87a restored youngest-first ordering in 2.48.0.
Repository::normalize_path()
This way, one won't have to use the Pattern + normalize workaround anymore.discover_opts() as sibling to open_opts().This makes isolated discovery easier, at the cost of less control compared to itsgix::ThreadSafeRepository` counterpart.core.fscache on WindowsConnection::configured_credentials_for_current_url().
It extracts the URL from the input action, which is relevant in case
of redirects which changes the initial url.<csr-id-4d4745303ec103165ea541dfa3ebe7f9f3d9f5a8/> avoid treating symbolic remote names as URLs --- agent
Configured remotes without an effective fetch URL exposed their symbolic name as a local-path URL.
Only use a remote name as the missing fetch URL when remote-name classification, a non-file transport, or native absolute-path detection identifies it as a URL.
Git baseline: remote.c:remotes_remote_get_1() adds the explicitly supplied name as a URL when the remote has no configured URL; t/t5505-remote.sh covers remote get-url behavior. This change intentionally diverges for symbolic names.
<csr-id-53515b69e6734c65d3214645b9d93217565f779e/> always treat submodule names as relative. Previously it would assume they are relative, join them with a base path, which could promptly be overridden by an absolute submodule name, which is valid for Git as well.
Code handling submodule paths is now aware and won't accidentally break out of the repository anymore.
<csr-id-d89bda0a87bcfbd4873d1571444ef24d842d2871/> honor credential.protectProtocol for helper exchanges
<csr-id-5f244b32c44795062b0aa9e352404cbd1412a844/> preserve multiple remote URLs
Configured remotes can have multiple remote.<name>.url or remote.<name>.pushUrl
values, but gix::Remote kept only one value because lookup used the singular
config accessor. That meant the most recent config value won, while Git exposes
every effective URL and uses the first one for the singular get-url form.
Add ordered URL storage to gix::Remote and expose Remote::urls(Direction) for
all effective URLs. Keep Remote::url(Direction) as the singular compatibility
API, now returning the first effective URL. Fetch URLs used as push fallbacks
try pushInsteadOf first and then insteadOf, matching Git behavior.
The regression fixture records Git 2.50.1 behavior with git remote get-url: without --all it prints the first configured URL, and with --all it prints all configured URLs in order for both fetch and push.
<csr-id-24293fc8b569131e63929d61c159ac320421cc66/> keep core.worktree-derived worktree paths in the caller's path namespace
Since b1c1cce7, relative core.worktree values from repository-owned
configuration were resolved against the symlink-resolved git dir whenever
that differed from the logical git dir. That is correct when the .git
directory itself is reached through a symlink (#2052), but it also fired
when merely an ancestor directory is a symlink - like /var on macOS,
where TMPDIR defaults to a path inside the symlinked /var/folders.
In that case a submodule repository opened through the symlinked path
would return a canonicalized workdir() while Repository::path() and
all paths the caller holds remain in the symlinked namespace, breaking
prefix-based path logic such as
repo.workdir().strip_prefix(parent_worktree_dir).
Now the symlink-resolved base is only used when resolving the relative worktree path against the logical and the resolved git dir leads to different directories on disk. If both denote the same directory, the logical path is kept, so all paths of the opened repository remain consistent with the path it was opened with.
<csr-id-8f8d6ab5cb47c60872952b3a8a1350297a6376a4/> consume open_path_as_is after resolving repository paths
<csr-id-54a3c2ac4386ec6fcff94be664c8ba1ced139b59/> Repository::kind() detects linked worktrees of bare repos
<csr-id-0a5c62aa0aee5d70a25867aaf8c70c2adb27bec8/> pass through the allocation limit This is particularly important in untrusted repositories, which get a reduced allocation limit.
<csr-id-9fe10501f647c43a992945b2a3e02b224702361d/> gix::open() now handles repo.git directories correctly.
Previously they were incorrectly assumed to be the actual .git repository
and treated as such.
<csr-id-b1c1cce71a936a96f64821d1757e26bff3f883f7/> resolve relative core.worktree from real git dir
some/ (a tree of only empty directories) now collapses to an empty
directory and is skipped when empty directories aren't emitted, matching
Git which treats a tree with no files as clean. See #2490.<csr-id-c3f2244541f0b6419d30782fbae825d33bd5fe16/> replace maybe-async with bisync.
Replace the globally feature-selected maybe-async dependency with bisync 0.3 and
re-export the locally selected macro mode from gix-protocol.
Also use it to deduplicate portions which previously couldn't be handled.
<csr-id-582d7b56cc09cdafaa8db2fb34457f6970c39ce7/> adapt to lifetime-free configuration files in gix-config
Update repository configuration storage, snapshots, overrides, and caches
to use the self-contained gix_config::File representation. Configuration
can now move through repository initialization, cloning, and remote setup
without artificial input lifetimes or conversions to 'static.
BString, PathBuf, OsString, and FullName values
from configuration-derived lookups.Option<Result<T, E>> to
Result<Option<T>, E>, allowing errors to propagate naturally with
?.AsBStr in
configuration setters, converters, remote lookup, and remote saving.Cow construction, into_owned(), and redundant
cloning from configuration consumers.Adapt config-tree conversions for the new owned values and optional-result shape, including booleans, integers, paths, URLs, refspecs, timeouts, compression levels, and reference names.
Return owned remote names, default remote names, branch tracking references, and submodule paths so these results are independent of the repository configuration borrow. Protocol feature values likewise use owned strings.
Update repository opening, initialization, cloning, remotes, filters, status, submodules, and related tests to use the lifetime-free APIs.
gix-config
Marked as breaking explicitly to as we know paramter types were
changed to use convenience traits.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
1568b31)319cec2)b1c1cce)5f244b3)842bc44)cb6ec7d)f0ec710)443b401)31a94aa)2315ede)gix-filter (552402f)02cb162)Repository::normalize_path() (6fe97a9)discover_opts() as sibling to open_opts(). ([2f4c488`](https://github.com/GitoxideLabs/gitoxide/commit/2f4c48801816edc67bae2132156b4c669a312695))e7af50e)271454b)a3e9a77)9949e9f)4d47453)adf4b7a)maybe-async with bisync. (c3f2244)5982dfe)gix-config (6aa934a)e70732a)gix-attributes (e11d7a2)c16b5a1)43ff87a)55b5158)gix-config (582d7b5)402babd)53515b6)299d16b)gix-credentials (f88cf10)cf3053a)d89bda0)27aec47)7056d62)432e2b1)6e1c4a2)f1ac335)6e5a5de)1cda1d1)core.worktree-derived worktree paths in the caller's path namespace (24293fc)d5cd537)1ff51ca)8f8d6ab)b36ca4c)Repository::kind() detects linked worktrees of bare repos (54a3c2a)6d95da6)gix-features, use gix-zlib accordingly. (9c2977a)e9c973d)d533f0c)dc1fdc3)0052e42)0a5c62a)3e43c42)54b5393)a82b492)32cb1ad)core.fscache on Windows (158f899)f2dfdd8)7de7a30)d8aeaac)Connection::configured_credentials_for_current_url(). (a5d4616)gix-transport (6a7a717)f77cb0a)gix::open() now handles repo.git directories correctly. (9fe1050)c31dac2)596ab93)7e17fcf)a7625fa)1e3da34)1b1541e)
</details>adopt the remote's object format when cloning A clone into a freshly initialized repository hit an unimplemented! panic when the remote used sha256, s
<csr-id-e7c748426159d948089d0df0ddc8dab840bc40a4/> adopt the remote's object format when cloning
A clone into a freshly initialized repository hit an unimplemented!
panic when the remote used sha256, since the local repository defaults
to sha1.
Reconfigure the still-empty local repository to the remote's object format and retry the fetch, matching git's behavior of inheriting the remote's hash on clone.
Without the sha256 feature gix_hash::Kind has a single variant, so the local and remote hashes can never differ; the mismatch check is compiled out entirely in that case.
<csr-id-fa42565eb48df91f6671e82074876b99481d74c8/> write fetched remote symrefs as direct refs
Previously gix had made-up behaviour to 'improve' on standard Git,
but it's clear this isn't backed up or tested well enough to be worth
the risk of introducing subtle or not so subtle bugs.
<csr-id-67303164b1960c40332d948071b6d718c277d229/> resolve remote HEAD fetches against remote refs Fetching a local transport remote with a refspec like +HEAD:refs/test/repo could write a symbolic local ref to the client repository's refs/heads/main when the remote HEAD was symbolic and the client happened to have a same-named branch. That made the fetched destination resolve to the local branch instead of the remote HEAD object.
Add a fetch regression that creates distinct local and remote repositories with matching HEAD target names but different commits, then fetches +HEAD:refs/test/repo and asserts the destination is the remote object as a direct ref.
Match Git behavior observed with the local Git checkout: git fetch <remote> +HEAD:refs/test/repo creates refs/test/repo as the remote HEAD object, and Git's remote.c resolves symrefs against the advertised remote ref list.
Fix the unmapped remote-symbolic-ref fallback to peel born remote symrefs to their advertised object id instead of consulting local refs. Mapped symrefs still rewrite to their corresponding local tracking ref, and unborn remote refs remain symbolic.
<csr-id-3b4a6bc63b793607ad689a35d1e3c7bff8941bec/> set trust for GIT_DIR environment discovery A Helix user reported that opening a repository with GIT_DIR set could panic in gix while discovering a repository through environment overrides. The reported reproductions used GIT_DIR=.git with Helix or git --git-dir=.git invoking an editor, and the panic came from open_from_paths() expecting git-dir trust to have already been determined.
The GIT_DIR override path in open_with_environment_overrides() already determines ownership trust for the effective git directory and selects options from the trust mapping, but it did not store that trust in the Options passed to open_from_paths(). Store the determined trust there, matching discover_opts(), so configuration loading receives an explicit trust value instead of reaching the internal expect().
Git baseline: git --git-dir=<repo/.git> --work-tree=<repo> status --short exits successfully.
<csr-id-b859b92b5241a011ebb2bd1b921dc55fd4f7e440/> reject implicit sha1 repos in sha256-only builds A missing extensions.objectFormat means legacy Sha1.
In sha256-only builds, Kind::default() is Sha256, so such repos were silently mislabeled as Sha256.
Resolve the implicit case to Sha1 when supported, else error out to avoid any mislabeling.
Also reject extensions.objectFormat when repositoryFormatVersion is 0, matching git, which treats it as an invalid v1-only extension.
<csr-id-9f432ef509daf09dc1a5bb3cd8201bef81d881ed/> handle loose ref path-prefix collisions
The GitButler branch creation flow reported that
repo.try_find_reference("refs/heads/A/new") could fail with a low-level
NotADirectory error when refs/heads/A already exists as a loose ref. That
lookup is asking whether the longer ref exists; the path-prefix collision
matters to creation/update code, but find should report absence for that
candidate.
Git reference: refs/refs-internal.h documents ENOTDIR as the case where a
ref prefix is not a directory, alongside ENOENT for non-existing refs. For
lookup, both mean the requested ref candidate was not found.
<csr-id-9ad2e24e47d783d5a4296c3ea3eb016faebff8e1/> write new remote sections to the local config file.
<csr-id-2bd9dfe2a8754b3daff230e407c1b3233169cb5d/> Add support for gix_object::Write::*with_known_id() and use it.
This means the Repository::write_object() won't recalculate the hash.
<csr-id-bd2881eb781c85e789b2e7c983621eb1f1993ec8/> handle relative worktree gidir files Git 2.48 can link worktrees with relative paths. In that layout the checkout .git file points at the private git dir relative to the checkout, while worktrees/<id>/gitdir points back to the checkout relative to the private git dir.
Discovery already handled the checkout-side gitdir file, but paths read from the private git dir were treated as-is. That made discovery from .git/worktrees/<id> and Repository::worktrees() proxy base resolution produce relative paths anchored to the process cwd instead of the gitdir file location.
Git reference: /Users/byron/dev/github.com/git/git
worktree.c:write_worktree_linking_files writes both relative links with
relative_path(), and t/t2400-worktree-add.sh covers the resulting relative
files.
<csr-id-92c8130d6df54d3632396650f123864cd54e12a2/> fetching and cloning with refspecs that are tags (in shallow clones) Fix shallow clone refspecs for explicit tag refs
When a shallow clone was created with with_ref_name(), the clone
setup treated the requested name as a branch and generated a refspec
under refs/heads/. For tag names this produced an unmatched required
mapping like +refs/heads/<tag>:refs/remotes/origin/<tag>.
Resolve the requested ref name against the remote before constructing
the shallow single-ref refspec. Branches continue to map to
refs/remotes/<remote>/*, while tags and other non-branch refs map to
themselves.
Baseline Git behavior was checked with /Users/byron/dev/github.com/git/git:
non-shallow --branch <tag> clones keep the normal branch wildcard
fetch refspec, while shallow --depth 1 --branch <tag> clones store
+refs/tags/<tag>:refs/tags/<tag>.
<csr-id-6b5c2ea5b7994bfe96de57cdc50b7c9c176c70fa/> reject deleted prior checkout branches
<csr-id-cd610db8801f101132ba6c3c26a112a1d45a5fd7/> add leaf-only tree-editor removal via Editor::remove_leaf()
Motivation comes from https://github.com/gitbutlerapp/gitbutler/pull/14312,
where callers had to split tree-entry deletions from additions to avoid
accidentally deleting a newly-added subtree after adding A/one and then deleting
A.
Add Editor::remove_leaf() to gix-object and expose it through gix object tree editors and cursors. The new API keeps remove() behavior unchanged, remains tolerant of absent paths, but returns an error when the target entry exists and is a tree.
<csr-id-9929ece41ecfde5cbabf25fc8d7a707d2eb21021/> avoid duplicate network connection when adopting a remote-controlled hash kind. Connections can now be created from detached remotes, internally, which makes them independent of the underlying repository.
This is breaking as it comes with a cleanup of Connection lifetimes,
which will break anyone who stores them in a struct. So hopefully
nobody is affected.
<csr-id-28b726d6900992dc055bb4edd5150b11dccdb22b/> bound the clone object-hash adoption retry The clone fetch loop adopts the remote's object format and retries when it differs from the freshly initialized local repository. Adoption makes the next iteration's hashes match, but if the reopened repository somehow still disagrees the loop would re-handshake forever. Track whether we already retried and fail with IncompatibleObjectHash on a second mismatch instead. The error variant is introduced here, as this is its only user.
Also silence clippy::never_loop on default (sha1) features, where the
sha256-gated continue is absent and the loop always returns first pass.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
9ad2e24)6b5c2ea)6730316)6428edc)da6b267)9929ece)ed998d1)325d2a1)470e689)77e11be)28b726d)e7c7484)a8c5257)00f64fc)fa42565)3755396)590b206)f051396)Editor::remove_leaf() (cd610db)73ffc99)847eb4a)5217d66)52d26d7)discovery_opts to inform about upwards::Options trust handling. (7ba53e1)f1f8b6f)2a5b8d4)5dfb44d)3b4a6bc)c391a12)14a1a11)ad9354e)b859b92)b0155ce)4f089fc)9f432ef)5aadd6e)137794d)b5b2d54)bc4064c)69caccd)gix_object::Write::*with_known_id() and use it. (2bd9dfe)a209dc1)1d80b47)bd2881e)3dd621c)0c1645a)find_custom_refname as in Git (7734fb0)92c8130)a4be01b)f7d4f33)
</details>Add SHA-256 support for object-format parsing.
SHA-256 support for object-format parsing.<csr-id-82c483a98cfe964efd153f9e517565e495a2aecb/> Follow submodule gitdir files when opening and perform basic validation Modern submodules store a .git file in the worktree whose gitdir: value points at the repository to open. The previous resolver treated every non-directory .git path like an uninitialized submodule and fell back to .git/modules/<name>, which can open the wrong repository after a submodule gitdir is relocated or renamed. That shows up as phantom submodule HEAD changes in gix status.
Git baseline: Git setup.c::read_gitfile_gently() parses gitdir: files and resolves relative targets against the .git file location; submodule.c::submodule_to_gitdir() consults that gitfile before falling back to the name-derived .git/modules path.
Update Submodule::git_dir_try_old_form() to validate the submodule name, then follow worktree .git files when present while preserving the old-form directory and uninitialized fallback behavior. Validate present gitdir file targets for direct state/open/status queries so broken submodule checkouts are reported if the gitlink doesn't point to a directory. For status ignore=all, still parse valid gitdir files to keep state accurate, but skip target validation and fall back without error if the gitdir file itself is malformed or unreadable. Derive State::is_old_form directly from whether the worktree .git path is a directory so a divergent modern gitlink is not misclassified as old form.
<csr-id-1f82a9ffa3059b175feec68f05d8fbe835fe9000/> Repository::is_dirty() won't fail on unborn repositories
destination_must_be_empty into Option<bool><csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
Repository::is_dirty() won't fail on unborn repositories (1f82a9f)82c483a)10c58bb)87433ed)f962ed1)d80c534)9013c3f)8606b7a)e75fbfa)2d4a6f2)31c2de3)b8510b2)object_hash to gix::create::Options (b123b4c)db925ec)ba7d9a4)5a37fbd)is_dirty() does when there are modifications. (3406b1d)8af2691)SHA-256 support for object-format parsing. (011316e)a791ea3)a8f7717)278d7ec)0ec3bb7)justfile and automate feature tests (db7b97b)sha1 feature in gix to just set what's needed. (16a6fc4)4743361)1980190)e3d5a04)ab2fee1)2cb17b2)3675a8d)3af9b4a)d3e4c17)1d9bae2)c2ae6cd)23af41a)gix_object::Data (4309fa4)adb8328)
</details>remove winnow and replace it with hand-implemented parsers everywhere. This will allow for simplified maintenance and editing (both human and machine)
<csr-id-91c854e7b9f41738d0fde825cd474b8c00c1a49b/> remove winnow and replace it with hand-implemented parsers everywhere.
This will allow for simplified maintenance and editing (both human and machine)
down the road, and enable additional performance optimisations.
Parser compbinators to me ultimately were a failed experiment as I couldn't maintain them anyway, with it being too difficult for me to grasp and express everything in its very own kind of language, with a lot of different things to consider.
Note that this also removes detailed errors from all parsers that previously
used winnow, with the option to re-add those if there is demand.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
53f880c)gix-object (91bfab0)winnow and replace it with hand-implemented parsers everywhere. (91c854e)4d5ba23)2c3a08e)gix-error (2e2a126)
</details>enforce the specification of alloc_init_bytes to handle untrusted input This breaking change is intended to force a decision about how much memory all…
gitoxide.objects.allocLimitIfReducedTrust.GIX_ALLOC_BYTES and pass them to gix-odb for reading untrusted inputsha256 to gix<csr-id-52485a9eb9d5df81e7f79908134b142cabbe2c04/> do not open .gitmodule files through symlinks
This could lead to places outside of the repository that are attacker controller.
<csr-id-5b229c6f560ff832ca1b2b72032e025e1ca235c3/> Restore Category::to_full_name() to be able to produce any full name.
Previously it learned to reject certain invalid branch names, but this has to
be done separately and led to some unpleasant changes in gix as well.
<csr-id-1adc44c323de3f160dba1d2f76364b89b1e03292/> reject refs/heads/HEAD as branch name during repo initialisation
Also document that refs/heads/HEAD is allowed if FullName was created
directly.
<csr-id-7f77169996b79cb80637465a9456267750f06ff9/> Tree::peel_to_entry() peel to the final tree entry (and only if it's a tree)
<csr-id-b37fef12302160b448191103b1d344e6adf0af6a/> deduplicate entry-finding logic The logic for finding entries is duplicated 3 times.
Use std::ops::ControlFlow for simpler, callback-friendly code.
<csr-id-0e173d6e75df6cfcce86e1f198e4b582d4709909/> std::path::Component has infallible conversion to &[u8]
Instead of relying on a fallible path and using a default value,
we can convert directly between a Component and a &[u8].
alloc_init_bytes to handle untrusted input
This breaking change is intended to force a decision about how
much memory allocation an untrusted party can command by tempering
with binary file formats.imara-diff-v2 with git sliders processing
The slider post-processing imrpoves the diff quality for about 8% slower diffs.
Line-counts, however, will be 50% faster to compute.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
f9fbcba)63b8419)0396152).gitmodule files through symlinks (52485a9)95b0399)alloc_init_bytes to handle untrusted input (91d0c26)alloc_limit tests to validate limit for loose objects as well. (9473d32)alloc_limit_bytes to gix-index (054494f)GIX_ALLOC_BYTES and pass them to gix-odb for reading untrusted input (acffd6b)392336f)7d50c30)d9b358b)gix-object (6df1d55)6f47e98)gix-traverse (a1bd845)2a5db88)e4f380e)imara-diff-v2 with git sliders processing (8094f5d)444a92b)package.include patterns more specific so they don't match ignored files (c2c917f)e51c40b)Category::to_full_name() to be able to produce any full name. (5b229c6)420c5df)6a5a0ec)refs/heads/HEAD as branch name during repo initialisation (1adc44c)a298901)3542230)8a2b474)50fb46f)gix-config. (344218a)af1ad55)gix-config (7bda16a)ec66ceb)6b45cfa)Tree::peel_to_entry() peel to the final tree entry (and only if it's a tree) (7f77169)29c275e)b1102c2)de3f064)fc09ed2)b37fef1)700ad9e) ([df41a64`](https://github.com/GitoxideLabs/gitoxide/commit/df41a64851de31b5b5581b39efe18af4e5becfbc))9a78ae2)3cf53e2)sha256 to gix (dce21dd)98bae84)7eb98cb)2ce6dde)std::path::Component has infallible conversion to &[u8] (0e173d6)
</details>add Repository::reopen() as quick way to reload all configuration and drop caches.
Repository::reopen() as quick way to reload all configuration and drop caches.sha1 and sha256 features to gix.
This way one can control which hashes are compiled in exactly,
while having reasonable defaults automatically.gix::open::Permissions now can be compared, and add is_isolated() method.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
c389a2c)1a72380)gix::open::Permissions now can be compared, and add is_isolated() method. (c80fa4c)26d5197)Repository::reopen() as quick way to reload all configuration and drop caches. (f15911c)6183fd0)5213afe)6bdb331)e8bf096)sha1 and sha256 features to gix. (3832916)gix-hash (e71c703)dad2a82)34d3c17)fa65501)72134f5)6a7287c)cargo machete CI job including exclusions (abd0724)f7277f3)
</details>make status work despite broken or invalid symlinks. Related to https://github.com/gitbutlerapp/gitbutler/issues/12399
status work despite broken or invalid symlinks.
Related to https://github.com/gitbutlerapp/gitbutler/issues/12399nonempty in gix-protocolgix-revision and gix-merge
Adapt gix accordingly (even though it's nonbreaking).<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
ecf90fc)93f39fb)status work despite broken or invalid symlinks. (94b35a1)29040a8)nonempty. (e033441)nonempty in gix-protocol (78b0a6f)gix-revision and gix-merge (231fda4)228caf7)GIX_TEST_FIXTURE_HASH for gix-commitgraph and gix-pack. (d51b858)9327b73)
</details>Differentiate between core.bare being known or not. This allows Repository::is_bare() to only make assumptions based on the configuration value, which
core.bare being known or not.
This allows Repository::is_bare() to only make assumptions based
on the configuration value, which is what Git does.gix-error instead of thiserrorgix-error instead of thiserrorRepository::kind() for better classification
Previously it wasn't clear what it really is as it chose the wrong
categories.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
core.bare being known or not. (02fe02b)d66ac10)28fbeb8)e4f016b)0b0e9f8)c7f84c2)gix-error instead of thiserror (0128df7)gix-error instead of thiserror (b8059ab)44e447b)5c9e6ae)gix-testtools (fb60c8a)8bceefb)7ce3c55)aaf0a76)d820846)blocking-http-transport-reqwest doesn't enable reqwest's default features (c45cdaf)75ac1d0)Repository::kind() for better classification (8ea42ea)e8612b5)gix-error (a304f13)gix-actor (b80d026)f7d0975)
</details>Enable auto-chain-error by default. This way, the behaviour of gix::Error is the same as it was before without actually exposing an Exn error tree.
auto-chain-error by default.
This way, the behaviour of gix::Error is the same as it was before
without actually exposing an Exn error tree.http-client-curl-rust-openssl feature, and make it the default.
Previously it was implicit, now it's explicit so it can be turned off.
When that's the case, the openssl dependencies will be removed.$COMMON_DIR/info/exclude to make excludes work in worktrees.
It turns out there is no per-worktree excludes file either.prodash and crosstermion to the latest version.
This will fix the cargo deny issue as it brings in a newer lru crate.std::ops::ControlFlow where possiblegix-error in gix-date
This will make for easier introspection for users of these errors.Exn::from_iter to raise_all<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
cbbdef5)f8517be)562e684)9d39656)auto-chain-error by default. (08d7966)1c5598e)6cff657)gix-commitgraph (1f58905)ErrorExt::erased() to ErrorExt::raise_erased(). (373fced)std::ops::ControlFlow where possible (5c1bd03)25233ce)Exn::into_box() to Exn::into_inner(). (939b8fc)ae23762)gix-error into gix-revision. (4819ea8)http-client-curl-rust-openssl feature, and make it the default. (3774a03)0a333e5)exn to most pressing needs of gitoxide (abedade)gix-error in gix-date (5ab19a7)10bdf7e)3f0e26e)$COMMON_DIR/info/exclude to make excludes work in worktrees. (4773fd1)ee0a1f6)prodash and crosstermion to the latest version. (2358b1d)c663b3f)7be8f90)d914d95)4edc5dd)9e1ba5e)3bc0c47)211b4fb)
</details>using PrepareFetch::with_ref_name with non-branch refs causes panics
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
b1d6c67)115e208)30d8d5c)3529428)0b29bd3)2ffee22)f087953)ac0af1d)7c59cf4)7d900a6)e29e952)d602d7e)d532bbf)blame-experimental to gix (826effb)d6c5b9d)
</details>respect the :(optional) prefix when interpolating paths via ConfigSnapshot::trusted_path(). Optional, but non-existing paths are now returned as None.
:(optional) prefix when interpolating paths via ConfigSnapshot::trusted_path().
Optional, but non-existing paths are now returned as None.<csr-id-1955b5b1a436518c036cfc9bf642170f9c7b6540/> expose raw commit/tag actor headers for round-tripping.
Note that this means you have to call CommitRef::commiter|author()? and TagRef::tagger()? instead
of assuming pre-parsed fields.
This PR makes signature handling truly lossless for "creative" emails and other info. We now stash the raw name <email> slice on IdentityRef/SignatureRef and fall back to it when rewriting, so even commits with embedded angle brackets round-trip cleanly (might want to expand to other malformed characters before merging? Parsing and serialization honor that flag but still keep strict validation for normal input. I also added regression coverage for these scenarios.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
21fecdf)e4775d2)201ec78)eab774c)9d936fb)e343ed9):(optional) prefix when interpolating paths via ConfigSnapshot::trusted_path(). (580bee9)ab3cce4)c26efb9)f471ac5)6f7b23a)1955b5b)93dd630)703644c)
</details>add Repository::worktree_proxy_by_id(id). That way it's more straightforward to obtain information about worktrees which are known by ID.
Repository::worktree_proxy_by_id(id).
That way it's more straightforward to obtain information about worktrees
which are known by ID.Handshake::ref_map() to produce a ref-map from a V1 or V2 handshake.Repository::set_workdir().
Force this repository instance to use the given worktree directory.<csr-id-f7700e452c79ff5582626bb3377d0429a921d869/> refspec for shallow clones uses a single-branch When doing shallow clones (depth != NoChange), it now uses a single-branch refspec instead of fetching all branches. This matches Git's behavior and significantly reduces the repository size for shallow clones.
For shallow clones:
This addresses issue #2227 where gix clone --depth 1 was creating
repositories ~130MB vs Git's ~70MB due to fetching all branches.
diff.algorithm in Repository::blame_fileserver parameter.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
f7700e4)82ff92f)b20d9e9)b170451)3c2b422)service parameter back to not hardcode the handshake for fetches. (c9a97db)server parameter. (36c2be8)2f14246)Repository::worktree_proxy_by_id(id). (a004329)c3beb20)37e7e02)0ac3080)Handshake::ref_map() to produce a ref-map from a V1 or V2 handshake. (aeee982)gix-protocol: Outcome -> Handshake (a61b2ab)48fdf5d)19a0051)50120de)37ab036)f05dfab)c2c1a61)ba2301f)c400dd3)gix-date (2bcac0c)3087b76)gix-date (d5e194d)bc62b1e)c331afc)ab44f45)385ab16)2a187ca)diff.algorithm in Repository::blame_file (bb2cec0)663b41e)Repository::set_workdir(). (0ed0164)6e89afa)c2050d0)fbf9c39)
</details>2 commits contributed to the release.
<csr-id-6f469a6fea59c88e6c69a5f94b0bc8a5977cb75b/>
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
bdcce5f)doc_auto_cfg feature to fix docs.rs documentation. (6f469a6)3313233)
</details>replace Reference::peel_to_id_in_place_packed Also, update documentation where it was still referring to deprecated in_place methods to refer to the n…
<csr-id-03804965f5723de001349cf3fe7399ac4815c9ef/> replace Reference::peel_to_id_in_place_packed
Also, update documentation where it was still referring to deprecated
in_place methods to refer to the new methods instead.
<csr-id-1d4a7f534d076d2793a8f17a36b11212ddc84d6e/> ability to change the fetch url of a remote
The remote has a couple of "builder" methods to change
is fields, e.g. push_url for setting the push url.
A builder method for changing the fetch url of a remote
was missing. This makes it impossible to fully replicate
the functionality of git remote set-url.
<csr-id-b6fbf053925d6530ca97e75bf1d99402eb98f202/> replace Head::(try_)peel_to_x_in_place with Head::peel_to_x.
The _in_place() suffixed methods are now deprecated.
<csr-id-3c0b7374f113017e47d384ccc799a8ada368855c/> Add Repository::new_commit and Repository::new_commit_as() methods.
<csr-id-cdb1100d7ec85868298c5ebe30d2bc5711c4b7eb/> add Repository::blame_file
<csr-id-fa1287f2e218a0959700cb858b41465f315db9d9/> Add gix::discover_with_environment_overrides()
<csr-id-6693ab9bfc123eb0cb8fb7a35654e01fe5853318/> support diff.ignoreSubmodules overrides in status
<csr-id-620d275beacf5f47c2ec56c9d077e7121b9570ca/> deprecate Remote::push_url*() in favor of Remote::with_push*().
<csr-id-e0879603475051c65cc2fe39f768fc71b53181b6/> remove special handling for empty blob hash to match Git behaviour This feature was recently introduced, but was never released.
<csr-id-2fc9dbe7e5ee7a0d122ee3ed9c94f7e9f8ee3afc/> empty blob hashes are now automatically considered present.
<csr-id-ba563b0e39ebc3ce635f399accd8a4be5210f816/> extend lifetime of iterators
Previously the iterators would return references with lifetimes that
were shorter than the actual lifetimes of the gix::Reference
themselves. This was dues to a footgun with '_ (eliding the lifetime).
When a function returns an elided lifetime, this lifetime usually is the
lifetime of the &self parameter, but sometimes it is the lifetime of
the type itself (e.g. Iter<'_>).
I made the lifetimes explicit to ensure we were using the correct ones.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
89fb308)4da2927)b188a7d)6cc8464)gix-blame (268dac4)9365cc3)838ff95)442f800)Reference::peel_to_id_in_place_packed (0380496)51f998f)Remote::push_url*() in favor of Remote::with_push*(). (620d275)1d4a7f5)81c0c16)d302fa2)Head::(try_)peel_to_x_in_place with Head::peel_to_x. (b6fbf05)3499050)ca99882)e60e253)b9c7a7e)e087960)f891c37)d4c2542)Repository::new_commit and Repository::new_commit_as() methods. (3c0b737)1a4c84d)689d839)2fc9dbe)42f8db5)gix-ref (44922d0)bd47fb5)blame to extras, and asssure it's tested separately on CI (3c54e5b)752d6dc)0e7aa81)gix-features, use libz-rs-sys directly, skipping flate2 (5a2361b)768164a)Repository::blame_file (cdb1100)gix-blame performance regresion (8dc5e98)eee5199)888b763)ad1e2ed)8e451cf)c149116)gix tag list when JSON is requested (fb2766b)gix::discover_with_environment_overrides() (fa1287f)a4b0d2c)make_remote_config_repos archive (c8c84e4)git config to make overlapping remotes in a test repo (4de96fc)git remote failure clearer in make_remote_config_repos (8cabd16)f3be6e3)gix-status (5da38e5)dc7343c)79ba9d0)651f9fa)4289ae6)d4dd783)453bb2c)diff.ignoreSubmodules overrides in status (6693ab9)04a18f3)d4130c3)ba563b0)202bc6d)d64f257)589d63e)007e3f6)91b3220)784c046)
</details>allow querying Repository::submodules() in an unborn repository. It's a breaking change merely because the error type changed.
<csr-id-b7c1f2c25c7485095022fec290492aa4b7c5c5a2/>
repo.references().pseudo() for traversing refs like HEAD and FETCH_HEAD.Repository::committer_or_set_generic_fallback().
That way one can always obtain a committer, even though it might
not represent the entity actually committing.revision::walk::Platform::hide().
This finally makes safe traversals possible and is what most people would want to use
instead of boundary().gitoxide.parsePrecious configuration key to opt-in to precious file parsing.Repository::is_empty() to emulate the similar git2 APIRepository::merge_bases_many() for simplified retrieval of multiple mergebases.tree::EntryRef::to_owned().
That way it's in a more reasonable spot as sibling to Entry and it's clearer how to convert noe into the other.EntryRef::kind() as shortcut for EntryRef::mode().kind().remote::Connection::ref_map() doesn't finish the handshakeRepository::branch_remote_ref_name() won't fail on short names anymore.
Instead, these partial names are turned into branch names, which seems more
in line with what Git can do.strict_config in conjunction with GIT_WORK_TREE no longer triggers an error.Repository::submodules() in an unborn repository.
It's a breaking change merely because the error type changed.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
strict_config in conjunction with GIT_WORK_TREE no longer triggers an error. (3f85bf5)remote::Connection::ref_map() doesn't finish the handshake (427274b)5a919c4)65037b5)60c29a5)43f92b5)repo.references().pseudo() for traversing refs like HEAD and FETCH_HEAD. (2affbab)5335c84)gix-diff (a0cef8b)dab97f7)a9a8ea1)3f2be40)-t bad (73a30f8)c2eb0c1)e8b7a4e)bfb1c34)554ce13)Repository::branch_remote_ref_name() won't fail on short names anymore. (a75b4a2)5cf6d05)Repository::committer_or_set_generic_fallback(). (d7db360)62e4bab)298f22e)b7c1f2c)92febae)revision::walk::Platform::hide(). (a9befb2)f8d7c0a)151e3a5)b199c6e)subomdule.<name>.ignore = all is handled correctly. (657dec4)40f5a56)gix manifest rust-version in all MSRV checks (654a8fa)5f9de52)gix-ignore and gix-glob, and more. (4ef7806)gitoxide.parsePrecious configuration key to opt-in to precious file parsing. (85a24b3)7ae3797)Repository::is_empty() to emulate the similar git2 API (b985766)Repository::submodules() in an unborn repository. (26ae766)648022b)f0ed2cc)c3f06ae)d2b4c44)fdfb239)Repository::merge_bases_many() for simplified retrieval of multiple mergebases. (f687cb1)7a33e2a):/ baseline skip (b623bf1):/ baseline skip from CI to local and extend (2400158)189d1a0)28935a5)tree::EntryRef::to_owned(). (3a5068e)800738a)4408166)EntryRef::kind() as shortcut for EntryRef::mode().kind(). (3ef6b55)8d4c4d1)
</details>3 commits contributed to the release.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
e104545)5f7f805)631f07a)
</details>Adapt to changes in gix-actor Use the committer date and author date that are now backed by bytes and interpret these bytes into a gix_date::Time on d
<csr-id-b07f907ba2e01849744c72df35dac57b624f2f85/> Adapt to changes in gix-actor
Use the committer date and author date that are now backed by bytes and
interpret these bytes into a gix_date::Time on demand.
<csr-id-ca165174e3502aa75e74ef90728d192f517f4406/> correctly handle safe.directory for worktrees
<csr-id-24d235d7a6bdb01c5c1cff79b5be14f1d5afa11a/> safe.directory now applies to configuration as well
This means that repo-local configuration that is considered safe, ideally with
safe.directory=safe/dir/* notation, will be usable for sensitive operations.
<csr-id-38b63c2fc9d407b3c634d8b0c72d4d0c104aa5ad/> make fs::walkdir_sorted_new() sort entries by paths literally
This follows up 7b1b5bf864e74706aefeb1213e8bdb0545d5464a. Since packed-refs
appears to be sorted by full ref name, loose-refs should also be emitted in
that order.
The comparison function is copied from gix::diff::object::tree::EntryRef. Non-utf8 file names are simply mapped to "" on Windows. We could add some fallback, but callers can't handle such file names anyway.
RelativePath for prefixed ref iteration.
Its type captures the requirements better.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
5396b2b)fs::walkdir_sorted_new() sort entries by paths literally (38b63c2)cc5b696)49fa9f3)db0b095)0bf84db)3b1bef7)c3c6504)6f009d7)gix-date and gix-actor (afdf1a5)70097c0)b07f907)737bb49)359914c)9e075b9)96164c5)fdc06b1)294902e)RelativePath for prefixed ref iteration. (a6d7d70)cd1a777)edb449c)3c16e53)5823b22)Cargo.toml files in workspace to gix-features bump (6315536)71275d1)gix-ref. (52142b4)57c9014)3aec7fb)9f1fbc7)b5e9059)68e6b2e)507d682)3ca6811)1612c73)fc5faf2)7502b4a)6307f57)8969245)420e730)
</details>read config losslessly even without debug_assertions This should hopefully not be a breaking change, as the same code could produce the same behaviour…
<csr-id-866affde8ef17f201884b8a4b36cc4c7f449d6fe/>
debug_assertions
This should hopefully not be a breaking change, as the same code
could produce the same behaviour if compiled with different flags,
and the semantic meaning of the resulting configuration should be
the same. But Hyrum’s law is always lurking…Repository::checkout_options().
It's a low-level set of options to drive (quite unsafe) checkouts.
They are unsafe as they may be configured to overwrite, and are in no
way similar to git checkout.Repository::head_tree_id_or_empty() for convenience.Repository::workdir_path() to easily obtain a Path for worktree items.Repository::workdir() as replacement for Repository::work_dir().
Keep the latter as deprecated though.filter::Pipeline::worktree_file_to_object() now can add Commit type objects.filter::Pipeline::worktree_file_to_object().
That way it's easier to correctly add whole files into the object
database.repo fields public for ease of use.
That way, functions or methods taking such a type as argument
have access to the underlying repository so it doesn't need
to be passed as separate argument.blob::platform::Resource::intern_source_strip_newline_separators()
That way it will be easier to have typical Git-style patches diffs around
files that don't end with a newline.Repository::big_file_threshold() to easily learn what Git considers a big file.<csr-id-aa8daf89bcc3c26baeb7d850c19bb9a5d403f555/> Don't panic when rev-parsing ^^^ and similar
<csr-id-dcdb8eae4b5c7897bef752a66bc17a8ee662da97/> filter::Pipeline::convert_to_git() now also works on Windows under all circumstances.
<csr-id-9bec947deb4313a9d1eb701555d96ea829132976/> assure Repository::commit_as() also uses the committer for reflogs
Previously it would retrieve the configured committer, or trigger an error
if there was none despite the commiter being provided to commit_as().
This als adds Repository::edit_references_as(committer) to allow passing
a given committer.
gix_hash::hasher, and we now use
sha1-checked unconditionally.with_pruned() is doing by renaming it to with_boundary().
This is how it acts, and it's not at all the same as hide() in git2.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
Repository::commit_as() also uses the committer for reflogs (9bec947)^^^ and similar (aa8daf8)d248e3d)ada5a94)b41312b)38dff41)4660f7a)gix_object::{try_ =>}compute_hash users (3d7e379)fbf6cc8)fd12ef8)cd96b64)gix-features (5f8bff8)32b54b3)5cb5337)gix_fs::stack::ToNormalPathComponents everywhere. (1f98edb)impl returns in traits. (569c186)bfa3253)filter::Pipeline::convert_to_git() now also works on Windows under all circumstances. (dcdb8ea)7b17da6), just before ) on same line in function calls (66a5ae1)01bd76d)7255a5f)5a1b3d6)316f113)5e618b6)8b1b55c)config corruption" (9061fc4)config corruption (d290ad9)0bf1d5b)dc8bd63)GIT_AUTHOR_NAME or GIT_COMMITTER_NAME are set (94dda22)Repository::checkout_options(). (5054780)Repository::head_tree_id_or_empty() for convenience. (02878c9)Repository::workdir_path() to easily obtain a Path for worktree items. (776f9be)Repository::workdir() as replacement for Repository::work_dir(). (518fbbc)10e41ee)cf7f34d)debug_assertions (9800e9c)16a248b)8e96ed3)b4fe425)Repository::commit() now explains how to create a commit without ref updates. (866affd)503098d)5c327bb)filter::Pipeline::worktree_file_to_object() now can add Commit type objects. (27e62d7)c042813)filter::Pipeline::worktree_file_to_object(). (70ebd5f)repo fields public for ease of use. (23d2bed)914bf28)blob::platform::Resource::intern_source_strip_newline_separators() (37582b0)daa6d4a)with_pruned() is doing by renaming it to with_boundary(). (b78e7dd)79cb655)d7ddbb7)687322b)1a69c40)Repository::big_file_threshold() to easily learn what Git considers a big file. (f3257f3)8df0db2)
</details>remove unused fetch-error variants Note that it's a breaking change, but it's on top of a previous breaking change so folks would already have to upda…
<csr-id-17835bccb066bbc47cc137e8ec5d9fe7d5665af0/> <csr-id-9db21601b61601c01cd2419543e2c461a7dd568d/>
Repository::upstream_branch_and_remote_name_for_tracking_branch()
It's a way to learn about the Remote and upstream branch which would
match the given local tracking branch.tree::Editor|editor::Cursor::get() to see if an entry is loaded at path.
This can be useful to get a feeling for how far the tree was already made available,
even though it won't reveal if an entry was edited.Repository::is_dirty() now also checks for tree/index changes.
This copmpletes the is_dirty() implementation.Repository::tree_index_status() to see the changes between a tree and an index.
It also respects status.rename and status.renameLimit to configure rename tracking.Tree::depthfirst() with a delegate.
This allows a depth-first traversal with a delegate.blame plumbing crate to the top-level.
For now, it doesn't come with a simplified gix API though.<csr-id-cd8fabf583e75f59feda7a78b8710f26a8200cbb/> Repository::status() detects files added to the index in an unborn repository.
Previously it wouldn't show them.
<csr-id-84019cb42cff153c305cb718307493df42a134a4/> Respository::status() iterator won't fail in unborn directories.
<csr-id-bc022845ace1962a2a85f9272cdbc0cf24745c62/> worktrees of submodules now know their correct worktree Previously they would use a very incorrect worktree which would cause the status to be calculated very wrongly.
<csr-id-3bbd1f7b60b09f9862ee88293c316a359d79e3d8/> status-iterator won't swallow legitimate modification during 'racy-git'. When a modification is marked as being racy, then previously the iterator would have kept the whole modification even though it should just have tracked the single change.
This made the legitimate modification disappear.
<csr-id-a03bde58176e68850fa2d3299f9901a9b36b892f/> write_blob_stream() does not need Seek trait anymore.
Internally, it has to turn it into a buffer so it's not needed anymore.
It also counteracts the idea of using a stream with arbitrarily big files.
<csr-id-a987e682aefa352ceaffa05d56545c9bc9c14934/> Submodule::status() now konws about tree-index changes as well.
This completes the status implementation.
<csr-id-51a430114493de392ce0c60f462d6e3ff36475a4/> remove unused fetch-error variants Note that it's a breaking change, but it's on top of a previous breaking change so folks would already have to update explicitly.
<csr-id-801689b4aa860e1054dd9362a59d76077f31f248/> add status::Platform::into_iter() for obtaining a complete status.
Note that it is still possible to disable the head-index status.
Types moved around, effectivey removing the iter:: module for most
more general types, i.e. those that are quite genericlally useful in
a status.
config::Snapshot access now uses the new Key trait.
That way one can officially use "section.name" strings or &Section::NAME.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
Repository::status() detects files added to the index in an unborn repository. (cd8fabf)dea106a)1f6390c)90e08f1)fe33fa7)4c8200f)47e44c5)Respository::status() iterator won't fail in unborn directories. (84019cb)34fa6bb)gix-status (25d480c)e4fb21e)dbf079f)af8f201)Repository::upstream_branch_and_remote_name_for_tracking_branch() (da0e1c7)gix-refspec (6d7dd9b)7ec21bb)rust-version to 1.70 (17835bc)Repository::worktrees() lists linked worktrees. (9db2160)bc02284)1ca480a)9193b05)8d84818)5b6e5c8)af704f5)tree::Editor|editor::Cursor::get() to see if an entry is loaded at path. (3b53982)3bbd1f7)write_blob_stream() does not need Seek trait anymore. (a03bde5)0ab4f64)Submodule::status() now konws about tree-index changes as well. (a987e68)status::Platform::into_iter() for obtaining a complete status. (801689b)config::Snapshot access now uses the new Key trait. (a6f397f)Repository::is_dirty() now also checks for tree/index changes. (8ae9e57)Repository::tree_index_status() to see the changes between a tree and an index. (83f3d93)Tree::depthfirst() with a delegate. (592e250)gix-traverse (1de4e70)6ed9976)blame plumbing crate to the top-level. (25efbfb)7659a65)3fb0c18)51a4301)d22937f)
</details>remove unused fetch-error variants Note that it's a breaking change, but it's on top of a previous breaking change so folks would already have to upda…
This is a breaking change as some types move and change the layout.
<csr-id-c0f4da5ef4791370c98f34f0eb3bb5773edbba32/> Adjust gix::dirwalk::Options::{X,set_X} parameter names
This adjusts the names of parameters to X and set_X methods of
gix::dirwalk::Options (where X is an option name) to use a
systematic naming convention:
X, the X and set_X methods now always
have the same name of the parameter that specifies a value for an
option.merge::tree::TreeFavor similar to *::FileFavor.
That way it's possible to control how tree-conflicts should be auto-resolved.Id.
This makes these types easier to use as it's enough to pass a wrapped type
to perform more actions on the underlying repository.<csr-id-e59fc09f12a1c6b27d878525ff6074ac846aa87e/> move all possible code from gix to gix-protocol.
For now, just move the code down and immediately re-integrate in gix
to be able to use its tests to validate it.
This is a breaking change as some types move and change the layout.
<csr-id-6367c7d0a796aff8ee8778916c1a1ddae68b654d/> Add gix-shallow crate and use it from gix and gix-protocol
That way it's easier to reuse shallow-handling code from plumbing crates.
Note that this is a breaking change as gix-protocol now uses the gix-shallow::Update
type, which doesn't implement a formerly public from_line() method anymore.
Now it is available as fetch::response::shallow_update_from_line().
<csr-id-bd905a6f151ac7f3153f5208ef7c2d686f372c30/>
<csr-id-ea8b95f4df8a6b06aa393acd907f6400785661ff/> symlinks_to_directories_are_ignored_like_directories by value
The methods of gix::dirwalk::Options are paired, where for each
option X of Options, a method named like X takes and returns
self by value, and a method set_X takes and returns self by
mutable reference.
But in symlinks_to_directories_are_ignored_like_directories, both
took self by mutable reference. This fixes that. The effect of
this fix is to allow building Options with a call to that method
as the last factory method call (and using it where Options is
accepted but &mut Options is not).
Most code that consumes the crate should be unaffected, but:
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
beb0ea8)c1ba571)7ea8582)df5cead)14c3744)cbdbb8a)9662bc1)d0df20a)ca54b8c)gix-protocol (41b6571)a542775)gix-protocol (25b8480)ddeb97f)gix and gix-protocol (fcb21a4)gix to gix-protocol. (e59fc09)gix-shallow crate and use it from gix and gix-protocol (6367c7d)cd9060a)c0f4da5)ea8b95f)f8ba4b9)regex_matches partial suppressions (f4b4bf0)520c832)gix-diff (960773e)gix-merge (aaeb427)bd905a6)Id. (efc71fd)gix (b2b8181)merge::tree::TreeFavor similar to *::FileFavor. (e17b3a9)gix-merge (3228de6)e8b3b41)
</details>Add support for index application in merge results via merge::Outcome::index_changed_after_applying_conflicts()
<csr-id-71b0ceaf02e022e83e6c24cfd0bdc26299dc95a0/> Add support for index application in merge results via merge::tree::Outcome::index_changed_after_applying_conflicts()
<csr-id-65ae68eac6b77d12ca804927090da5bb80551eae/> add Repository::merge_base_octopus()
<csr-id-7aee32abef13f5bf331249fed38e1e6b3e12876a/> add Repository::virtual_merge_base() and Repository::virtual_merge_base_with_graph().
<csr-id-5f3f63a05d1e594d92dbff75ce7293f9f163b397/> add Repository::merge_commits()
It's often more convenient to work with commits when merging, especially
when merge-bases are dealt with automatically.
<csr-id-27b663e4116c5aaa7b898283379d4d7d49a30865/> add objects::tree::Editor::detach() to get the underlying editor back.
This can be useful to have more control over what gets written, or how.
<csr-id-1f9556a7e4b89f00c4de091b50909a8d2081f0d4/> add Repository::index_or_load_from_head_or_empty().
It's useful to get a reasonable index in any case, even on unborn repositories.
It's for cases where the HEAD isn't setup at all, despite content being available,
and to avoid unnecessary restrictions on what works.
<csr-id-2fce14ff4724ddc2f1a13c8686a7f221f8d2024e/> add Object::peel_to_commit() to assure an object turns into a commit.
<csr-id-d1ac584d9098988e66091217db4264d69fb77282/> add Repository::merge_trees()
<csr-id-07746f3ccf3e5c71f12319cfd2fb069b5f380624/> gix::Repository implements all traits for object reading and writing.
That way it becomes usable when merging trees, which benefits from automatic
checking of hashes before writing loose objects.
<csr-id-4b1764ca9148e08ae9f11bca68e0689b12bc8c80/> add tree() and commit() merge support, en par with merge-ORT as far as tests go.
Note that this judgement of quality is based on a limited amount of partially complex
test, but it's likely that in practice there will be deviations of sorts.
Also, given the complexity of the implementation it is definitely under-tested, but with that it's mostly en par with Git, unfortunatly.
On the bright side, some of the tests are very taxing and I'd hope this means something for real-world quality.
<csr-id-b57be7189df216110adb52aa51c50a0f38692f2a/> Repository::tree_merge_options() now comes with rewrite tracking.
This is the way Git acts, as it's either configured, or defaults to the value
coming from the diff.renames configuration.
<csr-id-88d9d4387287b7540a0f42b26c6a4adb4cd769a9/> respect core.bare=true in conjunction with the main worktree
<csr-id-dc3d8bf79e90733172a2c3796995cdfbed438355/> propagate errors that are triggered when writing objects Previously it was assumed that writing objects could never fail unless there isn't enough memory to do so. However, it turns out that some last-minute validation can always be triggered and prevent an object to be written.
Now that error is propagated instead.
<csr-id-4079519e7e292ee193248e3acea6587788c6b884/> assure submodules are skipped everywhere
This also adds Repository::head_tree() for convenience.
Repository::merge_trees() now takes portable version of Options.Repository::merge_trees() now has a fully-wrapped outcome.
That way, more attached types are used for greater convenience.<csr-id-254793581a135553e555f0bcc815154bb0951324/> rename blob-merge feature to tree-merge.
By now, blob-merge is the lowest-level of features which is required
for both tree-merges and commit based merges. Hence it's better
to just call it merge.
<csr-id-de1cfb6a9caf5ac086c6411824835c75e888e2d7/> Adjust blob-merge baseline to also test the reverse of each operation This also fixes an issue with blob merge computations.
It's breaking because the marker-size was reduced to u8.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
core.bare=true in conjunction with the main worktree (88d9d43)4000197)8ce4912)bc9d994)0b7abfb)index application in merge results via merge::tree::Outcome::index_changed_after_applying_conflicts() (71b0cea)Repository::tree_merge_options() now comes with rewrite tracking. (b57be71)gix-merge. (47110d6)aeaebec)== size assertions (daf9990)<= on 32-bit for some size assertions (fc13fc3)9ab86a2)275a0c5)49ba115)7a40648)0f0e4fe)cf0c7ee)Repository::merge_base_octopus() (65ae68e)905e5b4)Repository::virtual_merge_base() and Repository::virtual_merge_base_with_graph(). (7aee32a)Repository::merge_commits() (5f3f63a)c5955fc)hasconfig is working on gix level as well. (d51aec9)697a632)4079519)a876533)Repository::merge_trees() now takes portable version of Options. (a43e563)blob-merge feature to tree-merge. (2547935)Repository::merge_trees() now has a fully-wrapped outcome. (1d2262f)objects::tree::Editor::detach() to get the underlying editor back. (27b663e)Repository::index_or_load_from_head_or_empty(). (1f9556a)Object::peel_to_commit() to assure an object turns into a commit. (2fce14f)5b428a9)8e99eba)chmod in make_rev_spec_parse_repos; regenerate archive on macOS (d74e919)72cd7f3)8720acb)3fb989b)Repository::merge_trees() (d1ac584)gix::Repository implements all traits for object reading and writing. (07746f3)80e006b)tree() and commit() merge support, en par with merge-ORT as far as tests go. (4b1764c)gix-object and gix-odb (96488f7)de1cfb6)db5c9cf)
</details>add Repository::diff_tree_to_tree() for greater similarity to git2
<csr-id-64ff0a77062d35add1a2dd422bb61075647d1a36/> <csr-id-743695fc345b59e30e75fb6b91357ab7e994bda2/> <csr-id-45b71554f6437fbfe3ead020ff182f77cd57e47f/>
<csr-id-b279957beaf581c16293343dbdb2121bd1d4dd1c/> <csr-id-7249291016253647c920852fb37eb9e29d615775/> <csr-id-3abf0432dad4d47d0fd70ae8a9fadea0ef82dba3/>
<csr-id-2b81e6c8bd30cc95e91cc92a89f0a0e6047eec6b/> add Repository::diff_tree_to_tree() for greater similarity to git2
<csr-id-3da2da9d7993adc16b19fc63e7524c768a6e2e7f/> add gix merge-file with similar features as git merge-file
<csr-id-c02adc736c9c150d2eb71307a13adfa5f35e9d47/> add Repository::blob_merge_options() to obtain options for merging blobs and Repository::diff_algorithm()
<csr-id-19374800ebfa19b0ddc5c2f30d1c42324732a34e/> Repository::merge_resource_cache() to obtain the foundation for merging files directly.
<csr-id-0cac69077e738cb22914e77a9a9dd3fd712d5670/> make implicit free-list more controllable
This is done by three new Repository methods:
empty_reusable_buffer() - hook into the free-list yourself.set_freelist() - enable or initialize the free-list.without_freelist() - a builder to disable the freelist from the start.GIT_WORK_TREE variable work as expected.
Now it's picked up durign initialization.rev_walk available even without the revision feature.
Technically it doesn't depend on it.<csr-id-7be142d087a736339af54f2cb894edc7c36cdc90/> optional rename tracking for directories. Depending on the source of the rename-information, items that are children of renamed parents may be provided to enable rename tracking based on these containers, instead of always resorting to tracking leaf nodes (i.e. blobs).
<csr-id-14d6bb92b42cb882b0fd6d0ae3c38fa634eacdaa/> Support for 'fast-tracking' reaching the beginning of the commit-graph during traversals. It's implemented by sorting commits oldest first when choosing the next one to traverse, which can greatly reduce the time it takes to reach the first commit of a graph.
<csr-id-dfbc732effc0fd1c90aba9c736a670d244c042e0/> optionally store objects new objects in memory only.
The default object database changed to a version that allows to
keep objects in memory. This needs a mutable Repository instance
to setup.
<csr-id-d63ec06500386450f6f7b9e3b9d23ad759371832/> Do not let revision::walk::Platform rely on plumbing crate types.
This is a step towards a more stable API, but also, will allow using
different implementations.
Notably, this replaces gix_traverse::commit::simple::Sorting with
gix::revision::walk::Sorting.
<csr-id-206f5d70fa74c23c56c6cbecc5625234fde930fc/> improve error messages when failing to find references. It's breaking due to changes in the error type.
<csr-id-9e79ba37cf5dc7c0c295218b2de67b4b2eeff443/> unify location of error type of Repository::diff_resource_cache().
<csr-id-c545d71ebfd4ac7d960fc75aae5558b341d8ecf2/> Tree::lookup_entry() looses its buf argument.
The buffer will now be previded from the free-list of the repository.
<csr-id-17573779688e755a786546d5e42ab533088cd726/> remove all workspace dependencies The problem is that with them, we don't notice anymore if the crate changes, because a dependency changes. That also means that older versions of the dependency may stay even though some other crates might pick up a newer version.
Ultimately, this will lead to drift and subtle incompatibilities.
We declare this breaking to enforce a proper re-release.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
977b81b)f1364dc)3f7e8ee)48aa74b)GIT_WORK_TREE variable work as expected. (e9b3db8)b36d7ef)206f5d7)2622936)e51fcd0)c949030)155b5e1)53fa8ab)ddc99b5)795962b)64ff0a7)6487269)diff::tree::ChangeDetached (c18ebbe)f8952e4)37c1e4c)3745212)Repository::diff_tree_to_tree() for greater similarity to git2 (2b81e6c)743695f)tree_with_rewrites plumbing implementation. (45b7155)gix-diff (3fd9fab)af03832)gix-diff (2bf1e5f)7be142d)gix-diff (5c1f010)5ffccd2)gix merge-file with similar features as git merge-file (3da2da9)Repository::blob_merge_options() to obtain options for merging blobs and Repository::diff_algorithm() (c02adc7)Repository::diff_resource_cache(). (9e79ba3)Repository::merge_resource_cache() to obtain the foundation for merging files directly. (1937480)e0b09d2)2261de4)WorktreeRoot API provided by gix-diff (25c6806)20f9b3f)14d6bb9)612896d)gix-protocol (0d3b480)73a7d15)0cac690)7c2af44)694ebad)c2bdda4)b12c7c9)22fbe70)fe1eb97)5242aad)jj_realistic_needs_to_be_more_clever on Windows (3adcfc5)93e86f1)012a754)d69c617)dfbc732)Tree and Repository. (b279957)Tree::lookup_entry() looses its buf argument. (c545d71)1cfe577)0fe5133)gix-revwalk (ea403a4)750e268)877f4d2)649f588)gix merge-base for the CLI (7249291)Repository::merge_base() (3abf043)gix-revision (ce5a320)beba720)37ba461)fc45c93)2e0ce50)c3a7dcf)29ad2df)f992fb7)ec69c88)e82f795)revision::walk::Platform rely on plumbing crate types. (d63ec06)rev_walk available even without the revision feature. (c515edd)46cd1ae)1757377)
</details>A maintenance release without user-facing changes.
A maintenance release without user-facing changes.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
b3ff033)209b6de)
</details>add objects::diff::Platform::stats() to quickly obtain diff-stats. This function is inspired by git2 which also makes it very simple to obtain.
<csr-id-26748ddbedc281b7b6b1defc51201d97e58f13e4/>
objects::tree::diff::Platform::stats() to quickly obtain diff-stats.
This function is inspired by git2 which also makes it very simple to obtain.Change::detach() and ChangeDetached::attach().Reference::follow_to_object()
It's an equivalent to git2::Reference::resolve().`Repository::diff_resource_cache_for_tree_diff()Reference::peel_to_kind()
Make it easy to follow a ref and peel it to a given object type.
Additional peel_to_<kind>() shortcuts are also provided, with
the same name as in git2.Repository::find_*() methods for every object type.Repository::compute_object_cache_size_for_tree_diffs().
With it it's easier to obtain reasonable object cache sizes as optimized
for tree-diffs.remote::Name::to_owned() to get a static version of it.
Also, add optional serde support.Reference::remote_name() now also provides valid remote names for local tracking branches.Reference::peel_to_id_in_place_packed() to allow passing a packed-buffer snapshot.
This is useful for speeding up reference lookups as otherwise, it will have to validate the packed-buffer
snapshot didn't change internally each time a ref is peeled.remote::Names as shortcut to the value returned for all remote names.<csr-id-6990afd269c3461ae22e2821164c03a0dedc82f4/> similarity detection Previously it would incorrectly count only the last batch of removed bytes, and now it will count all of them. This leads to realistic results with complex diffs, even though it's probably still not en-par with Git which uses more complex heuristics.
<csr-id-e74095e0a035b090284135c88133106ba6a19fc3/> prevent panic in Repository::rev_parse_single() when HEAD was invalid.
When using a refspec like HEAD:file.
<csr-id-6f2eb910f88ab8a61961efffd6d946d95927d8b8/> do not automatically use a parallel directory walk. This reduces dependencies and can speed-up typical ref-walks as these don't benefit from this many threads - the overhead here usually outweighs the benefit.
This can be turned back on based on the expected workload.
<csr-id-ba72ee0f069b7df96f7543fe2d97612c98544733/> better peeling performance for reference traversal. This is done by keeping a packed-buffer around and reusing it, instead of re-checking it every time.
For this to work, the peeled() function on the reference::Iter can now fail
as it has to open a packed-refs snapshot.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
17bd32a)jj (7ef1e88)f218578)4fe330e)f2b522d)a65a17f)d19af16)0f25841)9ed2b24)6990afd)f8c5d9c)ba72ee0)242fedc)f944e49)objects::tree::diff::Platform::stats() to quickly obtain diff-stats. (e079250)b291de0)Reference::follow_to_object() (d986b2b)Repository::diff_resource_cache_for_tree_diff() (6c6f946)Reference::peel_to_kind() (cdaba84)gix-ref (d296ee8)gix-ref (5464bfb)Repository::find_*() methods for every object type. (98bcb14)Repository::compute_object_cache_size_for_tree_diffs(). (63c7a03)git2 (26748dd)7b7902e)#[momo] directive as it seems to prevent auto-completion in IDEs. (3a339da)12251eb)63936e5)0b28297)Repository::rev_parse_single() when HEAD was invalid. (e74095e)7dff447)remote::Name::to_owned() to get a static version of it. (8a27454)29898e3)Reference::remote_name() now also provides valid remote names for local tracking branches. (6ac2867)Reference::peel_to_id_in_place_packed() to allow passing a packed-buffer snapshot. (c612440)6f2eb91)remote::Names as shortcut to the value returned for all remote names. (7c8f409)5871fb1)9fd1090)f6a4eb9)33eacfb)gix-dir (37c2852)
</details>retry the current commit when graph parents are corrupt
retry the current commit when graph parents are corrupt
Both Simple traversal paths pop the current commit before decoding its
cached parents. If parent iteration fails, dropping the cache and recursively
requesting the next commit skips the popped commit and its entire ancestry.
With an out-of-range inline parent, a two-commit gix revision walk could
therefore succeed with an empty result.
Put the current commit back at the front of the topology queue or into the
date queue with its existing priority, then continue the loop after disabling
the cache. The object database retries that same commit without recursion;
any object lookup or decoding failure is still propagated.
The regression corrupts a disposable graph, confirms that Git rejects it,
and checks that the existing gix fallback policy preserves both commits
across breadth-first traversal, both date orders, cutoff sorting, and
first-parent traversal.
<csr-id-d9a813fdd2cac522999dccb2dbff84c6a50735a2/>
tracing feature in the Cargo manifest.
That way, it's easier to directly enable tracing, instead of having to
resort to gix-features.config::section::filter() for the default section filter.
Provide the default implementation to determine which configuration
sections should be trusted.config::credential_helpers() function to configure an invocation.
That way it's possible to use git credential helpers even without a Repository instance.gix_validate as validate.
The crate appears in the public API of gix_index::State::from_tree
but it's types weren't readily available.PrepareFetch::with_ref_name() to control which ref is checked out.<csr-id-40d18816a85c41eb2b9075752b092ae68f4d979c/> make sure that refs/heads/HEAD isn't considered conflicting
<csr-id-c8c56aebaac95f0f73220055dc33e6e0ebdb5ced/> re-export gix_validate as it's now part of the public API.
This allows calling State::from_tree().
<csr-id-a146d140da6c848a39d9f14b40f3fd46b749cc11/> don't attempt negotiation without any refspec-mappings Previously, when a shallow operation was specified, it was possible to skip past the no-change test and attempt to negotiate even though there was nothing to want.
This is now 'fixed' by simply aborting early if there is no refspec mapping at all.
Further, it aborts as early as possible with a nicer error message, after all, there is no use in having no mapping.
Note that it's explicitly implemented such that obtaining such an empty refmap is fine, but trying to receive it is not. That way, the user can obtain information about the server without anything being an error.
<csr-id-0ec2389e4e3c457f87cff2cbdd394a94f7d0d54a/> gix-config convenience initiative
A new gix_config::AsKey trait allows all gix_config::File methods
to receive an implementation of AsKey instead of the tuple of
(section, subsection, value_name). This is the default, and all
methods that take a tuple have been renamed to <name>_by(), note the _by suffix.
The terminology was reworked so that key is now only used to identify a value.
This change also affects the public API of gix, which provides
ways to set values on configuration snapshots which now by default
will only take a AsKey implementation.
Note that gix::config::tree::* keys now also implement AsKey,
which allows them to be used more conveniently when setting values,
too.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 2 times to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
a146d14)refs/heads/HEAD isn't considered conflicting (40d1881)0e8508a)6232824)a1b73a6)0470df3)99c00cc)b4dba1c)1267712)113cbcc)15f1cf7)caae926)f87322e)gix-testtools (f5a9884)bf3d82a)7330844)a4bb7b9)<< rather than <<- heredoc operator (2641f8b)1e79c5c)use_http_path to be set in config::credential_helpers() (55cbc1b)tracing feature in the Cargo manifest. (41e018d)929744a)ab02aa9)d9a813f)config::section::filter() for the default section filter. (5c7e744)config::credential_helpers() function to configure an invocation. (478bbc1)0c5d1ff)8d89b86)f71b7a0)gix_validate as it's now part of the public API. (c8c56ae)gix_validate as validate. (afc6e25)c1d7c02)1dfa90d)tar files (dcab79a)5663a2c)gix-config convenience initiative (0ec2389)dbe1f22)9fa1054)ecfde07)f36b9bd)PrepareCheckout and make it easier to use (39180b4)PrepareFetch::with_ref_name() to control which ref is checked out. (acbfa6f)0912a46)2f9f0ac)2856434)1dc4568)9c65d98)ea12fc2)68cbea8)2cefe77)8da55a3)2d0a352)bd32c7a)
</details>5 commits contributed to the release over the course of 13 calendar days.
<csr-id-886d6b58e4612ac21cc660ea4ddf1dd0b49d1c6e/> checkout respects options for core.protectHFS and core.protectNTFS.
This also adds gitoxide.core.protectWindows as a way to enforce
additional restrictions that are usually only available on Windows.
Note that core.protectNFS is always enabled by default, just like
it is in Git.
<csr-id-3c7b7b3a7b981040cd51417202d7022597179114/> empty paths as configured will not be an error with lenient configuration enabled.
When using gix::open_opts(path, options.strict_config(false)), empty core.excludesFile values
will not cause an error anymore.
Note that in strict mode, the behaviour is unchanged so invalid configuration can rather be fixed than ignored.
<csr-id-88a6a4e6d882fc7a3a0b4017d772a3fe38e57598/> don't unwrap when reading possibly left-over bytes from pack-stream
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
88a6a4e)3c7b7b3)4f98e94)9511416)d6cd449)cd4de83)6f55f2a)79dce79)gix-ref (d2ae9d5)gix-index (5f86e6b)f961687)fcc3b69)bad9a79)core.protectHFS and core.protectNTFS. (886d6b5)gix-worktree (1ca6a3c)3c21741)d3588ca)04ef31e)git2 (5197b5a)e791bc5)977346e)54ac559)fe24c89)41bf65a)
</details>Keep rust workspace tests inside disposable repositories and isolated environments
Keep rust workspace tests inside disposable repositories and isolated environments
Direct Git launches inherited repository selectors and user configuration even
when tests supplied a fixture working directory. Tests of default-environment
APIs and local Git transports also shared the runner's environment. A few
journey tests wrote beneath source directories or used the source checkout as
the repository under test.
Use the shared gix-testtools Git command builder for subprocess setup, isolated
repository options for fixtures, and isolated child processes where the real
environment-reading API must be exercised. Scope CWD changes, copy the fixture
used by an object-write test, and run shell journeys through jtt run. Keep
journey worktrees and example output within their disposable sandboxes and
replace the attributes checkout test with a representative fixture repository.
Prompt examples also run in isolated children and must build successfully; the
old tests could ignore build failures and execute stale cached binaries.
The affected Rust crate suites, internal test-tool build, and max-pure journey
suite pass from a source copy without Git metadata. Signing and Git-daemon
checks use only disposable keys, repositories, and local sockets.
migrate errors to gix-error
rubberstamp
raise MSRV to Rust 1.88
The newly published dua-core 3.3 release used by linked-worktree removal
requires Rust 1.88, so raise every workspace crate and the advertised badge
together.
Keep the MSRV checks buildable by selecting the latest sysinfo and rusqlite
release lines that support Rust 1.88.
allow configuring the reqwest HTTP client
Applications need to supply a custom TLS configuration, including an explicit
cryptographic provider, before reqwest builds its HTTP client. The existing
request callback runs too late to configure that client.
Add reqwest::Options::configure_client and build the client lazily when the
first request makes the HTTP options available. Reuse that client for later
requests, retaining the configured options if a failed worker is restarted.
Apply Git's redirect policy after customization so the callback cannot replace
its safeguards for configured request headers or unsafe redirects.
Adding this public option requires existing complete Options literals to
specify configure_client or use ..Default::default().
reqwest HTTP client (7111e30)Please note that this release contains a security fix originally implemented in gix-transport via this PR
which prevents ssh options to be smuggled into the ssh command-line invocation with a username provided to a clone or fetch URL.
Details can be found in the advisory.
<csr-id-18b2921aaa28df536faf74098d5f1f13d34148f9/> into_index_worktree_iter() now takes an iterator, instead of a Vec.
This makes the API more consistent, and one can pass None
as well.
<csr-id-719ced8a7949ba1f30fef13801e3466a7d1da590/> show submodules in status independently of their active state.
Even inactive submodules are shown in the status by git status,
so gix should do the same.
First observed in https://github.com/helix-editor/helix/pull/5645#issuecomment-2016798212
<csr-id-98cfbec51276bbd6caa48fd6d8942247df091c94/> forward curl rustls feature from gix-transport to avoid curl in gix.
This removes the curl dependency just for configuring it, and removes
a hazard which became evident with reqwest.
topo more similar to Ancestors, but also rename Ancestors to Simple<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
curl rustls feature from gix-transport to avoid curl in gix. (98cfbec)095c673)5755271)55f379b)f72ecce)b590a9d)gix-traverse (1cfeb11)topo more similar to Ancestors, but also rename Ancestors to Simple (2a9c178)gix-traverse (6154bf3)7f6bee5)45edd2e)into_index_worktree_iter() now takes an iterator, instead of a Vec. (18b2921)719ced8)is_path_excluded() in documentation (c136329)gix-index (1e1fce1)9e9c653)e3eedd8)
</details>This release also updates reqwest to v0.12, bringing hyper 1.0 and a more recent rustls version.
This release also updates reqwest to v0.12, bringing hyper 1.0 and a more recent rustls version.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
57579f1)7018a92)8fde62b)curl into a workspace package (adee500)369cf1b)3b34699)f1bc4cd)e1fec3c)
</details>Headline benefits of this extra-curricular release are various security improvements, and greatly improved error handling and consisstency. Plumbing c
Headline benefits of this extra-curricular release are various security improvements,
and greatly improved error handling and consisstency. Plumbing crates for instance will now
use a standard std::error::Error compatible error type.
Besides that, the tracing of all commands was greatly improved.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
Repository::dirwalk_iter().
That way, more copying happens but the usability increases tremendously as well.
It's breaking as public types moved from repository::dirwalk to dirwalk,
dissolving repository::dirwalk entirely.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
155cc45)129ba3d)41cd53e)Repository::dirwalk_iter(). (ba3f2db)gix-dir (b90ab3d)4ccf39b)c18734b)e51b6b6)
</details>Headline benefits of this extra-curricular release are various security improvements, and greatly improved error handling and consisstency. Plumbing c
Headline benefits of this extra-curricular release are various security improvements,
and greatly improved error handling and consisstency. Plumbing crates for instance will now
use a standard std::error::Error compatible error type.
Besides that, the tracing of all commands was greatly improved.
remove full-screen progress mode <!-- agent --> Full-screen progress required separate command and UI threads plus channel coordination, while line progress already covers long-running commands and works with independently buffered tracing.
Remove --progress, --progress-keep-open, and the prodash-render-tui feature. Keep synchronous line progress as the only progress UI.
make trace output independently configurable <!-- Byron -->
Quick review only, as it's mostly about tracing and gix which both aren't super
important, and are seemingly working well. An extra agent-review couldn't
find anything either.
<!-- agent -->
Replace the old boolean trace switch with a bounded -t/--trace counter:
forest INFO and DEBUG at one or two occurrences, then flat DEBUG and TRACE at
three or four. Keep --threads long-only and route tracing independently of
verbose and progress rendering, including commands with bespoke execution paths
and corpus runs.
Initialize display tracing once before repository discovery, buffer it outside
prodash, and emit it after command and progress teardown. Format forest and
flat output with ANSI, then adapt the final stderr write so terminals get color
while pipes and NO_COLOR remain plain.
Corpus worker subscribers share that sink while retaining their complete
JSON trace storage, and flat modes include completed spans. gix tix remains
delegated to Tix so it installs only one subscriber.
add and remove linked worktrees from the CLI <!-- Byron -->
rubber-stamp mostly for gitoxide-core changes, did look at it though just to be sure.
Journey test was present but removed.
<!-- agent -->
The CLI previously exposed only worktree listing, despite gix supporting
both checkout and safe removal. Add worktree add (alias create) and
worktree remove using those APIs.
Creation follows Git's local-branch and detached-revision selection, including
destination-basename defaults and -b. It retains new branches after setup
failures, uses the existing listing format on success, and reports incomplete
checkouts. Removal maps repeated -f flags to dirty-worktree and lock overrides
while retaining branches.
Both commands use the existing repository, configuration, and progress options. Unsupported JSON output is rejected before mutation.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
AsHashKind (106db87)gix free index (a8e3143)gix status --index-worktree-renames
This enables rename-tracking between worktree and index, something
that Git also doesn't do or doesn't do by default.
It is, however, available in git2.commit::describe::Resolution::format_with_dirty_suffix()Repository::is_dirty()
The simplest way to learn if the repository is dirty or not.Submodule::status() method.
That way it's possible to obtain submodule status information,
with enough information to implement git status-like commands.Status iterator.
We also move the IndexPersistedOrInMemory type to the worktree module
as its more widely useful.diff::resource_cache() now takes the attribute stack directly.
That way, the constructor becaomes more versatile as the user can chose
to pass attribute stacks that have more functionality, and thus can be
used in more places.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
b050327)52c3bbd)3e5c974)3753592)summary available for Item. (da45d92)gix status --index-worktree-renames (66e87cd)status.showUntrackedFiles to config-tree and use it in status() (22abf60)f8ce3d0)f1ba7bd)17bef30)commit::describe::Resolution::format_with_dirty_suffix() (c7ddd30)Repository::is_dirty() (c20ad28)4a4989d)Submodule::status() method. (a29fa00)Status iterator. (0330ad7)diff::resource_cache() now takes the attribute stack directly. (57cf83b)b3556b2)ba3bf65)6281e1a)
</details>Breaking change: gix_worktree::prepare() now accepts the destination first, followed by an add::Context containing the common Git directory and an opt…
preserve sparse-checkout state when adding worktrees
Looked at everything carefully, but was despite test refactoring, I went
through those more quickly. The benchmark I only skimmed.
Adding a linked worktree from a sparse checkout copied its configuration
without its patterns, then materialized the entire target tree. Copy active
info/sparse-checkout patterns from the source worktree's private Git directory
during preparation, including when checkout is deferred. Missing patterns are
skipped, empty files are retained, and copy failures roll back registration.
Expose pattern loading and full-index selection through gix_worktree::sparse.
Initial checkout in gix reads the destination's current patterns and marks
excluded target-tree entries with SKIP_WORKTREE and EXTENDED before writing
files and persisting the index. Support cone and non-cone patterns, case
folding, invalid-cone fallback, root entries, and directory pruning. Sparse
index generation and updates to existing checkouts remain outside this API.
Reuse matching decisions for shared directory ancestors with storage bounded
by path depth, and skip index traversal for a validated full-cone selection.
Cover pattern matching with 18 Git-generated baseline scenarios, regression
tests for cache boundaries and ordering, and integration tests for main and
linked sources, deferred checkout, missing or disabled patterns, and rollback.
Add Criterion benchmarks for cone and non-cone selection on synthetic indices
with 20,000 to 200,000 entries, checking membership and flags before timing.
Breaking change: gix_worktree::add::prepare() now accepts the destination
first, followed by an add::Context containing the common Git directory and
an optional source private Git directory, then its existing options. Use
add::Context::new(common_dir) when pattern inheritance is not wanted.
make bounded removal retries configurable
Went through the tests pretty quickly, as is increasingly common.
Expose Options::retry_delay alongside max_retries. The default is 10 ms;
Duration::ZERO retries immediately, and callers can choose a longer delay for
longer (expected) write bursts. Only retryable DirectoryNotEmpty errors with
attempts remaining wait, before restarting traversal. Successful first-pass
removal, zero-retry operation, and terminal failures incur no pause. The default
two retries request at most 20 ms of sleep per root; filesystem operations and
scheduler delays have no wall-clock bound.
Remove the shrinking-entry-count guard. A writer can replace every deleted file
with a new one, leaving the scan count unchanged even though deletion succeeds
for every scanned entry. The old guard then stops before the configured retry
allowance is used. A deterministic regression writes one replacement after each
of the first two scans: the old loop fails on the second pass; the corrected
loop succeeds on the third, even with a zero delay. The retry count bounds
shrinking, equal, and growing workloads without trying to infer writer progress.
Deletion duration or entry counts cannot tell when an independent writer will
finish. Keep the delay an explicit caller policy instead of introducing another
heuristic tied to tree size. No finite retry policy guarantees completion for
arbitrary finite or indefinite writers. Existing porcelain Target::options()
and the re-exported Options expose this setting without another configuration
layer. Downstream exhaustive Options literals must add retry_delay or use
..Default::default().
cap automatic macOS removal at four workers
This is an APFS problem, which is also noticeable when scanning through
metadata, which now caps at 8 at least in dua.
On Linux Ext4 no such limits exist for all I know, so this commit is
a macOS specific fix to ensure decent performance.
Resolve automatic removal concurrency to at most four available logical CPUs
on macOS. None and Some(0) stay automatic; positive explicit limits remain
unchanged, as do defaults on other platforms. Apply the cap in the shared
plumbing options so repository, proxy, and CLI removal inherit it.
Sixteen concurrent unlink workers contend on native APFS. A dedicated comparison
of three and four workers favors four in all 12 matched pairs, including trees
created by Git, gix, and APFS cloning. Median wall seconds (range), four samples
per cell:
| Creator | 3 workers | 4 workers | Less elapsed time |
|---|---|---|---|
| Git | 2.013 (1.878–2.059) | 1.842 (1.820–1.856) | 8.49% |
| gix | 2.873 (2.849–2.890) | 2.597 (2.577–2.673) | 9.59% |
| APFS CoW | 1.577 (1.571–1.594) | 1.429 (1.420–1.432) | 9.42% |
Median per-round 3/4 time ratios are 1.087×, 1.101×, and 1.107× respectively.
One additional single-worker control per creator took 3.258, 3.911, and 2.781 s:
the four-worker medians are 1.77×, 1.51×, and 1.95× faster. Those controls ran
last and are diagnostic, not paired repetitions.
The preceding native worker sweep measured sixteen-worker medians of 5.018 s
for Git-created and 5.819 s for gix-created trees (two samples each). These are
separate measurements, not additional pairs in this comparison. GitButler's
image-derived one-worker override and the old all-core default both give up
native-volume throughput.
2026-10-09, Apple M4 Max, 16 logical CPUs, 64 GiB RAM, macOS 27.0.1 (26A434),
native APFS under /private/tmp; Rust 1.96.1 release probe and Apple Git 2.54.0.
The cached probe uses local Gitoxide 00bb1af, with max-performance, parallel,
both pack-cache variants, SHA-1, and worktree mutation. Explicit removal thread
limits exercise the same deletion path as the new automatic cap. The retry
pause only applies after an error; no concurrent writes were injected here.
Borrow objects read-only from
/Users/byron/dev/git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux, commit
707df3375124b51048233625a7e1c801e8c8a7fd, using independent seed metadata.
The clean seed checks out tree 176a057fce1932fe5057196e63c2a636e1a3cdab:
88,821 tracked files / 1,509,611,994 blob bytes. Native case-insensitive APFS
requires omitting thirteen later case-fold collisions in git ls-tree -r
order: 15,749 bytes, 0.00104% of the source tree.
Each of four rounds creates fresh Git, gix, and CoW destinations with both
removal counts; odd rounds reverse all case ordering. Git checkout uses one
worker, gix its default sixteen. CoW registers with Git without checkout,
uses clonefile() for regular files and index, and recreates symlinks. This is
a deletion fixture, not a timing of GitButler's entire CoW creation workflow.
A small byte/symlink self-check validates the fixture copier.
Synchronize with sync_volume_np(SYNC_VOLUME_WAIT) before creation and removal,
outside timers. Validate clean status before forced removal, excluding status
cost from the removal timer. All 27 samples removed both checkout and private
administration. No build or other benchmark overlapped measurements. One
0.24 s read-side inventory overlapped the second-round CoW/3 case; excluding
that pair leaves medians 1.577 vs 1.430 s, with four winning all remaining pairs.
These are warm-cache timings on one native APFS machine. No new disk-space,
cold-cache, durable-write, or other-platform measurement was made. The old
sparse-image results are unsuitable for choosing native macOS concurrency.
The updated automatic-resolution test failed with 16 instead of 4 before the
change. Removal and bounded late-write regressions pass, including explicit
limits above the cap. Keep results here; discard temporary fixtures and logs.
classify sparse gitlinks as directories on every host
Non-cone directory-only patterns should treat gitlinks as directories on
every host, including when the destination is initially empty. The original
matcher instead hardcoded them as non-directories, reproducing the result
of Git's little-endian ce_to_dtype() bug.
Expose gix_index::entry::Mode::is_dir_for_git_matching() using decoded
modes directly, and document why Git's extra ntohl() conversion is wrong.
Use this classification for sparse matching, so /*/ includes an absent
gitlink and !/module/ excludes it consistently across hosts.
Keep Git-generated baselines while working around its conversion bug:
pre-create the empty gitlink directory only for the reference operation,
allowing Git's filesystem fallback to recover its intended classification.
The gix index-only regression and initial checkout still start without it.
Check included gitlinks as directories rather than reading them as files.
raise MSRV to Rust 1.88
<!-- agent -->
The newly published dua-core 3.3 release used by linked-worktree removal
requires Rust 1.88, so raise every workspace crate and the advertised badge
together.
Keep the MSRV checks buildable by selecting the latest sysinfo and rusqlite
release lines that support Rust 1.88.
gix editor command
<!-- agent -->
Provide a small plumbing command that opens zero or more paths with
Repository::editor()'s Git-compatible selection. Prepare editor definitions with
command-aware argument splitting so PATH-resolved programs run directly while
actual shell syntax still uses the shell, reject explicitly empty settings, and
honor ':' as the no-op editor.<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
gix editor command (d930653)
</details>Repository::dirwalk_with_delegate().
That way it's possible to perform arbitrary directory walks,
useful for status, clean, and add.open::Options::current_dir().
That way it's possible to obtain the current working directory
with which the repository was opened.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
45b4470)f2e111f)bb48c4c)0b1b44f)1e85396)gix-dir (ab0f63a)e186199)gix::clone::PrepareFetch::new, crate_opts -> create_opts (adbf8e8)gix-status (366dfb3)gix-dir (e91accc)a86a5c0)b81d8ae)face359)Repository::dirwalk_with_delegate(). (6914d1a)open::Options::current_dir(). (d8bd45e)7b44c7f)8430442)8a62fb5)b8cba96)
</details>Provide the gix-worktree plumbing needed to recursively remove a linked checkout and its private Git directory without following symbolic links or cro
remove linked worktrees safely
Provide the gix-worktree plumbing needed to recursively remove a linked
checkout and its private Git directory without following symbolic links or
crossing Unix mount boundaries.
Use dua-core for traversal and parallel deletion with progress reporting,
bounded retries for directory-not-empty races, and errors distinguishing
checkout and administration failures. Keep repository validation, dirty-state
checks, lock policy, and branch decisions with higher-level callers.
create linked worktrees
Add transactional linked-worktree administration with rollback, then compose
it in gix with existing reference, checkout, index, progress, and interruption
machinery.
Support attached and detached worktrees from bare or non-bare repositories while
rejecting occupied branches and destinations. Keep move, remove, repair, hooks,
sparse checkout, and relative-link configuration out of scope.
skip symlinked ignore files and protect checkout writes
A tracked .gitignore symlink was absent from the skip-worktree ID
mapping, so ordinary ignore lookup could parse arbitrary external files.
An endless target could also exhaust memory.
Always request no-follow reads for worktree .gitignore files, regardless
of their index entry. Use gix_fs::open_read_only_no_follow() when pattern
loading disallows symlinks, treating skipped links as absent files so
skip-worktree blob fallback remains available. Discard partially read
pattern bytes on failure.
Use the same helper for the worktree .mailmap, reporting symlinks as
errors without reading their targets and identifying worktree read errors
correctly. Explicitly configured pattern files and mailmap.file may
still follow symlinks.
On Windows, inspect nonexclusive checkout handles for symlinks before
truncating with set_len(0) or writing. Retain forced unlink-and-replace
behavior and route symlinks checked out as ordinary files through the
same validated open path. No-follow protection applies to the final path
component on Unix and Windows; leading components can still be symlinks.
Compare ignore lookup and skip-worktree fallback against isolated Git
check-ignore calls. Cover mailmap policies and checkout collisions with
file, directory, and dangling symlink targets, including links created
after the Windows path check and validation before truncation.
remove gix tix screen selection Remove the plumbing CLI screen-mode option now that the interactive history always owns the alternate screen. The automatic and half-screen modes depended on inline rendering behavior that is being retired from gix-tix.
Stop accepting --screen for gix tix and its aliases, and remove the mode validation and translation into gix-tix. Construct the reduced gix-tix options directly from the remaining quit and hidden-revision arguments. Keep a command-line regression assertion so the removed option cannot silently return as an ignored argument.
delegate tix commands through gix-tix Embed the complete gix-tix Clap platform in the plumbing command instead of maintaining a second parser and dispatcher. This keeps standalone and plumbing invocations aligned, adds worktree-tip parity, and makes amend and spill available through gix tix without duplicating their execution logic.
show other worktree checkouts in tix Decorate commits checked out by other main or linked worktrees with light-blue name@ labels, replacing the ordinary branch label. Keep the checkout from which tix was opened represented by the graph @ marker and its ordinary local reference, and use directory basenames for other detached worktrees. Keep other-worktree labels visible on the selected row when references are hidden.
Add -w/--worktrees to include every successfully resolved worktree HEAD, including the current checkout, alongside implicit or explicit traversal tips without weakening hidden-revision exclusions. Discover worktrees from their private Git metadata so stale checkout directories remain useful, while malformed, unborn, or inaccessible entries are logged and skipped.
Watch linked HEAD and worktree membership changes so decorations and optional tips stay current, while ignoring unrelated linked indexes, logs, and metadata. Document the behavior and cover current, attached, detached, stale, malformed, hidden-reference, CLI, and watcher cases.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
<csr-id-a7e606b4dffe5c524b60a89fa0dbc753e80ce599/> <csr-id-1ba9488a7c3737a4b5a15a871108924095c061b2/>
<csr-id-8847676ddd1aefb3610d384245ec6d692d5258de/> add max-control feature for fine-grained performance control.
This also adds the following performance features:
zlib-ngobject::tree::diff::Platform::for_each_to_obtain_tree(callback) errors are more convenient to use.
Due to a change in how the generic error type is declared it should now be possible to
use anyhow with it as well.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
object::tree::diff::Platform::for_each_to_obtain_tree(callback) errors are more convenient to use. (e3c5a0f)eb6aa8f)6a2e0be)d8570d0)max-control feature for fine-grained performance control. (8847676)5d176fc)gix_fs::current_dir(precompose_unicode). (7d8d167)gix-features (eacb5a4)env::args_os_opt() which takes an argument to determine input unicode-decomposition (a7e606b)b6c04c8)39f35da)3ef3bc2)max-performance-zlib-ng-compat flag (1ba9488)cfb06ec)
</details>3 commits contributed to the release.
<csr-id-3bd09ef120945a9669321ea856db4079a5dab930/>
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
972241f)8c492d7)rust-version manifest field back to 1.65. (3bd09ef)
</details>keep descendants of ignored directories excluded I looked at this carefully, and ended up having a better comment to provide an example for what this
keep descendants of ignored directories excluded
I looked at this carefully, and ended up having a better comment
to provide an example for what this covers.
Ultimately, this is test extension is still minimal compared to the
behaviour that it enables, scoped status, but I think it's fine
in there interest of less code.
Scoped status walks can enter an ignored directory when a pathspec
matches. If a deeper directory matches a negated rule such as !out/,
the ignore stack previously stopped at that nearer match and exposed its
contents as untracked. Tix uses scoped walks for filesystem refreshes,
so ignored Cargo output appeared after unrelated worktree events and
disappeared after a full refresh.
Continue through negated directory matches to check excluded ancestors.
Keep the nearest negation as the fallback when no ancestor excludes the
path, and preserve the precedence of positive directory matches,
including precious-file handling.
Extend the Git-reference fixture below a negated child directory and
refresh both hash archives. The extended fixture fails with the previous
matcher. All directory-walk, status, and worktree tests pass, as do the
SHA-256 ignore baseline, formatting, and Clippy with -D warnings.
Clippy retains the workspace's existing removed-lint warning.
raise MSRV to Rust 1.88
The newly published dua-core 3.3 release used by linked-worktree removal
requires Rust 1.88, so raise every workspace crate and the advertised badge
together.
Keep the MSRV checks buildable by selecting the latest sysinfo and rusqlite
release lines that support Rust 1.88.
support cloning a single revision <!-- agent --> A full object ID passed through with_ref_name() produced an object-ID refspec mapping and panicked while clone assumed every mapping had a name. Branch and tag checkout also retained ordinary clone tracking semantics instead of offering a single-revision mode.
Add PrepareFetch::with_revision() and gix clone --revision for full refs, HEAD, and full object IDs. Revision clones use a one source-only implicit refspec, detach HEAD to the fetched commit, create no ordinary refs, persist no fetch refspec, and disable tag following. Existing with_ref_name() and --ref behavior stays unchanged.
This follows Git commit 337855629f59 (builtin/clone: teach git-clone(1) the --revision= option) and its t/t5621-clone-revision.sh behavior.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
gix-date (613ff86)<csr-id-aea89c3ad52f1a800abb620e9a4701bdf904ff7d/>
<csr-id-3fba5b856b37af2db40c29f463efe09dcfc8d085/> Repository::rev_parse*() now supports branch@{upstream|push|u|p}.
Previously it would be parsed, but always error as the implementation didn't exist.
Now it will return the fetch and push tracking branches respectively.
<csr-id-270322e75a49f9a5c2d996cf0a20c6d622b40394/> Add Reference::remote_tracking_ref_name() and *::remote_ref_name().
These methods mirror their respective Repository::branch_* prefixed versions.
<csr-id-4aa4b05b9dc785d550386218915208c0c9fdb78b/> add Repository::branch_remote_tracking_ref_name().
<csr-id-8ac2dccd62d88c0c196d2fc054a68a1b69121da0/> add push.default config key
<csr-id-3f842134d0e2bbc9c62ee77af3c8e5c7fd9f47d1/> add config::Snapshot::trusted_program().
That way it's possible to obtain an executable, program or script
from a key in the configuration that is in a trusted section of the
configuration.
This goes along with a new command feature that brings in the command
module at the top level to be able to execute such commands.
<csr-id-b5c36b805d0b269e6d87ca8b6c517b7fd7337622/> add clone::PrepareFetch::with_in_memory_config_overrides().
With it one can affect the repository configuration right before fetching.
Repository::remote_names|remote_default_name() now returns Cow<'_, BStr> instead of Cow<'_, str>.
That way information won't degenerate due to enforcement of UTF-8.<csr-id-404fde55d3cc85acce207ca259b0fa9b144dd694/> rename Repository::branch_remote_ref() to Repository::branch_remote_ref_name(), add direction argument (also to Repository::branch_remote_name() and Repository::branch_remote()).
This better differentiates the return value from the corresponding ref objects,
which would require the named ref to exist in the repository.
The direction argument allows to get the reference to push to as well.
Further, it now takes a full ref name to support deriving the name of branches
to push to.
Regarding Repository::branch_remote(), previously, this functionality
was only available from a Reference,
but now it's more generally available with just a branch name.
The method was also adjusted to permit looking up non-symbolic remote names, like remotes that are specified by their URL.
<csr-id-59b8104a5320d946abc9f5736fa76696cef1459d/> mark gix::interrupt::init_handler() as unsafe
The passed interrupt() argument will be called from a signal
handler, so that needs to be documented and the call sites need to
state that they fulfill the contract.
Thanks to @Manishearth for pointing this out.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
11c9f66)8ef0538)config::Snapshot::trusted_program(). (3f84213)2e04403)e1aae19)e78a92b)4454c9d)aea89c3)d38d1cc)0fe20e8)530c15d)Repository::rev_parse*() now supports branch@{upstream|push|u|p}. (3fba5b8)Reference::remote_tracking_ref_name() and *::remote_ref_name(). (270322e)Repository::branch_remote_tracking_ref_name(). (4aa4b05)Repository::branch_remote_ref() to Repository::branch_remote_ref_name(), add direction argument (also to Repository::branch_remote_name() and Repository::branch_remote()). (404fde5)Repository::remote_names|remote_default_name() now returns Cow<'_, BStr> instead of Cow<'_, str>. (5c07c76)push.default config key (8ac2dcc)cda5b51)1691ba6)c1cfe6e)20dce42)Executable and Program (56d1d09)core.editor key (ff71e07)7549559)35439de)b6f2b81)98b08f4)8dda069)mailmap keys and make a few improvements. (7f65ffd)mailmap keys (1bf3e88)86c7fa1)281fda0)clone::PrepareFetch::with_in_memory_config_overrides(). (b5c36b8)9833b45)4917beb)c23bb87)gix::interrupt::init_handler() as unsafe (59b8104)d77bc0e)cd26fd8)56588a9)ec0211a)
</details>11 commits contributed to the release over the course of 30 calendar days.
gix-testtools (0cbe539)Store::at() where possible (17fea2a)GIX_TEST_FIXTURE_HASH for more tests (bbea2c4)add configurable terminal screen modes.
hide revision ancestry in tix
add tix to the gix CLI
add explicit gix config show subcommand.
add gix config list for showing the git-configuration files.
add the gix config fmt subcommand
Expose the gix-config whitespace formatter as
gix config fmt [--in-place] [in-file] [out-file]: with no in-file it
formats the repository-local configuration, and with no out-file it writes
to stdout. The repository is only opened when the repository-local
configuration is needed, so formatting an explicit file works outside a
repository too.
add gix status --untracked flag
This allows to control how untracked files are folded, but also
can completely turn dirwalking off.
add gix free remote refs to list and write remote refs.
Add gix free remote refs to perform an upload-pack handshake, discover
the remote reference advertisement, and print the refs without negotiating
or receiving a pack.
The command can also write the advertised refs into a standalone ref store:
gix free remote refs --refs-directory out-refs <url>
preserve multiple remote URLs
Configured remotes can have multiple remote.<name>.url or remote.<name>.pushUrl
values, but gix::Remote kept only one value because lookup used the singular
config accessor. That meant the most recent config value won, while Git exposes
every effective URL and uses the first one for the singular get-url form.
Add ordered URL storage to gix::Remote and expose Remote::urls(Direction) for
all effective URLs. Keep Remote::url(Direction) as the singular compatibility
API, now returning the first effective URL. Fetch URLs used as push fallbacks
try pushInsteadOf first and then insteadOf, matching Git behavior.
The regression fixture records Git 2.50.1 behavior with git remote get-url: without --all it prints the first configured URL, and with --all it prints all configured URLs in order for both fetch and push.
make exclude queries index-aware <!-- agent -->
gix exclude query reported ignore matches for tracked files and directories
containing tracked entries, unlike git check-ignore. Positional arguments were
also interpreted as pathspecs while stdin supplied paths.
Treat positional and stdin input uniformly as paths, normalize them relative to the repository, and suppress ignore matches for indexed files or directories containing indexed entries. This changes positional arguments from pathspecs to paths.
Add journey coverage for tracked and untracked paths below ignored directories, stdin from a nested working directory, ignore-pattern display, and positional output order.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
gix config list for showing the git-configuration files. (bd595de)gix config fmt subcommand (87a5e89)gix-attributes (e11d7a2)gix-config (376e946)gix status --untracked flag (9316ff8)gix free remote refs to list and write remote refs. (6767b30)
</details>gitoxide.core.externalCommandStderr to allow enabling stderr to the enclosing terminal.
Previously, this was enabled by default, now it can additionally be disabled by
the caller.gitoxide.credentials.helperStderr key to control how stderr is handled with helpers.
That way users can configure each repository instance according to their needs,
with which includes disabling the stderr of credential helpers.revision::Spec::path_and_mode()
Provide additional information about revspecs for use with
worktree filters.diff.external.
That way it's conceivable that applications correctly run either
a configured external diff tool, or one that is configured on a
per diff-driver basis, while being allowed to fall back to
a built-in implementation as needed.diff::resource_cache() low-level utility for rapid in-memory diffing of combinations of resources.
We also add the object::tree::diff::Platform::for_each_to_obtain_tree_with_cache() to pass a resource-cache
for re-use between multiple invocation for significant savings.gitoxide.core.refsNamespace key and respect the GIT_NAMESPACE environment variable.
It's also provided as context value.verbose-object-parsing-errors available in gix.
That way, it's easy to create programs that are geared towards
debugging repositories and finding invalid objects with detailed
errors.gitoxide.credentials.terminalPrompt key to represent the GIT_TERMINAL_PROMPT
That way, it's easy to control the usage of terminals without using and environment.http-client-curl-rustls (CLI) and blocking-http-transport-curl-rustls (lib) features to avoid openssl.
That way, we should be able to avoid crashes on certain CI configurations.Head::try_into_peeled_object() and Head::peel_to_object_in_place()
This makes it easier to peel to a specific object type, after
all tags have been followed, without having to assume an intermediate
commit.<csr-id-20f962e5d6a7c19ca097ccd3f06434f6c9501262/>
<csr-id-0b3eb141bee59ffc17c973a8d126efaa52edb9b3/> assure the correct repository is used for checkouts after clone. If this is not the case, it's possible for filters to run in the context of potential parent repositories, which then can have all kinds of issues.
In case of git-lfs, for instance, it would try to download objects
from the wrong repository.
<csr-id-3ff1827a12557a601da22d138beb97e8647d5d6e/> Allow multiple packs to be received one after another. Previously it would be difficult to perform another fetch operation on the same connection as the final flush packet after a pack wouldn't be consumed.
This has now been mitigated by consuming it in the one place where knoweldge about this specialty exists.
<csr-id-8d9296ff150a887cb887ee6b6a9c4a9cb550cae0/> don't use trust-dns by default when using request.
It's reported to have issues under certain condition, please see
https://github.com/seanmonstar/reqwest/pull/437 for more.
The blocking-http-transport-reqwest-rust-tls-trust-dns feature was added
to provide the same feature-set as before for those who want trust-dns.
<csr-id-6295dec2bdd6c3bb35e45db7a486651ebfe50369/> V1 negotiation won't hang anymore The logic previously tried to estimate when a pack can be expected, and when a NAK is the end of a block, or the beginning of a pack.
This can be known because a pack (with our settings) needs two things:
done sent by the client<csr-id-4743212269c6fab69f6306fba88ee38b669a7dc3/> object::blob::diff::Platform now performs all necessary conversions.
Previously it would just offer the git-ODB version of a blob for diffing,
while it will now make it possible to apply all necessary conversion steps
for you.
This also moves Event::diff() to Change::diff(), adds
Repository::diff_resource_cache() and refactors nearly everything
about the objects::blob::diff::Platform.
<csr-id-089c4dc8b7d323637e5f9a9f7446f2a8e9f51ce1/> generalize rename-tracking engine for later use with status. Previously the rename tracking engine was integrated with tree-diffs, but already operates in a stand-alone fashion. Now it's officially generalized which allows it to be tested separately and used when tracking renames for diffs between index and tree, index and index, and index and worktree.
<csr-id-c3edef1c0c49accbb037bdf086dade3ed0e5e507/> make it possible to trace incoming and outgoing packetlines. Due to the way this is (and has to be) setup, unfortunately one has to integrate that with two crates, instead of just one.
This changes touches multiple crates, most of which receive a single boolean as last argument to indicate whether the tracing should happen in the first place.
<csr-id-4e6a4e6ef440c72f61513ba82b439b9dca298e73/> improve head() peeling API
Previously it was partially untested and it was hard to obtain an object of choice.
Further breaking changes:
Head::peeled() to into_peeled_id()Head::into_fully_peeled_id() to try_peel_into_id()Head::peel_to_id_in_place() to Head::try_peel_to_id_in_place()GITOXIDE_* environment variables to GIX_#<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
6295dec)trust-dns by default when using request. (8d9296f)gitoxide.credentials.terminalPrompt key to represent the GIT_TERMINAL_PROMPT (e95bb9f)SnapshotMut::set_value() now sets values for keys in subsections as well. (d8452a0)0b3eb14)3ff1827)476d5ef)c8568b9)d3fd11e)55d386a)d3dcbe5)8156340)gitoxide.core.externalCommandStderr to allow enabling stderr to the enclosing terminal. (2762724)gitoxide.credentials.helperStderr key to control how stderr is handled with helpers. (6cf73a4)GITOXIDE_* environment variables to GIX_# (2189cee)5fdc9df)d2ba97c)88f8b34)revision::Spec::path_and_mode() (77686db)51c7abc)dfb3f18)gix-diff (1706e23)object::blob::diff::Platform now performs all necessary conversions. (4743212)diff.external. (6f4bbc3)diff::resource_cache() low-level utility for rapid in-memory diffing of combinations of resources. (4aea9b0)5ce9784)ead00e9)dd575cd)c6e83cf)698caaa)8b8704f)gix-filter (1763862)f09ea13)gitoxide.core.refsNamespace key and respect the GIT_NAMESPACE environment variable. (8434aab)5a0d93e)bb3224c)2b80d84)a0cc80d)d75159c)gix-credentials (c712850)c87f2cc)089c4dc)c372321)verbose-object-parsing-errors available in gix. (0ed0a89)ff99a18)gix-object (203d69c)7227410)267b13d)c8bd660)82b01c2)gix-object::Find trait where necessary (5761a4d)gix_object and gix_odb. (24e319e)c197cbf)ea8cd0e)c0e72fb)b65a80b)eb23338)e7de4c7)c3edef1)16170d9)dd57957)20f962e)c5a7e66)http-client-curl-rustls (CLI) and blocking-http-transport-curl-rustls (lib) features to avoid openssl. (f34f46a)tracing enabled (4e48558)47a1241)c2cf20c)Head::try_into_peeled_object() and Head::peel_to_object_in_place() (117357e)head() peeling API (4e6a4e6)
</details>bump gix-transport version to prevent it from being picked up. gix-transport v0.37.1 could accidentally be picked up by older, incompatible, gix versi
<csr-id-8011c73ee401bfca03811a249c46a4dd468af1b8/> bump gix-transport version to prevent it from being picked up.
gix-transport v0.37.1 could accidentally be picked up by older, incompatible,
gix versions which now fail to build.
Thus v0.37.1 is now yanked and replaced with v0.38.0 along with a new
release of gix to go with it.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
Add take_data() to all primitive object types. That is the new, most direct way to obtain its data which otherwise is immovable.
take_data() to all primitive object types.
That is the new, most direct way to obtain its data which otherwise
is immovable.detach() and detached() too all object types.
That way, the detachment API is symmetric.
It's required to overcome the Drop implementation of each of these types
which prevents moving data out of the object (easily).<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
Strange - automatic release notes weren't generated or didn't arrive here. Have to look into that. Meantime, let's use the GitHub generated notes.
Strange - automatic release notes weren't generated or didn't arrive here. Have to look into that. Meantime, let's use the GitHub generated notes.
fuzzed_timeout on windows-11-arm by @EliahKagan in https://github.com/GitoxideLabs/gitoxide/pull/2619gix-pack by @cruessler in https://github.com/GitoxideLabs/gitoxide/pull/2602GIX_TEST_FIXTURE_HASH for gix-index tests by @cruessler in https://github.com/GitoxideLabs/gitoxide/pull/2598should_interrupt per entry in index_as_worktree by @sharifhsn in https://github.com/GitoxideLabs/gitoxide/pull/2631Full Changelog: https://github.com/GitoxideLabs/gitoxide/compare/v0.54.0...v0.55.0
<csr-id-f478a3722f0be35c109ea60b79cd4ac6e607480b/>
This release contains a complete rewrite of the internal url parsing logic, the public interface stays mostly the same however. Gitoxide will now be
more correct, interpreting more urls the same way Git does. Improvements include the added support for ssh aliases (github:byron/gitoxide has previously
been parsed as local path), adjustments around the interpretation of colons in file names (previously we disallowed colons that were not followed up
with a slash character) and some smaller changes that bring the interpretation of file urls more in line with Git's implementation. Additionally, the
error types have been adjusted to print a more comprehensive message by default, making sure they stay helpful even when bubbled up through multiple abstraction
layers.
There are still many (edge) cases in Git's url parsing implementation which are not handled correctly by Gitoxide. If you notice any such deviation please open a new issue to help us making Gitoxide even more correct.
<csr-id-c79a7daa30fe90d14d8e3387ec48116b37faf460/> add Repository::head_tree() to more easily obtain the current tree.
<csr-id-787a9aa91c1abaa7572f5d19f8a2acbb7ecc0732/> Add Repository::has_object() as a high-level alternative.
Previously, one would have to call repo.objects.contains(), which
is fine, but this method is necessary for symmetry of the API
and one shouldn't have to drop down a level to do this.
This method also knows empty trees as special case.
<csr-id-3cec935e692eeb33ffcac98988e34a390f755bf3/> add Object::try_into_blob() and into_blob() and Repository::empty_blob()
This way it's easier to assert that an object is actually a blob.
<csr-id-7d9ecdd1c230204468a965f703d5efd00fa7fb79/> add Repository::index_or_empty().
This is useful if a missing index should mean it's empty.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
Clippy helped 1 time to make code idiomatic.
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
14ddbd4)68e5432)1347a54)429e7b2)f478a37)Repository::head_tree() to more easily obtain the current tree. (c79a7da)Repository::has_object() as a high-level alternative. (787a9aa)Object::try_into_blob() and into_blob() and Repository::empty_blob() (3cec935)345712d)b842691)f929d42)Repository::index_or_empty(). (7d9ecdd)gix-status (54fb7c2)a12e4a8)4349353)
</details>local refs created during fetching will now always be valid. Previously it could create symbolic refs that were effectively unborn, i.e. point to a re
<csr-id-300a83821358f2a43649515606ebb84741e82780/> local refs created during fetching will now always be valid. Previously it could create symbolic refs that were effectively unborn, i.e. point to a reference which doesn't exist.
Now these will always point to the peeled object instead.
<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
gix dirwalk as a way to run gix-dir directly This is mostly for testing walks specifically, without needing them as part of gix clean or gix status.
gix dirwalk as a way to run gix-dir directly
This is mostly for testing walks specifically, without needing them as part
of gix clean or gix status.gix merge tree --message '' to allow creating commits
This is useful for controlling cherry-picks precisely.<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
gix dirwalk as a way to run gix-dir directly (add4cf4)gix merge tree --message '' to allow creating commits (6ab327e)
</details><csr-id-e022096aa495f55a05f83860243f49552be501f7/> <csr-id-79e47a512507c7fd7acbdff624a5249e24505e0d/>
PathspecDetached as pathspec that can more easily be used across threads.PathSpec implements gix_status::PathSpec to allow it to be used there.
The reason we need a trait and can't do with simply a function is that multiple calls
are needed to test for inclusion and allow the common-prefix optimization.Repository::stat_options() to learn how an index would compare filesystem stats.parallel feature toggle
Make certain data structure threadsafe (or Sync) to facilitate multithreading.
Further, many algorithms will now use multiple threads by default.
If unset, most of gix can only be used in a single thread
as data structures won't be Send anymore.stat isn't having.core.askpass settings
This is the same as what git does, it's explicit per value, which
means that other paths might be flagged as empty automatically.PrepareCheckout::main_worktree() now takes Progress as geric argument.
This makes it more flexible and convenient, but is technically a breaking change.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
7891fb1)8a60d5b)54a8495)PathspecDetached as pathspec that can more easily be used across threads. (f9d14d8)e22893c)PathSpec implements gix_status::PathSpec to allow it to be used there. (f066f98)Repository::stat_options() to learn how an index would compare filesystem stats. (a8333f1)4ce7f7c)c270f78)parallel feature toggle (2734e84)ThreadSafeRepository is sync. (79e47a5)14312b6)9c528dc)afb1960)core.askpass settings (334281c)1f2ffb6)PrepareCheckout::main_worktree() now takes Progress as geric argument. (ee9276f)e022096)clone::PrepareCheckout::main_worktree`` ([938f518`](https://github.com/GitoxideLabs/gitoxide/commit/938f5187f0ff51561971ca463584ec0db93f3455))maybe_async (c80e809)d82f84b)remote::fetch::Prepare::receive (44faa01)3eb8653)6a33594)progress in PrepareFetch::fetch_only (70989b3)d5aa2ba)Repository::write_blob_stream: Avoid dup codegen (ca8a373)gix_macros::momo to Repository::write_blob (bae928d)Repository::write_object: Avoid dup momo (32f1c7d)Repository::commit_as_inner (cf70a2e)gix: de-momo impl TryInto by hand (b19c140)
</details>interrupt feature only gates signal-handling, but leaves the interrupt module alone.
interrupt feature only gates signal-handling, but leaves the interrupt module alone.<csr-read-only-do-not-edit/>
<csr-read-only-do-not-edit/>
<details><summary>view details</summary>
One column per quarter.