1use std::fmt;
2use std::str::FromStr;
3
4use serde::{Deserialize, Serialize};
5
6use super::Principal;
7
8#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
9#[serde(rename_all = "lowercase")]
10pub enum PullRequestState {
11 Open,
12 Closed,
13 Merged,
14}
15
16impl PullRequestState {
17 pub fn as_str(self) -> &'static str {
18 match self {
19 Self::Open => "open",
20 Self::Closed => "closed",
21 Self::Merged => "merged",
22 }
23 }
24}
25
26impl fmt::Display for PullRequestState {
27 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
28 f.write_str(self.as_str())
29 }
30}
31
32#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
35#[serde(rename_all = "kebab-case")]
36pub enum MergeMethod {
37 Merge,
38 Squash,
39 Rebase,
40 FastForward,
41}
42
43impl MergeMethod {
44 pub fn as_str(self) -> &'static str {
45 match self {
46 Self::Merge => "merge",
47 Self::Squash => "squash",
48 Self::Rebase => "rebase",
49 Self::FastForward => "fast-forward",
50 }
51 }
52}
53
54impl fmt::Display for MergeMethod {
55 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
56 f.write_str(self.as_str())
57 }
58}
59
60impl FromStr for MergeMethod {
61 type Err = ();
62
63 fn from_str(s: &str) -> Result<Self, ()> {
64 match s.trim().to_ascii_lowercase().replace('_', "-").as_str() {
65 "merge" => Ok(Self::Merge),
66 "squash" => Ok(Self::Squash),
67 "rebase" => Ok(Self::Rebase),
68 "fast-forward" | "fastforward" | "ff" => Ok(Self::FastForward),
69 _ => Err(()),
70 }
71 }
72}
73
74#[derive(Debug, Clone, Default, Serialize, Deserialize)]
75pub struct PullRequestStats {
76 #[serde(default)]
77 pub commits: Option<i64>,
78 #[serde(default)]
79 pub files_changed: Option<i64>,
80 #[serde(default)]
81 pub additions: Option<i64>,
82 #[serde(default)]
83 pub deletions: Option<i64>,
84 #[serde(default)]
85 pub conversations: Option<i64>,
86 #[serde(default)]
87 pub unresolved_count: Option<i64>,
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
96pub struct PullRequest {
97 pub number: u64,
98 #[serde(default)]
99 pub title: String,
100 #[serde(default)]
101 pub description: String,
102 pub state: PullRequestState,
103 #[serde(default)]
104 pub is_draft: bool,
105 #[serde(default)]
106 pub author: Option<Principal>,
107 #[serde(default)]
108 pub merger: Option<Principal>,
109 #[serde(default)]
110 pub source_branch: String,
111 #[serde(default)]
112 pub target_branch: String,
113 #[serde(default)]
115 pub source_repo_id: Option<i64>,
116 #[serde(default)]
117 pub target_repo_id: Option<i64>,
118 #[serde(default)]
119 pub created: Option<i64>,
120 #[serde(default)]
121 pub updated: Option<i64>,
122 #[serde(default)]
123 pub merged: Option<i64>,
124 #[serde(default)]
125 pub closed: Option<i64>,
126 #[serde(default)]
127 pub web_url: Option<String>,
128 #[serde(default)]
129 pub stats: Option<PullRequestStats>,
130 #[serde(default)]
131 pub merge_check_status: Option<String>,
132 #[serde(default)]
133 pub merge_conflicts: Vec<String>,
134 #[serde(default)]
135 pub merge_method: Option<MergeMethod>,
136}
137
138impl PullRequest {
139 pub fn display_state(&self) -> &'static str {
142 if self.state == PullRequestState::Open && self.is_draft {
143 "draft"
144 } else {
145 self.state.as_str()
146 }
147 }
148
149 pub fn author_label(&self) -> String {
150 self.author
151 .as_ref()
152 .map(Principal::label)
153 .unwrap_or_default()
154 }
155}
156
157#[derive(Debug, Clone, Serialize)]
159pub struct CreatePullRequest {
160 pub title: String,
161 pub description: String,
162 pub source_branch: String,
163 pub target_branch: String,
164 #[serde(skip_serializing_if = "Option::is_none")]
165 pub source_repo_ref: Option<String>,
166 pub is_draft: bool,
167}
168
169#[derive(Debug, Clone, Default, Serialize)]
171pub struct MergePullRequest {
172 #[serde(skip_serializing_if = "Option::is_none")]
173 pub method: Option<MergeMethod>,
174 #[serde(skip_serializing_if = "Option::is_none")]
175 pub title: Option<String>,
176 #[serde(skip_serializing_if = "Option::is_none")]
177 pub message: Option<String>,
178 #[serde(skip_serializing_if = "Option::is_none")]
179 pub source_sha: Option<String>,
180 #[serde(skip_serializing_if = "std::ops::Not::not")]
181 pub bypass_rules: bool,
182 #[serde(skip_serializing_if = "std::ops::Not::not")]
183 pub dry_run: bool,
184}
185
186#[derive(Debug, Clone, Default, Serialize, Deserialize)]
191pub struct MergeResult {
192 #[serde(default)]
193 pub sha: Option<String>,
194 #[serde(default)]
195 pub branch_deleted: Option<bool>,
196 #[serde(default)]
197 pub mergeable: Option<bool>,
198 #[serde(default)]
199 pub dry_run: Option<bool>,
200 #[serde(default)]
201 pub conflict_files: Vec<String>,
202 #[serde(default)]
203 pub allowed_methods: Vec<MergeMethod>,
204}
205
206#[cfg(test)]
207mod tests {
208 use super::*;
209
210 #[test]
211 fn merge_methods_use_the_wire_spelling() {
212 assert_eq!(MergeMethod::FastForward.as_str(), "fast-forward");
213 assert_eq!(
214 serde_json::to_string(&MergeMethod::FastForward).unwrap(),
215 "\"fast-forward\""
216 );
217 assert_eq!("fast-forward".parse(), Ok(MergeMethod::FastForward));
218 assert_eq!("FF".parse(), Ok(MergeMethod::FastForward));
219 assert_eq!("nonsense".parse::<MergeMethod>(), Err(()));
220 }
221
222 #[test]
223 fn a_draft_reads_as_draft_rather_than_open() {
224 let mut pr: PullRequest = serde_json::from_value(serde_json::json!({
225 "number": 12, "title": "Add OAuth", "state": "open", "is_draft": true
226 }))
227 .unwrap();
228 assert_eq!(pr.display_state(), "draft");
229 pr.is_draft = false;
230 assert_eq!(pr.display_state(), "open");
231 pr.state = PullRequestState::Merged;
232 pr.is_draft = true;
233 assert_eq!(pr.display_state(), "merged");
234 }
235
236 #[test]
237 fn a_minimal_payload_still_decodes() {
238 let pr: PullRequest =
239 serde_json::from_value(serde_json::json!({ "number": 1, "state": "closed" })).unwrap();
240 assert_eq!(pr.number, 1);
241 assert!(pr.title.is_empty());
242 assert!(pr.author.is_none());
243 assert_eq!(pr.author_label(), "");
244 }
245
246 #[test]
247 fn merge_body_omits_everything_unset() {
248 let body = serde_json::to_value(MergePullRequest {
249 method: Some(MergeMethod::Squash),
250 ..Default::default()
251 })
252 .unwrap();
253 assert_eq!(body, serde_json::json!({ "method": "squash" }));
254 }
255}
256
257#[derive(Debug, Clone, Default, Serialize, Deserialize)]
259pub struct FileDiff {
260 #[serde(default)]
261 pub path: String,
262 #[serde(default)]
264 pub old_path: Option<String>,
265 #[serde(default)]
266 pub status: Option<String>,
267 #[serde(default)]
268 pub additions: Option<i64>,
269 #[serde(default)]
270 pub deletions: Option<i64>,
271 #[serde(default)]
272 pub changes: Option<i64>,
273 #[serde(default)]
274 pub is_binary: Option<bool>,
275 #[serde(default)]
276 pub is_submodule: Option<bool>,
277 #[serde(default)]
279 pub patch: Option<String>,
280 #[serde(default)]
281 pub sha: Option<String>,
282 #[serde(default)]
283 pub old_sha: Option<String>,
284}
285
286#[derive(Debug, Clone, Default, Serialize, Deserialize)]
292pub struct Check {
293 #[serde(default)]
294 pub identifier: String,
295 #[serde(default)]
296 pub status: crate::CiStatus,
297 #[serde(default)]
298 pub summary: Option<String>,
299 #[serde(default)]
300 pub link: Option<String>,
301 #[serde(default)]
302 pub started: Option<i64>,
303 #[serde(default)]
304 pub ended: Option<i64>,
305 #[serde(default)]
306 pub reported_by: Option<super::Principal>,
307}
308
309#[derive(Debug, Clone, Default, Serialize, Deserialize)]
310pub struct PullRequestCheck {
311 #[serde(default)]
313 pub required: Option<bool>,
314 #[serde(default)]
315 pub bypassable: Option<bool>,
316 #[serde(default)]
317 pub check: Check,
318}
319
320#[derive(Debug, Clone, Default, Serialize, Deserialize)]
321pub struct PullRequestChecks {
322 #[serde(default)]
324 pub commit_sha: Option<String>,
325 #[serde(default)]
326 pub checks: Vec<PullRequestCheck>,
327}
328
329impl PullRequestChecks {
330 pub fn required_blocking(&self) -> Vec<&PullRequestCheck> {
335 self.checks
336 .iter()
337 .filter(|c| c.required.unwrap_or(false) && !c.check.status.is_success())
338 .collect()
339 }
340
341 pub fn any_failed(&self) -> bool {
342 self.checks.iter().any(|c| c.check.status.is_failed())
343 }
344}