Struct JjVcs 

pub struct JjVcs { /* private fields */ }

Implementations

impl JjVcs

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

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

Trait Implementations

impl Vcs for JjVcs

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

One diff pass of @- vs the working copy. jj marks a new file intent-to-add in the index, so git’s three lists would count it twice.

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

Messages go as --message=<text>: clap reads a separate value that starts with - as a flag.

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

None squashes with -u, since a bare squash opens an editor when both sides are described. Some without use_index rewords @- alone.

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

Bookmarks @; checkout is moot since @ is already checked out.

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

exact:, since jj reads a bare name as a glob.

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

jj new <rev> works on top of the branch and keeps the change left behind; jj edit would rewrite the tip in place.

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 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 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 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 log(&self, limit: usize) -> Result<Vec<LogEntry>, VcsError>

History from HEAD, newest first.

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_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 stage_hunk(&self, _rel: &Path, _hunk: &HunkId) -> Result<(), VcsError>

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

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 head_message(&self) -> Result<String, VcsError>

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

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 rejects push and pull, since they would move git’s refs behind its back.

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.