git-assist 0.3.1

A suite of friendly assistive git commands
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

mod config;

use std::{
    collections::HashSet,
    os::unix::process::ExitStatusExt,
    path::PathBuf,
    process::{Command, ExitStatus},
};

use git2::{Oid, Repository as GitRepository};

use crate::{
    git::commits_in_range,
    host::{GitHost, GitPullRequest, GitRepositoryUrl},
};

pub use config::SkipPullRequestsConfigBuilder;

pub struct SkipPullRequestsConfig {
    /// The git repository.
    pub repository: GitRepositoryUrl,

    // The git directory.
    pub directory: PathBuf,

    /// A known "good" git commit.
    pub good: String,

    /// A known "bad" git commit.
    pub bad: String,

    /// Perform a "dry" run.
    pub dry_run: bool,
}

pub async fn skip_pull_requests(
    host: &dyn GitHost,
    config: &SkipPullRequestsConfig,
) -> anyhow::Result<ExitStatus> {
    eprintln!("Opening git repository ...");
    let repository = GitRepository::open(&config.directory)?;

    let range_commit_ids: HashSet<Oid> = {
        let range = (
            repository.revparse_single(&config.good)?.id(),
            repository.revparse_single(&config.bad)?.id(),
        );
        commits_in_range(&repository, range)?
            .into_iter()
            .map(|commit| commit.id())
            .collect()
    };

    eprintln!("Requesting pull requests ...");
    let pull_requests = host.merged_pull_requests(&config.repository).await?;

    eprintln!("Filtering pull requests ...");
    let pull_requests: Vec<GitPullRequest> = pull_requests
        .into_iter()
        .filter(|pull_request| {
            let Ok(base_obj) = repository.revparse_single(&pull_request.base_sha) else {
                return false;
            };
            let Ok(merge_obj) = repository.revparse_single(&pull_request.merge_sha) else {
                return false;
            };

            range_commit_ids.contains(&base_obj.id()) || range_commit_ids.contains(&merge_obj.id())
        })
        .collect();

    if !config.dry_run && std::env::current_dir()? != config.directory {
        eprintln!("Entering repository directory ...");
        std::env::set_current_dir(&config.directory)?;
    }

    for pull_request in pull_requests {
        let program = "git";
        let mut command = Command::new(program);
        let mut args = vec!["bisect".to_owned(), "skip".to_owned()];

        args.push(format!(
            "{start}..{end}^",
            start = pull_request.base_sha,
            end = pull_request.merge_sha,
        ));

        let formatted_args = args.join(" ");

        command.args(args);

        println!(
            "# Pull request #{number}: {title:?}",
            number = pull_request.identifier,
            title = pull_request.title
        );

        if config.dry_run {
            println!("{program} {formatted_args}");
        } else {
            command.spawn().and_then(|mut child| child.wait())?;
        }
    }

    Ok(ExitStatus::from_raw(0))
}