Struct GitVcs 

pub struct GitVcs { /* private fields */ }

Implementations

impl GitVcs

pub fn open(root: &Path) -> Result<Self, VcsError>

pub fn open_with_settings( root: &Path, settings: &DiffSettings, ) -> Result<Self, VcsError>

pub fn open_jj_store( git_dir: &Path, root: &Path, settings: &DiffSettings, ) -> Result<Self, VcsError>

The bare git store of a jj repo with no .git of its own, its worktree set to root.

Trait Implementations

impl Vcs for GitVcs

fn has_index(&self) -> bool

Whether this backend has a staging area. jj has none, so its whole working copy reads as StatusModel::staged.

fn native_git_checkout(&self) -> bool

Whether a raw git/forge CLI command may check out a branch. False for jj, whose operation log would miss the write, so we go through Vcs::checkout there.

fn git_dir(&self) -> Result<PathBuf, VcsError>

Resolved metadata directory. In a linked worktree this is the gitdir the .git file points at.

fn head(&self) -> Result<HeadInfo, VcsError>

fn status(&self) -> Result<StatusModel, VcsError>

fn working_tree_diff(&self) -> Result<DiffModel, VcsError>

HEAD vs index + worktree, untracked files included.

fn tree_to_workdir_diff(&self, base_oid: &str) -> Result<DiffModel, VcsError>

Vcs::working_tree_diff taken from base_oid.

fn commit_diff(&self, oid: &str) -> Result<DiffModel, VcsError>

Changes a single commit introduced over its first parent.

fn tree_diff( &self, base_oid: &str, newest_oid: &str, ) -> Result<DiffModel, VcsError>

git diff <base> <newest>; with base a merge base this is a three-dot diff.

fn merge_base(&self, a: &str, b: &str) -> Result<String, VcsError>

fn resolve(&self, revision: &str) -> Result<String, VcsError>

Resolve a revision (oid, ref name, remote ref) to a full commit oid.

fn range_diff( &self, oldest_oid: &str, newest_oid: &str, ) -> Result<DiffModel, VcsError>

git diff <oldest>^..<newest>. A root oldest diffs from the empty tree.

fn log( &self, limit: usize, all_branches: bool, ) -> Result<Vec<LogEntry>, VcsError>

History from HEAD, or from every branch, remote branch and tag with all_branches, newest first and each commit before its parents.

fn default_branch(&self, remote: &str) -> Result<Option<String>, VcsError>

The branch a pull request merges into by default, if the repo says.

fn commits_between( &self, base: &str, head: &str, ) -> Result<Vec<LogEntry>, VcsError>

Commits reachable from head but not base, newest first.

fn unpushed(&self, limit: usize) -> Result<Option<Vec<LogEntry>>, VcsError>

Commits on HEAD that no remote-tracking branch contains, newest first, at most limit. None when the repo has no remote-tracking refs. We ask the remotes since a configured upstream may be a local branch or a stale ref.

fn blame(&self, rel: &Path) -> Result<Vec<BlameSpan>, VcsError>

Last commit to touch each line of rel as the worktree has it, in line order. Uncommitted lines come back as spans owned by no commit.

fn read_at(&self, rev: &str, path: &str) -> Result<Option<String>, VcsError>

One file’s content in rev’s tree, None when the tree lacks it.

fn read_blob(&self, oid: &str) -> Result<Option<Vec<u8>>, VcsError>

A blob’s raw bytes by its hex id (a crate::model::BlobIds side), None when the object store has no such blob.

fn tracked_files(&self) -> Result<Vec<PathBuf>, VcsError>

Every tracked file, repo-relative and sorted. This is the index, so a staged new file is tracked and an untracked one is not.

fn attr(&self, rel: &Path, name: &str) -> bool

Whether the repo’s git attributes set name to true for rel. Unreadable attribute files read as unset.

fn branches(&self) -> Result<Vec<BranchInfo>, VcsError>

Local branches, their divergence left unresolved.

fn divergence(&self, branch: &str) -> Result<Option<(usize, usize)>, VcsError>

(ahead, behind) against the upstream, None when branch tracks nothing.

fn all_branches(&self) -> Result<Vec<String>, VcsError>

Local and remote-tracking branch names.

fn stage(&self, rel: &Path) -> Result<(), VcsError>

Stage a whole file (worktree deletions become staged deletions).

fn stage_hunk(&self, rel: &Path, hunk: &HunkId) -> Result<(), VcsError>

Stage one hunk out of the unstaged (or untracked) changes of a file.

fn stage_everything(&self) -> Result<(), VcsError>

Stage every change in the worktree, deletions and untracked files included.

fn unstage_everything(&self) -> Result<(), VcsError>

Reset the whole index back to HEAD, keeping the worktree.

fn unstage(&self, rel: &Path) -> Result<(), VcsError>

Reset a file’s index entry back to HEAD, keeping the worktree.

fn unstage_hunk(&self, rel: &Path, hunk: &HunkId) -> Result<(), VcsError>

Remove one staged hunk from the index, keeping the worktree.

fn discard(&self, rel: &Path) -> Result<(), VcsError>

Throw away worktree changes only; an untracked file is deleted. Refused while the file has staged changes (unstage first).

fn commit(&self, message: &str) -> Result<String, VcsError>

Commit the index; returns the new commit id.

fn head_message(&self) -> Result<String, VcsError>

Full message of the HEAD commit, for amend/reword editor templates.

fn commit_message(&self, oid: &str) -> Result<String, VcsError>

Full message of the commit oid.

fn amend( &self, message: Option<&str>, use_index: bool, ) -> Result<String, VcsError>

Amend HEAD, returning the new commit id. message None reuses HEAD’s message (extend); Some rewords it. use_index true folds the staged index into the new tree; false keeps HEAD’s tree (a pure reword).

fn create_branch(&self, name: &str, checkout: bool) -> Result<(), VcsError>

fn delete_branch(&self, name: &str) -> Result<(), VcsError>

Refused for the currently checked-out branch.

fn checkout(&self, name: &str) -> Result<(), VcsError>

fn stash_push(&self, message: Option<&str>) -> Result<(), VcsError>

Stash tracked changes, leaving untracked files in place like git stash. message None lets the backend label it.

fn stash_pop(&self) -> Result<(), VcsError>

Restore the most recent stash and drop it. Refused when there is no stash or the pop would conflict.

fn network_argv(&self, op: NetworkOp) -> Result<Vec<String>, VcsError>

Argv for a network op, run in Vcs::workdir so the backend’s own CLI handles credentials. jj pushes bookmarks with jj git push and pulls with jj git fetch, then Vcs::rebase_onto_remote.

fn workdir(&self) -> Result<PathBuf, VcsError>

fn remote_url(&self, name: &str) -> Result<Option<String>, VcsError>

fn remotes(&self) -> Result<Vec<String>, VcsError>

fn set_diff_algorithm(&self, algorithm: DiffAlgorithm, indent_heuristic: bool)

Set the line-diff algorithm for every later diff of this instance.

fn read_jj_view(&self, _log_limit: usize) -> Result<Option<JjView>, VcsError>

jj’s view, covering log_limit commits of history; None outside a jj repo. It costs two jj runs, so callers ask from a worker, and this handle adopts it.

fn adopt_jj_view(&self, _view: JjView)

Take a view another handle read, with no subprocess.

fn commit_paths( &self, _message: &str, _paths: &[String], ) -> Result<String, VcsError>

Commit only paths (files or folders) of the working copy, which jj can do with no index; returns the new commit id.

fn change(&self, _op: &ChangeOp) -> Result<(), VcsError>

A jj change verb; git has none.

fn pull_target(&self) -> Result<Option<PullTarget>, VcsError>

What a jj pull fetches and rebases onto, read fresh; None outside jj or with no local bookmark under @.

fn rebase_onto_remote( &self, _bookmark: &str, _remote: &str, ) -> Result<PullOutcome, VcsError>

After a fetch, rebase @’s branch onto bookmark@remote when that moved.