gps 7.3.3

Official CLI & library for Git Patch Stack
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// This is the `rr` module. It is responsible for exposing a public interface
// making it easy for the CLI to execute the rr command. This generally
// means there is one public function. In this case the `rr()` function. All
// other functions in here are purely private supporting functions and should
// be strongly considered if they fit better in one of the other modules
// inside of the `ps` module.

use super::patch_index_range_batch::PatchIndexRangeBatch;
use super::utils::{print_err, print_error_chain};
use gps as ps;

pub fn request_review(
    patch_index_or_range_batch: String,
    branch_name: Option<String>,
    color: bool,
    isolation_verification_hook: bool,
    post_sync_hook: bool,
) {
    let batch = match patch_index_or_range_batch.parse::<PatchIndexRangeBatch>() {
        Ok(b) => b,
        Err(e) => {
            print_err(
                color,
                &format!(
                    "Failed to parse patch index range batch, \"{}\"",
                    &patch_index_or_range_batch
                ),
            );
            print_error_chain(color, e.into());
            std::process::exit(1);
        }
    };

    if batch.len() > 1 && branch_name.is_some() {
        print_err(
            color,
            r#"
  Specifying a branch name does not work when batching.

  You can associate custom branch names with patches or patch series by
  using the branch command prior to requesting review of them as a batch.
  The request-review command will use the associated branch name for each
  patch or patch series respectively.

  For patches or patch series that you have not previously associated a
  custom branch name to. The request-review command will simply generate
  a branch name for each of them.
"#,
        );
        std::process::exit(1);
    }

    for patch_index_range in batch {
        println!("Running request-review for {}", patch_index_range);
        match ps::request_review(
            patch_index_range.start_index,
            patch_index_range.end_index,
            branch_name.clone(),
            color,
            isolation_verification_hook,
            post_sync_hook,
        ) {
            Ok(_) => {}
            Err(e) => match e {
                ps::RequestReviewError::MergeCommitDetected(oid) => {
                    print_err(
                        color,
                        &format!(
                            r#"
  Detected a merge commit ({}) in the patch(es) selection.

  This should only occur if you have a merge commit that hasn't been flatten in your patch stack.
  To flatten merge commits in your patch stack you can simply run gps rebase and then try to request review again.
        "#,
                            oid
                        ),
                    );
                }
                ps::RequestReviewError::ConflictsExist(src_oid, dst_oid) => {
                    print_err(
                        color,
                        &format!(
                            r#"
  Cherry picking commit ({}) onto commit ({}) failed due to conflicts.

  Please make sure that you aren't missing a dependent patch in your patch(es) selection.
        "#,
                            src_oid, dst_oid
                        ),
                    );
                }
                ps::RequestReviewError::PostSyncHookNotExecutable(path) => {
                    let path_str = path.to_str().unwrap_or("unknow path");
                    let msg = format!(
                        r#"
  The request_review_post_sync hook was found at

    {}

  but it is NOT executable. For the request-review command to function properly
  the hook needs to be executable. Generally this can be done with the
  following.

    chmod u+x {}
"#,
                        path_str, path_str
                    );
                    print_err(color, &msg);
                }
                ps::RequestReviewError::IsolationVerificationFailed(
                    ps::VerifyIsolationError::IsolateFailed(
                        ps::IsolateError::UncommittedChangesExist,
                    ),
                ) => {
                    print_err(
                        color,
                        r#"
  gps request-review command requires a clean working directory when verifying isolation, but it looks like yours is dirty.

  It is recommended that you create a WIP commit. But, you could also use git stash if you prefer.
        "#,
                    );
                }
                _ => {
                    print_error_chain(color, e.into());
                }
            },
        };
    }
}