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 read_jj_view(&self, log_limit: usize) -> Result<Option<JjView>, VcsError>

Change ids cover twice log_limit, since jj and git order a busy history differently.

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 resolve(&self, revision: &str) -> Result<String, VcsError>

Git syntax (main~2, refs, oids, HEAD as @-) resolves through git, since a colocated repo’s git refs are current where jj’s import of them may lag. With no .git the store’s refs are stale or absent, so jj’s bookmarks name the commit there, and git applies the ancestry suffix. What git cannot read (trunk(), change ids) is a jj revset; a git suffix never goes to jj, which reads ~ as a set difference.

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

A repo with no .git lists jj’s local bookmarks; the one @ sits on or under counts as checked out.

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

A repo with no .git measures a bookmark against its first remote namesake.

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

origin wins when the bookmark tracks several remotes.

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 network_argv(&self, op: NetworkOp) -> Result<Vec<String>, VcsError>

A push sends what JjVcs::push_selection picks, and jj tracks the remote bookmark it makes. A pull is the fetch alone; Vcs::rebase_onto_remote follows it.

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 adopt_jj_view(&self, view: JjView)

Take a view another handle read, with no subprocess.

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 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 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 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 rebase_onto_remote( &self, bookmark: &str, remote: &str, ) -> Result<PullOutcome, VcsError>

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

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

Full message of the commit oid.

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 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.