Skip to main content

gitfox_client/models/
pull_request.rs

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/// How a pull request is merged. The wire values are GitFox's, including the
33/// hyphen in `fast-forward`.
34#[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/// A pull request.
91///
92/// Timestamps stay as the raw epoch integers GitFox sends. Interpreting them is
93/// a presentation concern, and keeping them raw means the JSON a machine reads
94/// never depends on this crate's idea of a date format.
95#[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    /// Differs from `target_repo_id` when the pull request comes from a fork.
114    #[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    /// `open`, `draft`, `merged` or `closed` — draft is a display state, not an
140    /// API one, but it is the first thing a reviewer wants to know.
141    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/// The body of `POST /repos/{repo_ref}/pullreq`.
158#[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/// The body of `POST /repos/{repo_ref}/pullreq/{n}/merge`.
170#[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/// The answer to a merge attempt.
187///
188/// A `dry_run` merge returns the same shape with `mergeable` telling you whether
189/// the real thing would work — which is what `fx pr merge --dry-run` reports.
190#[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/// One file's worth of a pull request diff.
258#[derive(Debug, Clone, Default, Serialize, Deserialize)]
259pub struct FileDiff {
260    #[serde(default)]
261    pub path: String,
262    /// Set when the file was renamed or copied.
263    #[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    /// The unified diff for this file. Absent for binaries and submodules.
278    #[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/// A status check reported against a pull request's head commit.
287///
288/// Reuses [`crate::CiStatus`] — a check status is a CI status, and the same
289/// open-set reasoning applies: GitFox lists `error`, `failure`, `pending`,
290/// `running` and `success` today, and this keeps whichever word arrives.
291#[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    /// Whether a merge is blocked while this check is not green.
312    #[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    /// The commit the checks were reported against.
323    #[serde(default)]
324    pub commit_sha: Option<String>,
325    #[serde(default)]
326    pub checks: Vec<PullRequestCheck>,
327}
328
329impl PullRequestChecks {
330    /// Whether anything required is not green.
331    ///
332    /// A required check that is still running counts as blocking: the answer to
333    /// "can this merge" is no, not yet.
334    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}