Skip to main content

gitflow_gitlab/
review.rs

1//! GitLab Review 提供者实现。
2//!
3//! 通过 `glab mr approve` / `glab mr revoke` / `glab mr note` CLI 实现
4//! [`ReviewProvider`] trait,支持 MR 审查的评论、批准、要求修改及提交审查。
5//! 所有方法通过 `tokio::process::Command` 调用 `glab`,捕获 stdout 并解析 JSON。
6//!
7//! glab 的审查命令与 gh 不同:
8//! - 批准使用 `glab mr approve`
9//! - 撤回使用 `glab mr revoke`
10//! - 评论使用 `glab mr note`
11//!
12//! 由于 glab 不提供统一的 `review --json` 输出,本模块在审查操作后
13//! 构造符合 [`ReviewData`] 的返回值。
14
15use async_trait::async_trait;
16use chrono::{DateTime, Utc};
17use gitflow_core::{
18    CoreError, Result,
19    review::{ReviewData, ReviewProvider, ReviewState},
20    types::UserSummary,
21};
22use serde::Deserialize;
23use tracing::debug;
24
25use crate::error::parse_glab_error;
26
27/// GitLab Review 提供者,通过 `glab` CLI 操作。
28///
29/// # Examples
30///
31/// ```no_run
32/// use gitflow_gitlab::GitLabReviewProvider;
33///
34/// let provider = GitLabReviewProvider::new("gitlab-org/gitlab");
35/// ```
36#[derive(Debug, Clone)]
37pub struct GitLabReviewProvider {
38    /// GitLab `namespace/project`。
39    repo: String,
40}
41
42impl GitLabReviewProvider {
43    /// 创建新的 GitLab Review 提供者。
44    ///
45    /// `repo` 格式为 `namespace/project`。
46    #[must_use]
47    pub fn new(repo: impl Into<String>) -> Self {
48        Self { repo: repo.into() }
49    }
50}
51
52// ── 中间 API 响应类型 ──────────────────────────────────────────────
53
54/// `glab mr note --output json` 返回的 JSON 结构(用于获取审查评论 ID)。
55#[derive(Debug, Clone, Deserialize)]
56struct NoteApiResponse {
57    id: u64,
58    #[serde(default)]
59    body: String,
60    #[serde(default)]
61    author: Option<ApiUser>,
62    #[serde(default)]
63    created_at: Option<DateTime<Utc>>,
64}
65
66/// JSON 输出中的用户信息。
67#[derive(Debug, Clone, Deserialize)]
68struct ApiUser {
69    username: String,
70    #[serde(default)]
71    id: u64,
72}
73
74impl From<&ApiUser> for UserSummary {
75    fn from(u: &ApiUser) -> Self {
76        Self {
77            login: u.username.clone(),
78            id: u.id.to_string(),
79        }
80    }
81}
82
83/// `glab mr view --output json` 返回的 JSON 结构(用于获取当前用户信息)。
84#[derive(Debug, Clone, Deserialize)]
85struct MrViewResponse {
86    #[serde(default)]
87    author: Option<ApiUser>,
88}
89
90// ── trait 实现 ──────────────────────────────────────────────────────
91
92#[async_trait]
93impl ReviewProvider for GitLabReviewProvider {
94    /// 在指定 MR 上添加审查评论。
95    ///
96    /// 调用 `glab mr note` 发布评论,并通过 `glab mr view` 获取当前用户信息
97    /// 以构造 [`ReviewData`]。
98    async fn comment(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
99        debug!(repo = %self.repo, number = pr_number, "spawning `glab mr note`");
100
101        let output = tokio::process::Command::new("glab")
102            .args(["mr", "note"])
103            .arg(pr_number.to_string())
104            .arg("--repo")
105            .arg(&self.repo)
106            .arg("--body")
107            .arg(body)
108            .arg("--output")
109            .arg("json")
110            .output()
111            .await
112            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
113
114        if !output.status.success() {
115            return Err(parse_glab_error(&output.stderr).into());
116        }
117
118        let note: NoteApiResponse =
119            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
120
121        let author = note.author.as_ref().map_or_else(
122            || UserSummary {
123                login: "unknown".into(),
124                id: "0".to_string(),
125            },
126            UserSummary::from,
127        );
128
129        Ok(ReviewData {
130            id: note.id,
131            state: ReviewState::Commented,
132            body: Some(note.body),
133            author,
134            submitted_at: note.created_at.unwrap_or_else(Utc::now),
135        })
136    }
137
138    /// 批准指定 MR。
139    ///
140    /// 调用 `glab mr approve` 批准 MR,然后构造 [`ReviewData`]。
141    async fn approve(&self, pr_number: u64, body: Option<&str>) -> Result<ReviewData> {
142        debug!(repo = %self.repo, number = pr_number, "spawning `glab mr approve`");
143
144        let mut cmd = tokio::process::Command::new("glab");
145        cmd.args(["mr", "approve"])
146            .arg(pr_number.to_string())
147            .arg("--repo")
148            .arg(&self.repo);
149
150        if let Some(b) = body {
151            cmd.arg("--comment").arg(b);
152        }
153
154        let output = cmd
155            .output()
156            .await
157            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
158
159        if !output.status.success() {
160            return Err(parse_glab_error(&output.stderr).into());
161        }
162
163        let message = String::from_utf8_lossy(&output.stdout).trim().to_string();
164        let author = self.get_current_user().await.unwrap_or(UserSummary {
165            login: "unknown".into(),
166            id: "0".to_string(),
167        });
168
169        Ok(ReviewData {
170            id: 0,
171            state: ReviewState::Approved,
172            body: if message.is_empty() {
173                body.map(String::from)
174            } else {
175                Some(message)
176            },
177            author,
178            submitted_at: Utc::now(),
179        })
180    }
181
182    /// 对指定 MR 要求修改。
183    ///
184    /// glab 没有直接的 "request changes" 命令,通过 `glab mr note` 发布
185    /// 包含要求修改意见的评论,并标记为 `ChangesRequested` 状态。
186    async fn request_changes(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
187        debug!(
188            repo = %self.repo,
189            number = pr_number,
190            "spawning `glab mr note` (request changes)"
191        );
192
193        let changes_body = format!("Changes requested:\n\n{body}");
194
195        let output = tokio::process::Command::new("glab")
196            .args(["mr", "note"])
197            .arg(pr_number.to_string())
198            .arg("--repo")
199            .arg(&self.repo)
200            .arg("--body")
201            .arg(&changes_body)
202            .arg("--output")
203            .arg("json")
204            .output()
205            .await
206            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
207
208        if !output.status.success() {
209            return Err(parse_glab_error(&output.stderr).into());
210        }
211
212        let note: NoteApiResponse =
213            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
214
215        let author = note.author.as_ref().map_or_else(
216            || UserSummary {
217                login: "unknown".into(),
218                id: "0".to_string(),
219            },
220            UserSummary::from,
221        );
222
223        Ok(ReviewData {
224            id: note.id,
225            state: ReviewState::ChangesRequested,
226            body: Some(note.body),
227            author,
228            submitted_at: note.created_at.unwrap_or_else(Utc::now),
229        })
230    }
231
232    /// 提交指定 MR 的审查。
233    ///
234    /// 根据 `event` 参数分别调用 `glab mr approve`、`glab mr revoke` 或
235    /// `glab mr note` 实现不同的审查操作。
236    async fn submit_review(
237        &self,
238        pr_number: u64,
239        event: ReviewState,
240        body: Option<&str>,
241    ) -> Result<ReviewData> {
242        debug!(repo = %self.repo, number = pr_number, ?event, "spawning `glab mr review`");
243
244        match event {
245            ReviewState::Approved => self.approve(pr_number, body).await,
246            ReviewState::ChangesRequested => {
247                self.request_changes(pr_number, body.unwrap_or("Changes requested."))
248                    .await
249            }
250            ReviewState::Commented => {
251                self.comment(pr_number, body.unwrap_or("Review comment."))
252                    .await
253            }
254        }
255    }
256}
257
258impl GitLabReviewProvider {
259    /// 获取当前登录用户信息(内部辅助方法)。
260    async fn get_current_user(&self) -> Result<UserSummary> {
261        let output = tokio::process::Command::new("glab")
262            .args(["mr", "list"])
263            .arg("--repo")
264            .arg(&self.repo)
265            .arg("--output")
266            .arg("json")
267            .arg("--per-page")
268            .arg("1")
269            .output()
270            .await
271            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
272
273        if !output.status.success() {
274            return Ok(UserSummary {
275                login: "unknown".into(),
276                id: "0".to_string(),
277            });
278        }
279
280        let mrs: Vec<MrViewResponse> =
281            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
282
283        if let Some(mr) = mrs.into_iter().next()
284            && let Some(author) = mr.author
285        {
286            return Ok(UserSummary::from(&author));
287        }
288
289        Ok(UserSummary {
290            login: "unknown".into(),
291            id: "0".to_string(),
292        })
293    }
294}
295
296#[cfg(test)]
297mod tests {
298    use super::*;
299
300    #[test]
301    fn test_should_construct_gitlab_review_provider() {
302        let provider = GitLabReviewProvider::new("gitlab-org/gitlab");
303        assert_eq!(provider.repo, "gitlab-org/gitlab");
304    }
305
306    #[test]
307    fn test_should_construct_gitlab_review_provider_from_string() {
308        let repo = String::from("gitlab-org/gitlab");
309        let provider = GitLabReviewProvider::new(repo);
310        assert_eq!(provider.repo, "gitlab-org/gitlab");
311    }
312
313    #[test]
314    fn test_should_deserialize_note_api_response() {
315        let json = br#"{
316            "id": 2001,
317            "body": "Looks great, LGTM!",
318            "author": {"username": "reviewer", "id": 42},
319            "created_at": "2026-05-20T14:30:00Z"
320        }"#;
321
322        let note: NoteApiResponse = serde_json::from_slice(json).expect("valid NoteApiResponse");
323        assert_eq!(note.id, 2001);
324        assert_eq!(note.body, "Looks great, LGTM!");
325        assert_eq!(note.author.as_ref().map(|a| &*a.username), Some("reviewer"));
326    }
327
328    #[test]
329    fn test_should_deserialize_note_without_author() {
330        let json = br#"{
331            "id": 2002,
332            "body": "Anonymous comment",
333            "author": null,
334            "created_at": "2026-05-21T09:00:00Z"
335        }"#;
336
337        let note: NoteApiResponse = serde_json::from_slice(json).expect("valid NoteApiResponse");
338        assert!(note.author.is_none());
339    }
340
341    #[test]
342    fn test_should_convert_note_to_review_data() {
343        let note = NoteApiResponse {
344            id: 100,
345            body: "LGTM".into(),
346            author: Some(ApiUser {
347                username: "reviewer".into(),
348                id: 5,
349            }),
350            created_at: Some("2026-01-01T00:00:00Z".parse().expect("valid date")),
351        };
352
353        let author = note
354            .author
355            .as_ref()
356            .map(UserSummary::from)
357            .expect("has author");
358        let review = ReviewData {
359            id: note.id,
360            state: ReviewState::Commented,
361            body: Some(note.body),
362            author,
363            submitted_at: note.created_at.expect("has date"),
364        };
365
366        assert_eq!(review.id, 100);
367        assert_eq!(review.state, ReviewState::Commented);
368        assert_eq!(review.author.login, "reviewer");
369    }
370
371    #[test]
372    fn test_should_debug_format_provider() {
373        let provider = GitLabReviewProvider::new("gitlab-org/gitlab");
374        let debug = format!("{provider:?}");
375        assert!(debug.contains("GitLabReviewProvider"));
376        assert!(debug.contains("gitlab-org/gitlab"));
377    }
378
379    #[test]
380    fn test_should_clone_gitlab_review_provider() {
381        let original = GitLabReviewProvider::new("owner/repo");
382        let cloned = original.clone();
383        assert_eq!(original.repo, cloned.repo);
384    }
385}