1use 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#[derive(Debug, Clone)]
37pub struct GitLabReviewProvider {
38 repo: String,
40}
41
42impl GitLabReviewProvider {
43 #[must_use]
47 pub fn new(repo: impl Into<String>) -> Self {
48 Self { repo: repo.into() }
49 }
50}
51
52#[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#[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#[derive(Debug, Clone, Deserialize)]
85struct MrViewResponse {
86 #[serde(default)]
87 author: Option<ApiUser>,
88}
89
90#[async_trait]
93impl ReviewProvider for GitLabReviewProvider {
94 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 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 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 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 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}