Struct gix::config::CommitAutoRollback

pub struct CommitAutoRollback<'repo> { /* private fields */ }

A utility structure created by SnapshotMut::commit_auto_rollback() that restores the previous configuration on drop.

Implementations

impl<'repo> CommitAutoRollback<'repo>

Utilities

pub fn rollback(self) -> Result<&'repo mut Repository, Error>

Rollback the changes previously applied and all values before the change.

Methods from Deref<Target = Repository>

pub fn attributes( &self, index: &State, attributes_source: Source, ignore_source: Source, exclude_overrides: Option<Search> ) -> Result<AttributeStack<'_>, Error>

Available on (crate features attributes or excludes) and crate feature attributes only.

Configure a file-system cache for accessing git attributes and excludes on a per-path basis.

Use attribute_source to specify where to read attributes from. Also note that exclude information will always try to read .gitignore files from disk before trying to read it from the index.

Note that no worktree is required for this to work, even though access to in-tree .gitattributes and .gitignore files would require a non-empty index that represents a git tree.

This takes into consideration all the usual repository configuration, namely:

• $XDG_CONFIG_HOME/…/ignore|attributes if core.excludesFile|attributesFile is not set, otherwise use the configured file.
• $GIT_DIR/info/exclude|attributes if present.

pub fn attributes_only( &self, index: &State, attributes_source: Source ) -> Result<AttributeStack<'_>, Error>

Available on (crate features attributes or excludes) and crate feature attributes only.

Like attributes(), but without access to exclude/ignore information.

pub fn excludes( &self, index: &State, overrides: Option<Search>, source: Source ) -> Result<AttributeStack<'_>, Error>

Available on (crate features attributes or excludes) and crate feature excludes only.

Configure a file-system cache checking if files below the repository are excluded, reading .gitignore files from the specified source.

Note that no worktree is required for this to work, even though access to in-tree .gitignore files would require a non-empty index that represents a tree with .gitignore files.

This takes into consideration all the usual repository configuration, namely:

• $XDG_CONFIG_HOME/…/ignore if core.excludesFile is not set, otherwise use the configured file.
• $GIT_DIR/info/exclude if present.

When only excludes are desired, this is the most efficient way to obtain them. Otherwise use Repository::attributes() for accessing both attributes and excludes.

pub fn object_cache_size(&mut self, bytes: impl Into<Option<usize>>)

Sets the amount of space used at most for caching most recently accessed fully decoded objects, to Some(bytes), or None to deactivate it entirely.

Note that it is unset by default but can be enabled once there is time for performance optimization. Well-chosen cache sizes can improve performance particularly if objects are accessed multiple times in a row. The cache is configured to grow gradually.

Note that a cache on application level should be considered as well as the best object access is not doing one.

pub fn object_cache_size_if_unset(&mut self, bytes: usize)

Set an object cache of size bytes if none is set.

Use this method to avoid overwriting any existing value while assuring better performance in case no value is set.

pub fn branch_names(&self) -> BTreeSet<&str>

Return a set of unique short branch names for which custom configuration exists in the configuration, if we deem them trustworthy.

Note

Branch names that have illformed UTF-8 will silently be skipped.

pub fn branch_remote_ref_name( &self, name: &FullNameRef, direction: Direction ) -> Option<Result<Cow<'_, FullNameRef>, Error>>

Returns the validated reference on the remote associated with the given name, which will be used when merging. The returned value corresponds to the branch.<short_branch_name>.merge configuration key.

Returns None if there is no value at the given key, or if no remote or remote ref is configured. May return an error if the reference name to be returned is invalid.

Note

This name refers to what Git calls upstream branch (as opposed to upstream tracking branch). The value is also fast to retrieve compared to its tracking branch. Also note that a remote::Direction isn’t used here as Git only supports (and requires) configuring the remote to fetch from, not the one to push to.

See also Reference::remote_ref_name().

pub fn branch_remote_tracking_ref_name( &self, name: &FullNameRef, direction: Direction ) -> Option<Result<Cow<'_, FullNameRef>, Error>>

Return the validated name of the reference that tracks the corresponding reference of name on the remote for direction. Note that a branch with that name might not actually exist.

• with remote being remote::Direction::Fetch, we return the tracking branch that is on the destination side of a src:dest refspec. For instance, with name being main and the default refspec refs/heads/*:refs/remotes/origin/*, refs/heads/main would match and produce refs/remotes/origin/main.
• with remote being remote::Direction::Push, we return the tracking branch that corresponds to the remote branch that we would push to. For instance, with name being main and no setup at all, we would push to refs/heads/main on the remote. And that one would be fetched matching the refs/heads/*:refs/remotes/origin/* fetch refspec, hence refs/remotes/origin/main is returned. Note that push refspecs can be used to map main to other (using a push refspec refs/heads/main:refs/heads/other), which would then lead to refs/remotes/origin/other to be returned instead.

Note that if there is an ambiguity, that is if name maps to multiple tracking branches, the first matching mapping is returned, according to the order in which the fetch or push refspecs occur in the configuration file.

See also Reference::remote_tracking_ref_name().

pub fn branch_remote_name<'a>( &self, short_branch_name: impl Into<&'a BStr>, direction: Direction ) -> Option<Name<'_>>

Returns the unvalidated name of the remote associated with the given short_branch_name, typically main instead of refs/heads/main. In some cases, the returned name will be an URL. Returns None if the remote was not found or if the name contained illformed UTF-8.

• if direction is remote::Direction::Fetch, we will query the branch.<short_name>.remote configuration.
• if direction is remote::Direction::Push, the push remote will be queried by means of branch.<short_name>.pushRemote or remote.pushDefault as fallback.

See also Reference::remote_name() for a more typesafe version to be used when a Reference is available.

short_branch_name can typically be obtained by shortening a full branch name.

pub fn branch_remote<'a>( &self, short_branch_name: impl Into<&'a BStr>, direction: Direction ) -> Option<Result<Remote<'_>, Error>>

Like branch_remote_name(…), but returns a Remote. short_branch_name is the name to use for looking up branch.<short_branch_name>.* values in the configuration.

See also Reference::remote().

pub fn remote_names(&self) -> BTreeSet<Cow<'_, BStr>>

Returns a sorted list unique of symbolic names of remotes that we deem trustworthy.

pub fn remote_default_name(&self, direction: Direction) -> Option<Cow<'_, BStr>>

Obtain the branch-independent name for a remote for use in the given direction, or None if it could not be determined.

For fetching, use the only configured remote, or default to origin if it exists. For pushing, use the remote.pushDefault trusted configuration key, or fall back to the rules for fetching.

Notes

It’s up to the caller to determine what to do if the current head is unborn or detached.

pub fn transport_options<'a>( &self, url: impl Into<&'a BStr>, remote_name: Option<&BStr> ) -> Result<Option<Box<dyn Any>>, Error>

Available on crate features blocking-network-client or async-network-client only.

Produce configuration suitable for url, as differentiated by its protocol/scheme, to be passed to a transport instance via configure() (via &**config to pass the contained Any and not the Box). None is returned if there is no known configuration. If remote_name is not None, the remote’s name may contribute to configuration overrides, typically for the HTTP transport.

Note that the caller may cast the instance themselves to modify it before passing it on.

For transports that support proxy authentication, the default authentication method will be used with the url of the proxy if it contains a user name.

pub fn config_snapshot(&self) -> Snapshot<'_>

Return a snapshot of the configuration as seen upon opening the repository.

pub fn config_snapshot_mut(&mut self) -> SnapshotMut<'_>

Return a mutable snapshot of the configuration as seen upon opening the repository, starting a transaction. When the returned instance is dropped, it is applied in full, even if the reason for the drop is an error.

Note that changes to the configuration are in-memory only and are observed only the this instance of the Repository.

pub fn filesystem_options(&self) -> Result<Capabilities, Error>

Return filesystem options as retrieved from the repository configuration.

Note that these values have not been probed.

pub fn stat_options(&self) -> Result<Options, Error>

Available on crate feature index only.

Return filesystem options on how to perform stat-checks, typically in relation to the index.

Note that these values have not been probed.

pub fn open_options(&self) -> &Options

The options used to open the repository.

pub fn ssh_connect_options(&self) -> Result<Options, Error>

Available on crate feature blocking-network-client only.

Obtain options for use when connecting via ssh.

pub fn command_context(&self) -> Result<Context, Error>

Available on crate feature attributes only.

Return the context to be passed to any spawned program that is supposed to interact with the repository, like hooks or filters.

pub fn object_hash(&self) -> Kind

The kind of object hash the repository is configured to use.

pub fn diff_resource_cache( &self, mode: Mode, worktree_roots: WorktreeRoots ) -> Result<Platform, Error>

Available on crate feature blob-diff only.

Create a resource cache for diffable objects, and configured with everything it needs to know to perform diffs faithfully just like git would. mode controls what version of a resource should be diffed. worktree_roots determine if files can be read from the worktree, where each side of the diff operation can be represented by its own worktree root. .gitattributes are automatically read from the worktree if at least one worktree is present.

Note that attributes will always be obtained from the current HEAD index even if the resources being diffed might live in another tree. Further, if one of the worktree_roots are set, attributes will also be read from the worktree. Otherwise, it will be skipped and attributes are read from the index tree instead.

pub fn dirwalk_options(&self) -> Result<Options, Error>

Available on crate feature dirwalk only.

Return default options suitable for performing a directory walk on this repository.

Used in conjunction with dirwalk()

pub fn dirwalk( &self, index: &State, patterns: impl IntoIterator<Item = impl AsRef<BStr>>, should_interrupt: &AtomicBool, options: Options, delegate: &mut dyn Delegate ) -> Result<Outcome<'_>, Error>

Available on crate feature dirwalk only.

Perform a directory walk configured with options under control of the delegate. Use patterns to further filter entries. should_interrupt is polled to see if an interrupt is requested, causing an error to be returned instead.

The index is used to determine if entries are tracked, and for excludes and attributes lookup. Note that items will only count as tracked if they have the gix_index::entry::Flags::UPTODATE flag set.

See gix_dir::walk::delegate::Collect for a delegate that collects all seen entries.

pub fn dirwalk_iter( &self, index: impl Into<IndexPersistedOrInMemory>, patterns: impl IntoIterator<Item = impl Into<BString>>, should_interrupt: OwnedOrStaticAtomicBool, options: Options ) -> Result<Iter, Error>

Available on crate feature dirwalk only.

Create an iterator over a running traversal, which stops if the iterator is dropped. All arguments are the same as in dirwalk().

should_interrupt should be set to Default::default() if it is supposed to be unused. Otherwise, it can be created by passing a &'static AtomicBool, &Arc<AtomicBool> or Arc<AtomicBool>.

pub fn filter_pipeline( &self, tree_if_bare: Option<ObjectId> ) -> Result<(Pipeline<'_>, IndexPersistedOrInMemory), Error>

Available on crate feature attributes only.

Configure a pipeline for converting byte buffers to the worktree representation, and byte streams to the git-internal representation. Also return the index that was used when initializing the pipeline as it may be useful when calling convert_to_git(). Bare repositories will either use HEAD^{tree} for accessing all relevant worktree files or the given tree_if_bare.

Note that this is considered a primitive as it operates on data directly and will not have permanent effects. We also return the index that was used to configure the attributes cache (for accessing .gitattributes), which can be reused after it was possibly created from a tree, an expensive operation.

Performance

Note that when in a repository with worktree, files in the worktree will be read with priority, which causes at least a stat each time the directory is changed. This can be expensive if access isn’t in sorted order, which would cause more then necessary stats: one per directory.

pub fn revision_graph<T>(&self) -> Graph<'_, T>

Create a graph data-structure capable of accelerating graph traversals and storing state of type T with each commit it encountered.

Note that the commitgraph will be used if it is present and readable, but it won’t be an error if it is corrupted. In that case, it will just not be used.

Note that a commitgraph is only allowed to be used if core.commitGraph is true (the default), and that configuration errors are ignored as well.

Performance

Note that the Graph can be sensitive to various object database settings that may affect the performance of the commit walk.

pub fn commit_graph(&self) -> Result<Graph, Error>

Return a cache for commits and their graph structure, as managed by git commit-graph, for accelerating commit walks on a low level.

Note that revision_graph() should be preferred for general purpose walks that don’t rely on the actual commit cache to be present, while leveraging it if possible.

pub fn committer(&self) -> Option<Result<SignatureRef<'_>, Error>>

Return the committer as configured by this repository, which is determined by…

• …the git configuration committer.name|email…
• …the GIT_COMMITTER_(NAME|EMAIL|DATE) environment variables…
• …the configuration for user.name|email as fallback…

…and in that order, or None if no committer name or email was configured, or Some(Err(…)) if the committer date could not be parsed.

Note

The values are cached when the repository is instantiated.

pub fn author(&self) -> Option<Result<SignatureRef<'_>, Error>>

Return the author as configured by this repository, which is determined by…

• …the git configuration author.name|email…
• …the GIT_AUTHOR_(NAME|EMAIL|DATE) environment variables…
• …the configuration for user.name|email as fallback…

…and in that order, or None if there was nothing configured.

Note

The values are cached when the repository is instantiated.

pub fn open_index(&self) -> Result<File, Error>

Available on crate feature index only.

Open a new copy of the index file and decode it entirely.

It will use the index.threads configuration key to learn how many threads to use. Note that it may fail if there is no index.

pub fn index(&self) -> Result<Index, Error>

Available on crate feature index only.

Return a shared worktree index which is updated automatically if the in-memory snapshot has become stale as the underlying file on disk has changed.

Notes

• This will fail if the file doesn’t exist, like in a newly initialized repository. If that is the case, use index_or_empty() or try_index() instead.

The index file is shared across all clones of this repository.

pub fn index_or_empty(&self) -> Result<Index, Error>

Available on crate feature index only.

Return the shared worktree index if present, or return a new empty one which has an association to the place where the index would be.

pub fn try_index(&self) -> Result<Option<Index>, Error>

Available on crate feature index only.

Return a shared worktree index which is updated automatically if the in-memory snapshot has become stale as the underlying file on disk has changed, or None if no such file exists.

The index file is shared across all clones of this repository.

pub fn index_or_load_from_head(&self) -> Result<IndexPersistedOrInMemory, Error>

Available on crate feature index only.

Open the persisted worktree index or generate it from the current HEAD^{tree} to live in-memory only.

Use this method to get an index in any repository, even bare ones that don’t have one naturally.

Note

The locally stored index is not guaranteed to represent HEAD^{tree} if this repository is bare - bare repos don’t naturally have an index and if an index is present it must have been generated by hand.

pub fn index_from_tree(&self, tree: &oid) -> Result<File, Error>

Available on crate feature index only.

Create new index-file, which would live at the correct location, in memory from the given tree.

Note that this is an expensive operation as it requires recursively traversing the entire tree to unpack it into the index.

pub fn git_dir(&self) -> &Path

Return the path to the repository itself, containing objects, references, configuration, and more.

Synonymous to path().

pub fn git_dir_trust(&self) -> Trust

The trust we place in the git-dir, with lower amounts of trust causing access to configuration to be limited.

pub fn current_dir(&self) -> &Path

Return the current working directory as present during the instantiation of this repository.

Note that this should be preferred over manually obtaining it as this may have been adjusted to deal with core.precomposeUnicode.

pub fn common_dir(&self) -> &Path

Returns the main git repository if this is a repository on a linked work-tree, or the git_dir itself.

pub fn index_path(&self) -> PathBuf

Return the path to the worktree index file, which may or may not exist.

pub fn modules_path(&self) -> Option<PathBuf>

Available on crate feature attributes only.

The path to the .gitmodules file in the worktree, if a worktree is available.

pub fn path(&self) -> &Path

The path to the .git directory itself, or equivalent if this is a bare repository.

pub fn work_dir(&self) -> Option<&Path>

Return the work tree containing all checked out files, if there is one.

pub fn install_dir(&self) -> Result<PathBuf>

The directory of the binary path of the current process.

pub fn prefix(&self) -> Result<Option<&Path>, Error>

Returns the relative path which is the components between the working tree and the current working dir (CWD). Note that it may be None if there is no work tree, or if CWD isn’t inside of the working tree directory.

Note that the CWD is obtained once upon instantiation of the repository.

pub fn kind(&self) -> Kind

Return the kind of repository, either bare or one with a work tree.

pub fn open_mailmap(&self) -> Snapshot

Available on crate feature mailmap only.

Similar to open_mailmap_into(), but ignores all errors and returns at worst an empty mailmap, e.g. if there is no mailmap or if there were errors loading them.

This represents typical usage within git, which also works with what’s there without considering a populated mailmap a reason to abort an operation, considering it optional.

pub fn open_mailmap_into(&self, target: &mut Snapshot) -> Result<(), Error>

Available on crate feature mailmap only.

Try to merge mailmaps from the following locations into target:

• read the .mailmap file without following symlinks from the working tree, if present
• OR read HEAD:.mailmap if this repository is bare (i.e. has no working tree), if the mailmap.blob is not set.
• read the mailmap as configured in mailmap.blob, if set.
• read the file as configured by mailmap.file, following symlinks, if set.

Only the first error will be reported, and as many source mailmaps will be merged into target as possible. Parsing errors will be ignored.

pub fn find_object(&self, id: impl Into<ObjectId>) -> Result<Object<'_>, Error>

Find the object with id in the object database or return an error if it could not be found.

There are various legitimate reasons for an object to not be present, which is why try_find_object(…) might be preferable instead.

Performance Note

In order to get the kind of the object, is must be fully decoded from storage if it is packed with deltas. Loose object could be partially decoded, even though that’s not implemented.

pub fn find_header(&self, id: impl Into<ObjectId>) -> Result<Header, Error>

Obtain information about an object without fully decoding it, or fail if the object doesn’t exist.

Note that despite being cheaper than Self::find_object(), there is still some effort traversing delta-chains.

pub fn has_object(&self, id: impl AsRef<oid>) -> bool

Return true if id exists in the object database.

Performance

This method can be slow if the underlying object database has an unsuitable RefreshMode and id is not likely to exist. Use repo.objects.refresh_never() to avoid expensive IO-bound refreshes if an object wasn’t found.

pub fn try_find_header( &self, id: impl Into<ObjectId> ) -> Result<Option<Header>, Error>

Obtain information about an object without fully decoding it, or None if the object doesn’t exist.

Note that despite being cheaper than Self::try_find_object(), there is still some effort traversing delta-chains.

pub fn try_find_object( &self, id: impl Into<ObjectId> ) -> Result<Option<Object<'_>>, Error>

Try to find the object with id or return None if it wasn’t found.

pub fn write_object(&self, object: impl WriteTo) -> Result<Id<'_>, Error>

Write the given object into the object database and return its object id.

Note that we hash the object in memory to avoid storing objects that are already present. That way, we avoid writing duplicate objects using slow disks that will eventually have to be garbage collected.

pub fn write_blob(&self, bytes: impl AsRef<[u8]>) -> Result<Id<'_>, Error>

Write a blob from the given bytes.

We avoid writing duplicate objects to slow disks that will eventually have to be garbage collected by pre-hashing the data, and checking if the object is already present.

pub fn write_blob_stream( &self, bytes: impl Read + Seek ) -> Result<Id<'_>, Error>

Write a blob from the given Read implementation.

Note that we hash the object in memory to avoid storing objects that are already present. That way, we avoid writing duplicate objects using slow disks that will eventually have to be garbage collected.

If that is prohibitive, use the object database directly.

pub fn tag( &self, name: impl AsRef<str>, target: impl AsRef<oid>, target_kind: Kind, tagger: Option<SignatureRef<'_>>, message: impl AsRef<str>, constraint: PreviousValue ) -> Result<Reference<'_>, Error>

Create a tag reference named name (without refs/tags/ prefix) pointing to a newly created tag object which in turn points to target and return the newly created reference.

It will be created with constraint which is most commonly to only create it or to force overwriting a possibly existing tag.

pub fn commit_as<'a, 'c, Name, E>( &self, committer: impl Into<SignatureRef<'c>>, author: impl Into<SignatureRef<'a>>, reference: Name, message: impl AsRef<str>, tree: impl Into<ObjectId>, parents: impl IntoIterator<Item = impl Into<ObjectId>> ) -> Result<Id<'_>, Error>

where Name: TryInto<FullName, Error = E>, Error: From<E>,

Similar to commit(…), but allows to create the commit with committer and author specified.

This forces setting the commit time and author time by hand. Note that typically, committer and author are the same.

pub fn commit<Name, E>( &self, reference: Name, message: impl AsRef<str>, tree: impl Into<ObjectId>, parents: impl IntoIterator<Item = impl Into<ObjectId>> ) -> Result<Id<'_>, Error>

where Name: TryInto<FullName, Error = E>, Error: From<E>,

Create a new commit object with message referring to tree with parents, and point reference to it. The commit is written without message encoding field, which can be assumed to be UTF-8. author and committer fields are pre-set from the configuration, which can be altered temporarily before the call if required.

reference will be created if it doesn’t exist, and can be "HEAD" to automatically write-through to the symbolic reference that HEAD points to if it is not detached. For this reason, detached head states cannot be created unless the HEAD is detached already. The reflog will be written as canonical git would do, like <operation> (<detail>): <summary>.

The first parent id in parents is expected to be the current target of reference and the operation will fail if it is not. If there is no parent, the reference is expected to not exist yet.

The method fails immediately if a reference lock can’t be acquired.

pub fn empty_tree(&self) -> Tree<'_>

Return an empty tree object, suitable for getting changes.

Note that the returned object is special and doesn’t necessarily physically exist in the object database. This means that this object can be used in an uninitialized, empty repository which would report to have no objects at all.

pub fn empty_blob(&self) -> Blob<'_>

Return an empty blob object.

Note that the returned object is special and doesn’t necessarily physically exist in the object database. This means that this object can be used in an uninitialized, empty repository which would report to have no objects at all.

pub fn pathspec( &self, empty_patterns_match_prefix: bool, patterns: impl IntoIterator<Item = impl AsRef<BStr>>, inherit_ignore_case: bool, index: &State, attributes_source: Source ) -> Result<Pathspec<'_>, Error>

Available on crate feature attributes only.

Create a new pathspec abstraction that allows to conduct searches using patterns. inherit_ignore_case should be true if patterns will match against files on disk, or false otherwise, for more natural matching (but also note that git does not do that). index may be needed to load attributes which is required only if patterns refer to attributes via :(attr:…) syntax. In the same vein, attributes_source affects where .gitattributes files are read from if pathspecs need to match against attributes. If empty_patterns_match_prefix is true, then even empty patterns will match only what’s inside of the prefix. Otherwise they will match everything.

It will be initialized exactly how it would, and attribute matching will be conducted by reading the worktree first if available. If that is not desirable, consider calling Pathspec::new() directly.

pub fn pathspec_defaults(&self) -> Result<Defaults, Error>

Available on crate feature attributes only.

Return default settings that are required when parsing pathspecs by hand.

These are stemming from environment variables which have been converted to config settings, which now serve as authority for configuration.

pub fn pathspec_defaults_inherit_ignore_case( &self, inherit_ignore_case: bool ) -> Result<Defaults, Error>

Available on crate feature attributes only.

Similar to Self::pathspec_defaults(), but will automatically configure the returned defaults to match case-insensitively if the underlying filesystem is also configured to be case-insensitive according to core.ignoreCase, and inherit_ignore_case is true.

pub fn tag_reference( &self, name: impl AsRef<str>, target: impl Into<ObjectId>, constraint: PreviousValue ) -> Result<Reference<'_>, Error>

Create a lightweight tag with given name (and without refs/tags/ prefix) pointing to the given target, and return it as reference.

It will be created with constraint which is most commonly to only create it or to force overwriting a possibly existing tag.

pub fn namespace(&self) -> Option<&Namespace>

Returns the currently set namespace for references, or None if it is not set.

Namespaces allow to partition references, and is configured per Easy.

pub fn clear_namespace(&mut self) -> Option<Namespace>

Remove the currently set reference namespace and return it, affecting only this Easy.

pub fn set_namespace<'a, Name, E>( &mut self, namespace: Name ) -> Result<Option<Namespace>, Error>

where Name: TryInto<&'a PartialNameRef, Error = E>, Error: From<E>,

Set the reference namespace to the given value, like "foo" or "foo/bar".

Note that this value is shared across all Easy… instances as the value is stored in the shared Repository.

pub fn reference<Name, E>( &self, name: Name, target: impl Into<ObjectId>, constraint: PreviousValue, log_message: impl Into<BString> ) -> Result<Reference<'_>, Error>

where Name: TryInto<FullName, Error = E>, Error: From<E>,

Create a new reference with name, like refs/heads/branch, pointing to target, adhering to constraint during creation and writing log_message into the reflog. Note that a ref-log will be written even if log_message is empty.

The newly created Reference is returned.

pub fn edit_reference(&self, edit: RefEdit) -> Result<Vec<RefEdit>, Error>

Edit a single reference as described in edit, and write reference logs as log_committer.

One or more RefEdits are returned - symbolic reference splits can cause more edits to be performed. All edits have the previous reference values set to the ones encountered at rest after acquiring the respective reference’s lock.

pub fn edit_references( &self, edits: impl IntoIterator<Item = RefEdit> ) -> Result<Vec<RefEdit>, Error>

Edit one or more references as described by their edits. Note that one can set the committer name for use in the ref-log by temporarily overriding the git-config.

Returns all reference edits, which might be more than where provided due the splitting of symbolic references, and whose previous (old) values are the ones seen on in storage after the reference was locked.

pub fn head(&self) -> Result<Head<'_>, Error>

Return the repository head, an abstraction to help dealing with the HEAD reference.

The HEAD reference can be in various states, for more information, the documentation of Head.

pub fn head_id(&self) -> Result<Id<'_>, Error>

Resolve the HEAD reference, follow and peel its target and obtain its object id, following symbolic references and tags until a commit is found.

Note that this may fail for various reasons, most notably because the repository is freshly initialized and doesn’t have any commits yet.

Also note that the returned id is likely to point to a commit, but could also point to a tree or blob. It won’t, however, point to a tag as these are always peeled.

pub fn head_name(&self) -> Result<Option<FullName>, Error>

Return the name to the symbolic reference HEAD points to, or None if the head is detached.

The difference to head_ref() is that the latter requires the reference to exist, whereas here we merely return a the name of the possibly unborn reference.

pub fn head_ref(&self) -> Result<Option<Reference<'_>>, Error>

Return the reference that HEAD points to, or None if the head is detached or unborn.

pub fn head_commit(&self) -> Result<Commit<'_>, Error>

Return the commit object the HEAD reference currently points to after peeling it fully, following symbolic references and tags until a commit is found.

Note that this may fail for various reasons, most notably because the repository is freshly initialized and doesn’t have any commits yet. It could also fail if the head does not point to a commit.

pub fn head_tree_id(&self) -> Result<Id<'_>, Error>

Return the tree id the HEAD reference currently points to after peeling it fully, following symbolic references and tags until a commit is found.

Note that this may fail for various reasons, most notably because the repository is freshly initialized and doesn’t have any commits yet. It could also fail if the head does not point to a commit.

pub fn find_reference<'a, Name, E>( &self, name: Name ) -> Result<Reference<'_>, Error>

where Name: TryInto<&'a PartialNameRef, Error = E>, Error: From<E>,

Find the reference with the given partial or full name, like main, HEAD, heads/branch or origin/other, or return an error if it wasn’t found.

Consider try_find_reference(…) if the reference might not exist without that being considered an error.

pub fn references(&self) -> Result<Platform<'_>, Error>

Return a platform for iterating references.

Common kinds of iteration are all or prefixed references.

pub fn try_find_reference<'a, Name, E>( &self, name: Name ) -> Result<Option<Reference<'_>>, Error>

where Name: TryInto<&'a PartialNameRef, Error = E>, Error: From<E>,

Try to find the reference named name, like main, heads/branch, HEAD or origin/other, and return it.

Otherwise return None if the reference wasn’t found. If the reference is expected to exist, use find_reference().

pub fn remote_at<Url, E>(&self, url: Url) -> Result<Remote<'_>, Error>

where Url: TryInto<Url, Error = E>, Error: From<E>,

Create a new remote available at the given url.

It’s configured to fetch included tags by default, similar to git. See with_fetch_tags(…) for a way to change it.

pub fn remote_at_without_url_rewrite<Url, E>( &self, url: Url ) -> Result<Remote<'_>, Error>

where Url: TryInto<Url, Error = E>, Error: From<E>,

Create a new remote available at the given url similarly to remote_at(), but don’t rewrite the url according to rewrite rules. This eliminates a failure mode in case the rewritten URL is faulty, allowing to selectively apply rewrite rules later and do so non-destructively.

pub fn find_remote<'a>( &self, name_or_url: impl Into<&'a BStr> ) -> Result<Remote<'_>, Error>

Find the configured remote with the given name_or_url or report an error, similar to try_find_remote(…).

Note that we will obtain remotes only if we deem them trustworthy.

pub fn find_default_remote( &self, direction: Direction ) -> Option<Result<Remote<'_>, Error>>

Find the default remote as configured, or None if no such configuration could be found.

See remote_default_name() for more information on the direction parameter.

pub fn try_find_remote<'a>( &self, name_or_url: impl Into<&'a BStr> ) -> Option<Result<Remote<'_>, Error>>

Find the configured remote with the given name_or_url or return None if it doesn’t exist, for the purpose of fetching or pushing data.

There are various error kinds related to partial information or incorrectly formatted URLs or ref-specs. Also note that the created Remote may have neither fetch nor push ref-specs set at all.

Note that ref-specs are de-duplicated right away which may change their order. This doesn’t affect matching in any way as negations/excludes are applied after includes.

We will only include information if we deem it trustworthy.

pub fn find_fetch_remote( &self, name_or_url: Option<&BStr> ) -> Result<Remote<'_>, Error>

This method emulate what git fetch <remote> does in order to obtain a remote to fetch from.

As such, with name_or_url being Some, it will:

• use name_or_url verbatim if it is a URL, creating a new remote in memory as needed.
• find the named remote if name_or_url is a remote name

If name_or_url is None:

• use the current HEAD branch to find a configured remote
• fall back to either a generally configured remote or the only configured remote.

Fail if no remote could be found despite all of the above.

pub fn try_find_remote_without_url_rewrite<'a>( &self, name_or_url: impl Into<&'a BStr> ) -> Option<Result<Remote<'_>, Error>>

Similar to try_find_remote(), but removes a failure mode if rewritten URLs turn out to be invalid as it skips rewriting them. Use this in conjunction with Remote::rewrite_urls() to non-destructively apply the rules and keep the failed urls unchanged.

pub fn rev_parse<'a>( &self, spec: impl Into<&'a BStr> ) -> Result<Spec<'_>, Error>

Available on crate feature revision only.

Parse a revision specification and turn it into the object(s) it describes, similar to git rev-parse.

Deviation

• @ actually stands for HEAD, whereas git resolves it to the object pointed to by HEAD without making the HEAD ref available for lookups.

pub fn rev_parse_single<'repo, 'a>( &'repo self, spec: impl Into<&'a BStr> ) -> Result<Id<'repo>, Error>

Available on crate feature revision only.

Parse a revision specification and return single object id as represented by this instance.

pub fn rev_walk( &self, tips: impl IntoIterator<Item = impl Into<ObjectId>> ) -> Platform<'_>

Available on crate feature revision only.

Create the baseline for a revision walk by initializing it with the tips to start iterating on.

It can be configured further before starting the actual walk.

pub fn is_shallow(&self) -> bool

Return true if the repository is a shallow clone, i.e. contains history only up to a certain depth.

pub fn shallow_commits(&self) -> Result<Option<Commits>, Error>

Return a shared list of shallow commits which is updated automatically if the in-memory snapshot has become stale as the underlying file on disk has changed.

The list of shallow commits represents the shallow boundary, beyond which we are lacking all (parent) commits. Note that the list is never empty, as Ok(None) is returned in that case indicating the repository isn’t a shallow clone.

The shared list is shared across all clones of this repository.

pub fn shallow_file(&self) -> PathBuf

Return the path to the shallow file which contains hashes, one per line, that describe commits that don’t have their parents within this repository.

Note that it may not exist if the repository isn’t actually shallow.

pub fn state(&self) -> Option<InProgress>

Returns the status of an in progress operation on a repository or None if no operation is currently in progress.

Note to be confused with the repositories ‘status’.

pub fn open_modules_file(&self) -> Result<Option<File>, Error>

Available on crate feature attributes only.

Open the .gitmodules file as present in the worktree, or return None if no such file is available. Note that git configuration is also contributing to the result based on the current snapshot.

Note that his method will not look in other places, like the index or the HEAD tree.

pub fn modules(&self) -> Result<Option<ModulesSnapshot>, Error>

Available on crate feature attributes only.

Return a shared .gitmodules file which is updated automatically if the in-memory snapshot has become stale as the underlying file on disk has changed. The snapshot based on the file on disk is shared across all clones of this repository.

If a file on disk isn’t present, we will try to load it from the index, and finally from the current tree. In the latter two cases, the result will not be cached in this repository instance as we can’t detect freshness anymore, so time this method is called a new modules file will be created.

Note that git configuration is also contributing to the result based on the current snapshot.

pub fn submodules( &self ) -> Result<Option<impl Iterator<Item = Submodule<'_>>>, Error>

Available on crate feature attributes only.

Return the list of available submodules, or None if there is no submodule configuration.

pub fn worktrees(&self) -> Result<Vec<Proxy<'_>>>

Return a list of all linked worktrees sorted by private git dir path as a lightweight proxy.

Note that these need additional processing to become usable, but provide a first glimpse a typical worktree information.

pub fn main_repo(&self) -> Result<Repository, Error>

Return the repository owning the main worktree, typically from a linked worktree.

Note that it might be the one that is currently open if this repository doesn’t point to a linked worktree. Also note that the main repo might be bare.

pub fn worktree(&self) -> Option<Worktree<'_>>

Return the currently set worktree if there is one, acting as platform providing a validated worktree base path.

Note that there would be None if this repository is bare and the parent Repository was instantiated without registered worktree in the current working dir, even if no .git file or directory exists. It’s merely based on configuration, see Worktree::dot_git_exists() for a way to perform more validation.

pub fn is_bare(&self) -> bool

Return true if this repository is bare, and has no main work tree.

This is not to be confused with the worktree() worktree, which may exists if this instance was opened in a worktree that was created separately.

pub fn worktree_stream( &self, id: impl Into<ObjectId> ) -> Result<(Stream, File), Error>

Available on crate feature worktree-stream only.

If id points to a tree, produce a stream that yields one worktree entry after the other. The index of the tree at id is returned as well as it is an intermediate byproduct that might be useful to callers.

The entries will look exactly like they would if one would check them out, with filters applied. The export-ignore attribute is used to skip blobs or directories to which it applies.

pub fn worktree_archive( &self, stream: Stream, out: impl Write + Seek, blobs: impl Count, should_interrupt: &AtomicBool, options: Options ) -> Result<(), Error>

Available on crate feature worktree-archive only.

Produce an archive from the stream and write it to out according to options. Use blob to provide progress for each entry written to out, and note that it should already be initialized to the amount of expected entries, with should_interrupt being queried between each entry to abort if needed, and on each write to out.

Performance

Be sure that out is able to handle a lot of write calls. Otherwise wrap it in a BufWriter.

Additional progress and fine-grained interrupt handling

For additional progress reporting, wrap out into a writer that counts throughput on each write. This can also be used to react to interrupts on each write, instead of only for each entry.

pub fn is_dirty(&self) -> Result<bool, Error>

Available on crate feature status only.

Returns true if the repository is dirty. This means it’s changed in one of the following ways:

• the index was changed in comparison to its working tree
• the working tree was changed in comparison to the index
• submodules are taken in consideration, along with their ignore and isActive configuration

Note that untracked files do not affect this flag.

Incomplete Implementation Warning

Currently, this does not compute changes between the head and the index.

pub fn index_worktree_status<'index, T, U, E>( &self, index: &'index State, patterns: impl IntoIterator<Item = impl AsRef<BStr>>, delegate: &mut impl VisitEntry<'index, ContentChange = T, SubmoduleStatus = U>, compare: impl CompareBlobs<Output = T> + Send + Clone, submodule: impl SubmoduleStatus<Output = U, Error = E> + Send + Clone, progress: &mut dyn Progress, should_interrupt: &AtomicBool, options: Options ) -> Result<Outcome, Error>

where T: Send + Clone, U: Send + Clone, E: Error + Send + Sync + 'static,

Available on crate feature status only.

Obtain the status between the index and the worktree, involving modification checks for all tracked files along with information about untracked (and posisbly ignored) files (if configured).

• index
  • The index to use for modification checks, and to know which files are tacked when applying the dirwalk.
• patterns
  • Optional patterns to use to limit the paths to look at. If empty, all paths are considered.
• delegate
  • The sink for receiving all status data.
• compare
  • The implementations for fine-grained control over what happens if a hash must be recalculated.
• submodule
  • Control what kind of information to retrieve when a submodule is encountered while traversing the index.
• progress
  • A progress indication for index modification checks.
• should_interrupt
  • A flag to stop the whole operation.
• options
  • Additional configuration for all parts of the operation.

Note

This is a lower-level method, prefer the status method for greater ease of use.

pub fn status<P>(&self, progress: P) -> Result<Platform<'_, P>, Error>

where P: Progress + 'static,

Available on crate feature status only.

Obtain a platform for configuring iterators for traversing git repository status information.

By default, this is set to the fastest and most immediate way of obtaining a status, which is most similar to

git status --ignored=no

which implies that submodule information is provided by default.

Note that status.showUntrackedFiles is respected, which leads to untracked files being collapsed by default. If that needs to be controlled, configure the directory walk explicitly or more implicitly.

Pass progress to receive progress information on file modifications on this repository. Use progress::Discard to discard all progress information.

Deviation

Whereas Git runs the index-modified check before the directory walk to set entries as up-to-date to (potentially) safe some disk-access, we run both in parallel which ultimately is much faster.

Trait Implementations

impl Debug for CommitAutoRollback<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for CommitAutoRollback<'_>

type Target = Repository

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for CommitAutoRollback<'_>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for CommitAutoRollback<'_>

fn drop(&mut self)

Executes the destructor for this type.