Struct branchless::git::Repo

pub struct Repo { /* private fields */ }

Wrapper around git2::Repository.

Implementations

impl Repo

pub fn from_dir(path: &Path) -> Result<Self>

Get the Git repository associated with the given directory.

pub fn from_current_dir() -> Result<Self>

Get the Git repository associated with the current directory.

pub fn try_clone(&self) -> Result<Self>

Open a new copy of the repository.

pub fn get_path(&self) -> &Path

Get the path to the .git directory for the repository.

pub fn get_packed_refs_path(&self) -> PathBuf

Get the path to the packed-refs file for the repository.

pub fn get_rebase_state_dir_path(&self) -> PathBuf

Get the path to the directory inside the .git directory which contains state used for the current rebase (if any).

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

Get the path to the working copy for this repository. If the repository is bare (has no working copy), returns None.

pub fn get_index(&self) -> Result<Index>

Get the index file for this repository.

pub fn get_readonly_config(&self) -> Result<impl ConfigRead>

Get the configuration object for the repository.

Warning: This object should only be used for read operations. Write operations should go to the config file under the .git/branchless directory.

pub fn get_config_path(&self) -> PathBuf

Get the file where git-branchless-specific Git configuration is stored.

pub fn get_dag_dir(&self) -> PathBuf

Get the directory where the DAG for the repository is stored.

pub fn get_man_dir(&self) -> PathBuf

Get the directory to store man-pages. Note that this is the man directory, and not a subsection thereof. git-branchless man-pages must go into the man/man1 directory to be found by man.

pub fn get_tempfile_dir(&self) -> PathBuf

Get a directory suitable for storing temporary files.

In particular, this directory is guaranteed to be on the same filesystem as the Git repository itself, so you can move files between them atomically. See https://github.com/arxanas/git-branchless/discussions/120.

pub fn get_db_conn(&self) -> Result<Connection>

Get the connection to the SQLite database for this repository.

pub fn resolve_reference(
    &self,
    reference: &Reference<'_>
) -> Result<ResolvedReferenceInfo>

Get a snapshot of information about a given reference.

pub fn get_head_info(&self) -> Result<ResolvedReferenceInfo>

Get the OID for the repository’s HEAD reference.

pub fn set_head(&self, oid: NonZeroOid) -> Result<()>

Set the HEAD reference directly to the provided oid. Does not touch the working copy.

pub fn detach_head(&self, head_info: &ResolvedReferenceInfo) -> Result<()>

Detach HEAD by making it point directly to its current OID, rather than to a branch. If HEAD is unborn, logs a warning.

pub fn is_rebase_underway(&self) -> Result<bool>

Detect if an interactive rebase has started but not completed.

Git will send us spurious post-rewrite events marked as amend during an interactive rebase, indicating that some of the commits have been rewritten as part of the rebase plan, but not all of them. This function attempts to detect when an interactive rebase is underway, and if the current post-rewrite event is spurious.

There are two practical issues for users as a result of this Git behavior:

• During an interactive rebase, we may see many “processing 1 rewritten commit” messages, and then a final “processing X rewritten commits” message once the rebase has concluded. This is potentially confusing for users, since the operation logically only rewrote the commits once, but we displayed the message multiple times.

• During an interactive rebase, we may warn about abandoned commits, when the next operation in the rebase plan fixes up the abandoned commit. This can happen even if no conflict occurred and the rebase completed successfully without any user intervention.

pub fn get_current_operation_type(&self) -> Option<&str>

Get the type current multi-step operation (such as rebase or cherry-pick) which is underway. Returns None if there is no such operation.

pub fn find_merge_base(
    &self,
    lhs: NonZeroOid,
    rhs: NonZeroOid
) -> Result<Option<NonZeroOid>>

Find the merge-base between two commits. Returns None if a merge-base could not be found.

pub fn get_patch_for_commit(
    &self,
    effects: &Effects,
    commit: &Commit<'_>
) -> Result<Option<Diff<'_>>>

Get the patch for a commit, i.e. the diff between that commit and its parent.

If the commit has more than one parent, returns None.

pub fn get_diff_between_trees(
    &self,
    effects: &Effects,
    old_tree: Option<&Tree<'_>>,
    new_tree: &Tree<'_>,
    num_context_lines: usize
) -> Result<Diff<'_>>

Get the diff between two trees. This is more performant than calling libgit2’s diff_tree_to_tree directly since it dehydrates commits before diffing them.

pub fn get_staged_paths(&self) -> Result<HashSet<PathBuf>>

Returns the set of paths currently staged to the repository’s index.

pub fn get_paths_touched_by_commit(
    &self,
    commit: &Commit<'_>
) -> Result<Option<HashSet<PathBuf>>>

Get the file paths which were added, removed, or changed by the given commit.

If the commit has no parents, returns all of the file paths in that commit’s tree.

If the commit has more than one parent, returns None.

pub fn get_patch_id(
    &self,
    effects: &Effects,
    commit: &Commit<'_>
) -> Result<Option<PatchId>>

Get the patch ID for this commit.

pub fn revparse_single_commit(&self, spec: &str) -> Result<Option<Commit<'_>>>

Attempt to parse the user-provided object descriptor.

pub fn get_all_references(&self) -> Result<Vec<Reference<'_>>>

Find all references in the repository.

pub fn has_changed_files(
    &self,
    effects: &Effects,
    git_run_info: &GitRunInfo
) -> Result<bool>

Check if the repository has staged or unstaged changes. Untracked files are not included. This operation may take a while.

pub fn get_status(
    &self,
    effects: &Effects,
    git_run_info: &GitRunInfo,
    index: &Index,
    head_info: &ResolvedReferenceInfo,
    event_tx_id: Option<EventTransactionId>
) -> Result<(WorkingCopySnapshot<'_>, Vec<StatusEntry>)>

Returns the current status of the repo index and working copy.

pub fn create_reference(
    &self,
    name: &ReferenceName,
    oid: NonZeroOid,
    force: bool,
    log_message: &str
) -> Result<Reference<'_>>

Create a new reference or update an existing one.

pub fn get_all_remote_names(&self) -> Result<Vec<String>>

Get a list of all remote names.

pub fn find_reference(
    &self,
    name: &ReferenceName
) -> Result<Option<Reference<'_>>>

Look up a reference with the given name. Returns None if not found.

pub fn get_all_local_branches(&self) -> Result<Vec<Branch<'_>>>

Get all local branches in the repository.

pub fn find_branch(
    &self,
    name: &str,
    branch_type: BranchType
) -> Result<Option<Branch<'_>>>

Look up the branch with the given name. Returns None if not found.

pub fn find_commit(&self, oid: NonZeroOid) -> Result<Option<Commit<'_>>>

Look up a commit with the given OID. Returns None if not found.

pub fn find_commit_or_fail(&self, oid: NonZeroOid) -> Result<Commit<'_>>

Like find_commit, but raises a generic error if the commit could not be found.

pub fn find_blob(&self, oid: NonZeroOid) -> Result<Option<Blob<'_>>>

Look up a blob with the given OID. Returns None if not found.

pub fn find_blob_or_fail(&self, oid: NonZeroOid) -> Result<Blob<'_>>

Like find_blob, but raises a generic error if the blob could not be found.

pub fn friendly_describe_commit_from_oid(
    &self,
    glyphs: &Glyphs,
    oid: NonZeroOid
) -> Result<StyledString>

Look up the commit with the given OID and render a friendly description of it, or render an error message if not found.

pub fn create_blob_from_path(&self, path: &Path) -> Result<Option<NonZeroOid>>

Read a file from disk and create a blob corresponding to its contents. If the file doesn’t exist on disk, returns None instead.

pub fn create_blob_from_contents(&self, contents: &[u8]) -> Result<NonZeroOid>

Create a blob corresponding to the provided byte slice.

pub fn create_commit(
    &self,
    update_ref: Option<&str>,
    author: &Signature<'_>,
    committer: &Signature<'_>,
    message: &str,
    tree: &Tree<'_>,
    parents: Vec<&Commit<'_>>
) -> Result<NonZeroOid>

Create a new commit.

pub fn cherry_pick_commit(
    &self,
    cherry_pick_commit: &Commit<'_>,
    our_commit: &Commit<'_>,
    mainline: u32
) -> Result<Index>

Cherry-pick a commit in memory and return the resulting index.

pub fn cherry_pick_fast<'repo>(
    &'repo self,
    patch_commit: &'repo Commit<'_>,
    target_commit: &'repo Commit<'_>,
    options: &CherryPickFastOptions
) -> Result<Tree<'repo>, CherryPickFastError>

Cherry-pick a commit in memory and return the resulting tree.

The libgit2 routines operate on entire Indexes, which contain one entry per file in the repository. When operating on a large repository, this is prohibitively slow, as it takes several seconds just to write the index to disk. To improve performance, we reduce the size of the involved indexes by filtering out any unchanged entries from the input trees, then call into libgit2, then add back the unchanged entries to the output tree.

pub fn find_tree(&self, oid: NonZeroOid) -> Result<Option<Tree<'_>>>

Look up the tree with the given OID. Returns None if not found.

pub fn find_tree_or_fail(&self, oid: NonZeroOid) -> Result<Tree<'_>>

Like find_tree, but raises a generic error if the commit could not be found.

pub fn write_index_to_tree(&self, index: &mut Index) -> Result<NonZeroOid>

Write the provided in-memory index as a tree into Git`s object database. There must be no merge conflicts in the index.

pub fn amend_fast(
    &self,
    parent_commit: &Commit<'_>,
    opts: &AmendFastOptions
) -> Result<Tree<'_>>

Amends the provided parent commit in memory and returns the resulting tree.

Only amends the files provided in the options, and only supports amending from either the working tree or the index, but not both.

See Repo::cherry_pick_fast for motivation for performing the operation in-memory.

Trait Implementations

impl Debug for Repo

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

Formats the value using the given formatter.

impl RepoExt for Repo

fn get_main_branch_reference(&self) -> Result<Reference<'_>>

Get the Reference for the main branch for the repository.

fn get_main_branch_oid(&self) -> Result<NonZeroOid>

Get the OID corresponding to the main branch.

fn get_branch_oid_to_names(
    &self
) -> Result<HashMap<NonZeroOid, HashSet<ReferenceName>>>

Get a mapping from OID to the names of branches which point to that OID.

fn get_references_snapshot(&self) -> Result<RepoReferencesSnapshot>

Get the positions of references in the repository.