Trait GitApi 

pub trait GitApi: Send + Sync {
    // Required methods
    fn run<'life0, 'life1, 'async_trait>(
        &'life0 self,
        args: &'life1 [String],
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn run_raw<'life0, 'life1, 'async_trait>(
        &'life0 self,
        args: &'life1 [String],
    ) -> Pin<Box<dyn Future<Output = Result<ProcessResult<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn version<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn capabilities<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<GitCapabilities>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn status<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<StatusEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn status_text<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn status_tracked<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<StatusEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn branch_status<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<BranchStatus>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn conflicted_files<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<PathBuf>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn current_branch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn branches<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Branch>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn log<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        revspec: &'life2 RevSpec,
        max: usize,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Commit>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn log_paths<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        revspec: &'life2 RevSpec,
        max: usize,
        paths: &'life3 [String],
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Commit>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn rev_parse<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        rev: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn rev_parse_short<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        rev: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn init<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn add<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        paths: &'life2 [PathBuf],
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn commit<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        message: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn create_branch<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        name: &'life2 RefName,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn checkout<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        target: &'life2 CheckoutTarget,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn checkout_detach<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        commit: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn commit_paths<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: CommitPaths,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn last_commit_message<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_unborn<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn diff_is_empty<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn common_dir<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<PathBuf>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn git_dir<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<PathBuf>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn resolve_commit<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        rev: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn remote_head_branch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn branch_exists<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        name: &'life2 RefName,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn remote_branch_exists<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        name: &'life2 RefName,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn remote_url<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        remote: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn remote_list<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Remote>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn upstream<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn remote_branches<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        remote: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn is_merged<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: MergeCheck,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn set_upstream<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        branch: &'life2 RefName,
        upstream: &'life3 RefName,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn delete_branch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: BranchDelete,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn rename_branch<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        old: &'life2 RefName,
        new: &'life3 RefName,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn rev_list_count<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        range: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn diff_range_is_empty<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        range: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn diff_stat<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        range: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<DiffStat>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn diff_text<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: DiffSpec,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn diff<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: DiffSpec,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<FileDiff>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn staged_is_empty<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_rebase_in_progress<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_merge_in_progress<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_am_in_progress<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_cherry_pick_in_progress<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_revert_in_progress<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn is_bisect_in_progress<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn fetch<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn fetch_with_progress<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        progress: &'a mut ProgressCallback<'a>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn fetch_from<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        remote: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn fetch_branch<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        branch: &'life2 RefName,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn push<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: GitPush,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn push_with_progress<'a, 'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: GitPush,
        progress: &'a mut ProgressCallback<'a>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn merge_squash<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        branch: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn merge_commit<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: MergeCommit,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn merge_no_commit<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: MergeNoCommit,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn merge_abort<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn merge_continue<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn reset_merge<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn reset_hard<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        rev: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn rebase<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        onto: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn rebase_abort<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn am_abort<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn am_continue<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn rebase_continue<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn stash_push<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: StashPush,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn stash_pop<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn stash_list<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<StashEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn stash_apply<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        index: usize,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn stash_drop<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        index: usize,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn clean<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: Clean,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<CleanEntry>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn worktree_list<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Worktree>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn worktree_add<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: WorktreeAdd,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn worktree_remove<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: WorktreeRemove,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn worktree_move<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        from: &'life2 Path,
        to: &'life3 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn worktree_prune<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn sparse_checkout_set<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: SparseCheckoutSet,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn sparse_checkout_list<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn sparse_checkout_disable<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn submodule_list<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Submodule>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn submodule_status<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<SubmoduleStatus>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn submodule_update<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: SubmoduleUpdate,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn clone_repo<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        url: &'life1 str,
        dest: &'life2 Path,
        spec: CloneSpec,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn clone_repo_with_progress<'a, 'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        url: &'life1 str,
        dest: &'life2 Path,
        spec: CloneSpec,
        progress: &'a mut ProgressCallback<'a>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'a: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn tag_create<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        name: &'life2 RefName,
        rev: Option<RevSpec>,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn tag_create_annotated<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        spec: AnnotatedTag,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn tag_list<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn tag_delete<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        name: &'life2 RefName,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn show_file<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        rev: &'life2 RevSpec,
        path: &'life3 str,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn config_get<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        key: &'life2 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn config_set<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        key: &'life2 str,
        value: &'life3 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn remote_add<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        name: &'life2 str,
        url: &'life3 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn remote_set_url<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        name: &'life2 str,
        url: &'life3 str,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn blame<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        path: &'life2 str,
        rev: Option<RevSpec>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<BlameLine>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn cherry_pick<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        rev: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn revert<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        rev: &'life2 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn rebase_skip<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn cherry_pick_abort<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn cherry_pick_continue<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn revert_abort<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn revert_continue<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn bisect_reset<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn bisect_start<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        bad: &'life2 RevSpec,
        good: &'life3 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait;
    fn bisect_good<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn bisect_bad<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn bisect_skip<'life0, 'life1, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
    ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;

    // Provided methods
    fn diff_text_between<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        _dir: &'life1 Path,
        _from: &'life2 RevSpec,
        _to: &'life3 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait { ... }
    fn diff_between<'life0, 'life1, 'life2, 'life3, 'async_trait>(
        &'life0 self,
        dir: &'life1 Path,
        from: &'life2 RevSpec,
        to: &'life3 RevSpec,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<FileDiff>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait,
             'life3: 'async_trait { ... }
}

The Git operations this crate exposes — the interface consumers code against and mock in tests.

Injection safety: reference names and revision expressions are taken as the validated RefName / RevSpec newtypes (directly or inside an options struct), so a flag-like or malformed value is rejected at construction, before it can reach an argv slot. The remaining caller-supplied bare positionals that are not refs/revisions — remote names and URLs — keep an internal reject_flag_like guard: a value that is empty or begins with - is rejected with an ErrorReason::Spawn before spawning. Flag-value slots (-m <msg>, --branch <b>), filesystem path arguments (---separated pathspecs, plus worktree paths and clone destinations — typed Path, caller-trusted), and the run/run_raw escape hatches are not guarded. The one context-dependent special value, git’s - “previous branch”, is CheckoutTarget::Previous.

Required Methods

fn run<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run git <args> in the process’s current directory, returning trimmed stdout (throws on a non-zero exit). A raw escape hatch for unmodelled commands — you supply the whole argv, so target a specific repo with -C <dir> in the args. This method on the client is the process-cwd escape hatch; the at(dir) bound view’s run is instead bound to dir (it forwards to Git::run_in, so git.at(dir).run(…) runs in the bound repo). Use git.at(dir).run(…) (or Git::run_in) for the bound repo; use this for the process cwd (T-035, was M15).

fn run_raw<'life0, 'life1, 'async_trait>( &'life0 self, args: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<ProcessResult<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Like GitApi::run but never errors on a non-zero exit — returns the captured ProcessResult.

fn version<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Installed Git version (git --version).

fn capabilities<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<GitCapabilities>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

The installed binary’s parsed version, as GitCapabilities (git --version). A value type — probe once and keep it; an unrecognisable version string is an ErrorReason::Parse.

fn status<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<StatusEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Working-tree status (git status --porcelain=v1 -z).

fn status_text<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Raw porcelain status text (git status --porcelain=v1) — the unparsed counterpart of status, mirroring vcs_jj status_text.

fn status_tracked<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<StatusEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Like status but ignoring untracked files (git status --porcelain=v1 -z --untracked-files=no) — “is the tracked tree dirty”, staged or not.

fn branch_status<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<BranchStatus>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

A combined branch + working-tree snapshot in one spawn (git status --porcelain=v2 --branch -z): HEAD, branch, upstream, ahead/behind, and change counts — the data a prompt/status-bar needs without N round-trips. See BranchStatus.

fn conflicted_files<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<PathBuf>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Paths with unresolved merge conflicts, repo-relative with / separators (git diff --name-only --diff-filter=U -z). Empty when there are none. Returns PathBufs built from the raw -z bytes, so a non-UTF-8 conflicted path survives losslessly.

fn current_branch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Current branch name, or None on a detached HEAD (git symbolic-ref --quiet --short HEAD). Returns the branch name for a normal branch and for an unborn branch (a fresh init/clone before the first commit); None only when HEAD is detached. Mirrors JjApi::current_bookmark’s Option shape, so cross-backend code treats “no named branch/bookmark” the same way on both wrappers.

fn branches<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<Branch>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Local branches, current one flagged (git branch).

fn log<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, revspec: &'life2 RevSpec, max: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<Commit>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Up to max commits reachable from revspec, newest first (git log <revspec> -- ). Pass "HEAD" for the current branch’s history, or a range like "main..HEAD" / "origin/main..HEAD" to scope it. Mirrors JjApi::log’s revset argument, so cross-backend code uses one signature. The revspec is a validated RevSpec, so it can never be parsed as a flag. The argv ends in a literal -- (end of revisions, no pathspecs) so a revspec that happens to match an existing file’s name (e.g. Makefile) resolves as a revision or fails outright, rather than silently falling back to git’s pathspec DWIM and returning HEAD’s history filtered by that path (C2/M13) — the same convention already used by log_paths, diff_text, diff_range_is_empty, diff_stat, and checkout.

fn log_paths<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, revspec: &'life2 RevSpec, max: usize, paths: &'life3 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Commit>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Like log, but scoped to commits that touched paths (git --literal-pathspecs log <revspec> -n <max> -- <paths>) — e.g. “who changed this module”. --literal-pathspecs matches a path containing */?/[] literally rather than as pathspec glob magic (R-02); the -- separator keeps a path from being read as a flag (same convention as add/commit_paths). An empty paths is refused before spawning: silently falling back to log’s unrestricted history would defeat the “scoped to these paths” contract. Mirrors JjApi::log_paths, which takes filesets instead of pathspecs.

Unlike add/commit_paths, git’s log has no --pathspec-from-file support, so a paths set that would risk exceeding the OS argv limit is instead split into multiple git log calls, each within budget; the per-call results are merged (deduplicated by hash — a commit can touch paths spread across more than one chunk) and restored to git’s own commit order using a separate, pathless git log <revspec> --format=%H oracle call (T-052/R-03): pathspec filtering only drops non-matching commits, it never reorders the ones that remain, so the oracle’s order — over the same revspec, unrestricted by paths — gives the exact relative order a single, hypothetical unchunked call would have produced. Unlike sorting by a parsed date field, this needs no assumption about author-vs-committer timestamps or same-second ties (git log dates have no sub-second precision). A paths set that fits in one call is unaffected — same single invocation, same order, as before.

Before any of that, revspec (which may be symbolic, e.g. HEAD, or a range, e.g. main..feature) is resolved exactly once via git rev-parse into a fixed set of commit ids that every chunk call and the oracle call then reuse verbatim (T-052/R-04): without this, each of those several independent invocations would re-resolve the same symbolic text on its own, so a concurrent commit/reset/ref-move landing between any two of them could make them see different repository snapshots, silently omitting a newer matching commit, including one no longer reachable, or interleaving two different histories into the merged result. This resolution only happens on the chunked path (more than one invocation); the single-call fast path is unaffected. Also before any of that, every individual path is checked against the argv budget on its own (T-052/R-05): git log has no NUL-safe transport to fall back to the way add/commit_paths do, so a single path that by itself cannot fit in argv is rejected up front with a clear error rather than silently forwarded as an over-budget singleton chunk.

fn rev_parse<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Resolve a revision to a full hash (git rev-parse --verify <rev>). --verify requires rev to name exactly one object, so a non-revision (e.g. a filename) errors instead of being echoed back as a fake id.

fn rev_parse_short<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Resolve a revision to its abbreviated hash (git rev-parse --short <rev>) — e.g. to label a detached HEAD.

fn init<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Initialise a repository (git init).

fn add<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, paths: &'life2 [PathBuf], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Stage paths (git --literal-pathspecs add -- <paths>) — --literal-pathspecs applies regardless of path-set size, so a path containing */?/[] always matches literally rather than as pathspec glob magic (R-01). A path set whose combined length would risk exceeding the OS command-line limit (ARGV_PATHSPEC_BUDGET; Windows’ CreateProcess caps out around 32,767 characters) instead goes over stdin via --pathspec-from-file=- --pathspec-file-nul — the paths never touch argv at all in that case, so there is no upper bound left to exceed (T-052).

fn commit<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, message: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Commit staged changes (git commit -m).

fn create_branch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a branch without switching to it (git branch <name>).

fn checkout<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, target: &'life2 CheckoutTarget, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Switch to a branch/revision, or the previous branch (git checkout <target>); see CheckoutTarget.

fn checkout_detach<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, commit: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Check out a commit as a detached HEAD (git checkout --detach <commit>).

fn commit_paths<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: CommitPaths, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Commit exactly the spec’s paths’ working-tree content, ignoring the index (git --literal-pathspecs commit [--amend] -m <message> --only -- <paths>); see CommitPaths. --literal-pathspecs applies regardless of path-set size, so a glob-magic character (*/?/[]) in a path is matched literally rather than expanded — otherwise commit_paths’s “exactly these paths” contract could be violated (R-01). Like add, a path set that would risk exceeding the OS argv limit is instead routed over stdin (--pathspec-from-file=- --pathspec-file-nul) — always as a single git commit invocation either way, so the one-atomic-commit contract is unaffected by the path set’s size (T-052).

fn last_commit_message<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The last commit’s full message (git log -1 --format=%B) — e.g. to pre-fill an amend.

fn is_unborn<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether HEAD is unborn — a fresh repo with no commits yet (git rev-parse --verify -q HEAD, exit-code mapped).

fn diff_is_empty<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether the working tree has no unstaged modifications to tracked files (git diff --quiet). Untracked files are not counted — this is not a full “is the working tree clean?” check; use status for that.

fn common_dir<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<PathBuf>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The repository’s common git directory (rev-parse --git-common-dir) — stable across linked worktrees.

fn git_dir<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<PathBuf>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

This worktree’s git directory (rev-parse --git-dir).

fn resolve_commit<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Resolve a revision to a commit hash, peeling tags (rev-parse --verify <rev>^{commit}).

fn remote_head_branch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The remote’s default branch from symbolic-ref refs/remotes/origin/HEAD (short name only); None when origin/HEAD is unset.

fn branch_exists<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Whether a local branch exists (show-ref --verify --quiet refs/heads/<name>).

fn remote_branch_exists<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Whether origin has name, without fetching (ls-remote origin refs/heads/<name> — the fully-qualified ref, so foo can’t tail-match bar/foo). Runs with GIT_TERMINAL_PROMPT=0 and a 10s timeout so a missing credential or a flaky network can’t hang the call.

fn remote_url<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, remote: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

A remote’s URL (remote get-url <remote>).

fn remote_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<Remote>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Configured remotes from remote -v, coalesced to one typed row per name with its fetch URL.

fn upstream<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The current attached branch’s upstream, e.g. Some("origin/main") (rev-parse --abbrev-ref --symbolic-full-name @{u}); None when unset. A detached HEAD or a directory outside a repository is an error.

fn remote_branches<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, remote: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Branch names on remote, without fetching (ls-remote --heads <remote>).

fn is_merged<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: MergeCheck, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether the MergeCheck’s branch is fully merged into its base (branch --merged <base>). Build it as MergeCheck::branch(RefName::new("feature")?).into_base(RevSpec::new("main")?) so the two refs can’t be transposed (a swap would invert the answer).

fn set_upstream<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 RefName, upstream: &'life3 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Set branch’s upstream to upstream (e.g. origin/main) (branch --set-upstream-to=<upstream> <branch>).

fn delete_branch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: BranchDelete, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a local branch (branch -d, or -D when forced); see BranchDelete.

fn rename_branch<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, old: &'life2 RefName, new: &'life3 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Rename a local branch (branch -m <old> <new>).

fn rev_list_count<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, range: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Count commits in a range (rev-list --count <range>).

fn diff_range_is_empty<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, range: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Whether a diff range is empty (diff --quiet <range>).

fn diff_stat<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, range: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<DiffStat>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Aggregate change stats for a range (diff --shortstat <range>). Named to match vcs_jj::JjApi::diff_stat.

fn diff_text<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: DiffSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Raw git-format unified diff text for spec (diff <spec> --no-color --no-ext-diff -M) — stable machine output, returned verbatim (a trailing blank context line is preserved, so the last hunk stays in sync with its @@ line count for a re-parse/re-apply).

DiffSpec::Rev is a direct passthrough: the string becomes git’s single positional diff argument verbatim (git diff <rev>) — this crate doesn’t parse, classify, or rewrite it beyond the reject_flag_like guard against a leading -. Whatever git diff <rev> would do at the shell for that exact string is what Rev(rev) does here.

One consequence follows from plain git diff’s own rules: a single revision (no ../...) diffs the working tree against that revision, not the revision against its parent — when HEAD exists, Rev("HEAD".into()) behaves exactly like DiffSpec::WorkingTree, and Rev("abc".into()) includes any uncommitted changes on top of abc. On an unborn repository the two differ: DiffSpec::WorkingTree deliberately diffs against the empty tree, while Rev("HEAD".into()) passes the unresolved name through and errors. To compare two commits with the working tree excluded, put a range in the Rev string instead ("abc..def" / "abc^..abc") — git’s two-dot/three-dot forms diff commit-to-commit. None of this is vcs-git logic; it’s inherited by passing the string straight to git, except for WorkingTree’s documented unborn fallback.

How DiffSpec is interpreted here is stable behavior, not an implementation detail. Changing it would be a semver-breaking change.

fn diff<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: DiffSpec, ) -> Pin<Box<dyn Future<Output = Result<Vec<FileDiff>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Parsed per-file unified diff for spec, layered on diff_text.

fn staged_is_empty<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether the index has no staged changes (diff --cached --quiet).

fn is_rebase_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a rebase is in progress (a rebase-merge dir, or a rebase-apply dir not left by git am, exists under the git dir).

fn is_merge_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a merge is in progress (a MERGE_HEAD exists under the git dir).

fn is_am_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a git am (mailbox apply) is in progress (rebase-apply/applying). Distinct from a rebase, which shares the rebase-apply dir but without the applying marker — aborting an am needs am --abort, not rebase --abort.

fn is_cherry_pick_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a cherry-pick is in progress (CHERRY_PICK_HEAD under the git dir). A cherry-pick conflict writes CHERRY_PICK_HEAD, not MERGE_HEAD, so this is distinct from a merge and is aborted/continued with cherry-pick --abort / --continue, not merge --abort.

fn is_revert_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a revert is in progress (REVERT_HEAD under the git dir). Like a cherry-pick, a revert conflict writes its own head file, not MERGE_HEAD; it is driven with revert --abort / --continue.

fn is_bisect_in_progress<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Whether a git bisect session is in progress (BISECT_LOG under the git dir). Ended with bisect reset (there is no --continue).

fn fetch<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch from the default remote (fetch --quiet), with GIT_TERMINAL_PROMPT=0. Transient (network) failures are retried (3 attempts, 500 ms backoff).

fn fetch_with_progress<'a, 'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, progress: &'a mut ProgressCallback<'a>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch from the default remote while reporting process lifecycle and stdout/stderr lines. This observes one process attempt (no automatic replay), so ProcessEvent::Exited is always terminal.

fn fetch_from<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, remote: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch from a named remote (fetch --quiet <remote>), with GIT_TERMINAL_PROMPT=0. Transient failures are retried like fetch.

fn fetch_branch<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Fetch a single branch from origin into its remote-tracking ref (fetch --quiet origin refs/heads/<b>:refs/remotes/origin/<b>), with GIT_TERMINAL_PROMPT=0. Transient failures are retried (3×, 500 ms).

fn push<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: GitPush, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Push to a remote (push [-u] <remote> <refspec>); see GitPush.

fn push_with_progress<'a, 'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: GitPush, progress: &'a mut ProgressCallback<'a>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Push while reporting process lifecycle and stdout/stderr lines. Uses git’s --progress flag so progress is emitted even though output is piped.

fn merge_squash<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, branch: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Stage a branch’s changes without committing (merge --squash <branch>).

fn merge_commit<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: MergeCommit, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Merge a branch (merge [--no-ff] [-m <msg> | --no-edit] <branch>); with no message it takes the default merge message non-interactively (--no-edit). See MergeCommit.

fn merge_no_commit<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: MergeNoCommit, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Merge a branch but stop before committing, so the result can be inspected (merge --no-commit [--squash | --no-ff] <branch>). With no_ff (and not squash) git records MERGE_HEAD, so the in-progress merge is abortable via merge_abort — the dry-run pattern. With squash, git stages the squashed result but records no MERGE_HEAD, so it is not an abortable merge: undo it with reset_merge / reset_hard, not merge_abort. See MergeNoCommit.

fn merge_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress merge (merge --abort).

fn merge_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Finish a merge after resolving conflicts (commit --no-edit).

fn reset_merge<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Undo an in-progress (or just-staged) merge: reset --merge resets the index and the merge-touched working-tree files back to HEAD and drops MERGE_HEAD, discarding the merge’s changes while keeping unrelated unstaged edits. Use it after merge_squash / merge_no_commit(squash), where there is no MERGE_HEAD for merge_abort to act on.

fn reset_hard<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Hard-reset the working tree to a revision (reset --hard <rev>).

fn rebase<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, onto: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Rebase the current branch onto onto (rebase <onto>); the editor is suppressed (GIT_EDITOR=true) so it never hangs a headless caller.

fn rebase_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress rebase (rebase --abort).

fn am_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress git am (am --abort), restoring the pre-am HEAD.

fn am_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a git am after resolving conflicts (am --continue); the editor is suppressed (GIT_EDITOR=true) so the patch’s message-confirm never hangs a headless caller. On a multi-patch mailbox it can stop again on the next patch’s conflict (exit non-zero) — a conflict, not a hard error, like the other sequencer --continues.

fn rebase_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a rebase after resolving conflicts (rebase --continue); the editor is suppressed (GIT_EDITOR=true) so the message-confirm never hangs.

fn stash_push<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: StashPush, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Stash the working tree (stash push, --include-untracked when asked) — e.g. to save state before a copy-on-write restore. See StashPush.

fn stash_pop<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Restore the most recent stash and drop it (stash pop).

fn stash_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<StashEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The stash list, most-recent first (stash@{0}), machine-parsed via stash list -z --format=%gd%x1f%H%x1f%gs into typed StashEntry records — a read, unlike stash_push/ stash_pop.

fn stash_apply<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, index: usize, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Apply the stash at index (stash@{<index>}, StashEntry::index) without dropping it (stash apply stash@{<index>}) — unlike stash_pop, the stash entry survives a successful apply, so it can be applied again or dropped explicitly with stash_drop.

fn stash_drop<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, index: usize, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Drop the stash at index (stash@{<index>}, StashEntry::index) without applying it (stash drop stash@{<index>}) — discards the stash entry; the working tree is untouched.

fn clean<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: Clean, ) -> Pin<Box<dyn Future<Output = Result<Vec<CleanEntry>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove untracked files/directories from the working tree (git clean), per Clean. Destructive unless Clean::dry_run is set — with neither dry_run nor Clean::force picked, this refuses before spawning git at all (an Error::spawn carrying std::io::ErrorKind::InvalidInput), so deletion is never the default and never implied by omission (see the Clean type docs). Returns the typed list of paths removed (forced) or that would be removed (dry run) — see CleanEntry.

fn worktree_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<Worktree>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List worktrees (worktree list --porcelain).

fn worktree_add<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: WorktreeAdd, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Add a worktree (worktree add [-b <branch>] <path> [<commitish>]).

fn worktree_remove<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: WorktreeRemove, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a worktree (worktree remove [--force] <path>); see WorktreeRemove.

fn worktree_move<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, from: &'life2 Path, to: &'life3 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Move a worktree (worktree move <from> <to>).

fn worktree_prune<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Prune stale worktree admin entries (worktree prune).

fn sparse_checkout_set<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: SparseCheckoutSet, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Set the sparse-checkout directories or patterns (sparse-checkout set --cone|--no-cone -- <values>); see SparseCheckoutSet. Cone mode is the default and is recommended for directory-oriented worktrees. Values are validated before spawning and pinned after --, so a caller cannot turn one into a git option.

fn sparse_checkout_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List the currently configured sparse-checkout directories or patterns (sparse-checkout list) in git’s emitted order. Pattern text is kept verbatim apart from the line terminator, including meaningful spaces.

fn sparse_checkout_disable<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Disable sparse checkout and repopulate the working tree (sparse-checkout disable).

fn submodule_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<Submodule>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The submodules declared in <dir>/.gitmodules, parsed from the machine-unambiguous git config --file .gitmodules --list -z source (not a hand-rolled scan of the ini-style file). dir must be the repository’s top-level working directory, where .gitmodules lives.

A repository with no submodules has no .gitmodules file; that is reported as an empty list, not an error — the absent file is probed before spawning, so the common no-submodule case does not even run git. See Submodule. This is a pure read: git config --file only parses the file, so it neither clones, fetches, nor executes any submodule’s config — the safe way to inspect what a (possibly untrusted) .gitmodules declares before deciding whether to submodule_update.

fn submodule_status<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<SubmoduleStatus>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

The sync state of the superproject’s submodules (git submodule status): the checked-out commit, path, and a typed SubmoduleState from the line’s leading -/+/U/space prefix. See SubmoduleStatus.

A read: it inspects the recorded gitlink and each initialized submodule’s HEAD (briefly running git inside each to compute the trailing describe), but performs no checkout, fetch, or working-tree materialization.

fn submodule_update<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: SubmoduleUpdate, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check out the submodules to the commits the superproject records (git submodule update [--init] [--recursive] [--depth <n>] [-- <paths>]); see SubmoduleUpdate.

Security boundary — executes a nested repository’s content. Unlike submodule_list / submodule_status, this fetches from the URLs .gitmodules records and materializes each submodule’s working tree, so it runs that nested repo’s checkout-time config (filter/smudge drivers) and network transport. On a hardened client the hardened environment is inherited by the git subprocesses this spawns, but the residual repo-local-config vectors apply per nested repo too — for a fully untrusted superproject, run this only inside an OS-level sandbox, or vet .gitmodules via submodule_list first. Terminal prompts are pinned off (GIT_TERMINAL_PROMPT=0) so a submodule needing credentials fails fast rather than hanging. See the submodules section of the security guide.

Positional submodule paths are flag-guarded and passed after a -- terminator, so a caller-supplied path can never be parsed as an option.

fn clone_repo<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, url: &'life1 str, dest: &'life2 Path, spec: CloneSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Clone url into dest (git clone <url> <dest> + CloneSpec flags). Runs without a working directory — pass an absolute dest.

fn clone_repo_with_progress<'a, 'life0, 'life1, 'life2, 'async_trait>( &'life0 self, url: &'life1 str, dest: &'life2 Path, spec: CloneSpec, progress: &'a mut ProgressCallback<'a>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'a: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Clone while reporting process lifecycle and stdout/stderr lines. Uses git’s --progress flag and preserves clone_repo’s failed-destination cleanup contract.

fn tag_create<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, rev: Option<RevSpec>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a lightweight tag at rev (tag <name> [<rev>]; None = HEAD).

fn tag_create_annotated<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, spec: AnnotatedTag, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create an annotated tag (tag -a <name> -m <message> [<rev>]); see AnnotatedTag.

fn tag_list<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Tag names, sorted by git’s default ordering (tag --list).

fn tag_delete<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 RefName, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a tag (tag -d <name>).

fn show_file<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, path: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

A file’s content at a revision (git show <rev>:<path>). path is repo-relative; backslashes are normalised to / (git requires it). Content is decoded lossily — binary files come back mangled rather than erroring — and returned verbatim: the blob’s trailing newline(s) are preserved (not trimmed), so a read-modify-write round-trip is byte-exact.

An empty or whitespace-only path is refused before git spawns, with an is_invalid_input error: a bare git show <rev>: is not an error but the root tree listing, so an unguarded empty path would return a directory index as if it were a file’s content. vcs_jj::JjApi::file_show refuses the same input in the same form (T-149).

fn config_get<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, key: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The value of a config key, or None when unset (config --get <key>, whose exit 1 covers both “unset” and “no such section” — git doesn’t distinguish). A multi-valued key errors; read those via run.

fn config_set<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, key: &'life2 str, value: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Set a config key in the repository’s local config (config -- <key> <value>).

The -- option terminator pins both key and value as positionals, so a value that looks like a flag (--global, --file=<path>, or a plain -1) is written literally as the key’s value — git can never reparse it as an option redirecting the write to another config file. value therefore keeps no flag-shape guard on purpose (a config value may legitimately start with -); it is the flag parse that is blocked, not the leading dash. key additionally can’t be flag-shaped (guarded before the terminator is reached).

Trusted-input sink. This still writes whatever key/value it’s given — including code-execution keys like core.sshCommand or filter.<drv>.clean. The -- guard stops a value being misparsed as a flag; it does not sanitise a genuinely dangerous key you choose to write. Never wire untrusted input into it; a harden()ed client does not protect against config you write.

fn remote_add<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 str, url: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Add a remote (remote add <name> <url>).

fn remote_set_url<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, name: &'life2 str, url: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Change a remote’s URL (remote set-url <name> <url>).

fn blame<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, path: &'life2 str, rev: Option<RevSpec>, ) -> Pin<Box<dyn Future<Output = Result<Vec<BlameLine>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Per-line authorship of path (blame --line-porcelain [<rev>] -- <path>; None = the working tree’s HEAD).

Unlike show_file, path deliberately carries no pre-spawn emptiness guard: it occupies a pathspec slot of its own behind --, where git resolves an empty or whitespace-only value as an ordinary path and fails loudly (fatal: no such path '' in HEAD, exit 128) instead of quietly answering about something else. The T-149 investigation verified this on git 2.55.0; the live blame_and_show_file_reject_empty_path test pins it, so a future git that started accepting it would be caught.

fn cherry_pick<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Apply a commit onto the current branch (cherry-pick <rev>). A conflict surfaces as an error classified by is_merge_conflict.

fn revert<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, dir: &'life1 Path, rev: &'life2 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Revert a commit with the default message (revert --no-edit <rev>).

fn rebase_skip<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Skip the current patch of a paused rebase (rebase --skip). Mainly for the apply backend’s “nothing to commit” stop — the default merge backend auto-drops emptied patches on --continue.

fn cherry_pick_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress cherry-pick (cherry-pick --abort), restoring the pre-cherry-pick state.

fn cherry_pick_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a cherry-pick after resolving conflicts (cherry-pick --continue); the editor is suppressed (GIT_EDITOR=true) so the message-confirm never hangs a headless caller. On a multi-commit pick it can stop again on the next commit’s conflict (exit non-zero) — a conflict, not a hard error.

fn revert_abort<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Abort an in-progress revert (revert --abort), restoring the pre-revert state.

fn revert_continue<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Continue a revert after resolving conflicts (revert --continue); the editor is suppressed like cherry_pick_continue, and it too can stop on the next commit’s conflict.

fn bisect_reset<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

End a git bisect session (bisect reset), returning to the branch/commit that was checked out before it started. This is the “abort” for a bisect; bisect has no --continue.

fn bisect_start<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, bad: &'life2 RevSpec, good: &'life3 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Start a bisect session with bad and good bounds (bisect start <bad> <good>), returning the next checkout or the first bad commit when Git can finish immediately. The consumer remains responsible for running its test at each checkout and classifying it with bisect_good, bisect_bad, or bisect_skip. Call bisect_reset when the session is complete or abandoned.

fn bisect_good<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark the currently checked-out bisect revision good (bisect good), returning the next checkout or the first bad commit. Git advances the session; this method does not run a consumer-supplied test.

fn bisect_bad<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Mark the currently checked-out bisect revision bad (bisect bad), returning the next checkout or the first bad commit. Git advances the session; this method does not run a consumer-supplied test.

fn bisect_skip<'life0, 'life1, 'async_trait>( &'life0 self, dir: &'life1 Path, ) -> Pin<Box<dyn Future<Output = Result<BisectStep>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Skip the currently checked-out bisect revision (bisect skip), returning the next checkout or the first bad commit. If Git reports an ambiguous set of possible first bad commits, this returns ErrorReason::Parse rather than choosing one silently; the session is still owned by Git and may be reset or driven through the raw escape hatch by the consumer.

Provided Methods

fn diff_text_between<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _dir: &'life1 Path, _from: &'life2 RevSpec, _to: &'life3 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Raw git-format unified diff comparing the tree at from with the tree at to (git diff <from> <to> --no-color --no-ext-diff -M). Each endpoint is a separately validated RevSpec, so compound selectors stay in their own argv slot and the from → to direction is explicit. Unlike DiffSpec::Rev, this operation never includes the working tree implicitly: only the two supplied endpoints are compared.

The default implementation returns ErrorReason::Unsupported so an existing downstream implementor remains source-compatible; concrete Git clients override it with the real Git operation.

fn diff_between<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, dir: &'life1 Path, from: &'life2 RevSpec, to: &'life3 RevSpec, ) -> Pin<Box<dyn Future<Output = Result<Vec<FileDiff>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Parsed per-file unified diff comparing the tree at from with the tree at to, layered on diff_text_between. The default implementation uses the default text method, allowing an implementor to opt into the parsed operation by overriding only that method.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl GitApi for MockGitApi

The Git operations this crate exposes — the interface consumers code against and mock in tests.

Injection safety: reference names and revision expressions are taken as the validated RefName / RevSpec newtypes (directly or inside an options struct), so a flag-like or malformed value is rejected at construction, before it can reach an argv slot. The remaining caller-supplied bare positionals that are not refs/revisions — remote names and URLs — keep an internal reject_flag_like guard: a value that is empty or begins with - is rejected with an ErrorReason::Spawn before spawning. Flag-value slots (-m <msg>, --branch <b>), filesystem path arguments (---separated pathspecs, plus worktree paths and clone destinations — typed Path, caller-trusted), and the run/run_raw escape hatches are not guarded. The one context-dependent special value, git’s - “previous branch”, is CheckoutTarget::Previous.

impl<R: ProcessRunner> GitApi for Git<R>