1use async_trait::async_trait;
7use chrono::{DateTime, Utc};
8use gitflow_core::{
9 CoreError, Result,
10 label::{
11 CreateLabelArgs, CreateMilestoneArgs, LabelData, LabelProvider, MilestoneData,
12 MilestoneProvider,
13 },
14 types::State,
15};
16use serde::Deserialize;
17use tracing::debug;
18
19use crate::error::parse_glab_error;
20
21#[derive(Debug, Clone)]
31pub struct GitLabLabelProvider {
32 repo: String,
34}
35
36impl GitLabLabelProvider {
37 #[must_use]
41 pub fn new(repo: impl Into<String>) -> Self {
42 Self { repo: repo.into() }
43 }
44}
45
46#[derive(Debug, Clone, Deserialize)]
48struct LabelApiResponse {
49 #[serde(default)]
50 name: String,
51 #[serde(default)]
52 color: Option<String>,
53 #[serde(default)]
54 description: Option<String>,
55}
56
57impl From<LabelApiResponse> for LabelData {
58 fn from(api: LabelApiResponse) -> Self {
59 Self {
60 name: api.name,
61 color: api.color,
62 description: api.description,
63 }
64 }
65}
66
67#[async_trait]
68impl LabelProvider for GitLabLabelProvider {
69 async fn create(&self, args: CreateLabelArgs) -> Result<LabelData> {
70 debug!(
71 repo = %self.repo,
72 name = %args.name,
73 color = %args.color,
74 "spawning `glab label create`"
75 );
76
77 let mut cmd = tokio::process::Command::new("glab");
78 cmd.args(["label", "create"])
79 .arg("--name")
80 .arg(&args.name)
81 .arg("--color")
82 .arg(&args.color)
83 .arg("--repo")
84 .arg(&self.repo)
85 .arg("--output")
86 .arg("json");
87
88 if let Some(ref desc) = args.description {
89 cmd.arg("--description").arg(desc);
90 }
91
92 let output = cmd
93 .output()
94 .await
95 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label create: {e}")))?;
96
97 if !output.status.success() {
98 return Err(parse_glab_error(&output.stderr).into());
99 }
100
101 let api_response: LabelApiResponse =
102 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
103
104 Ok(api_response.into())
105 }
106
107 async fn list(&self) -> Result<Vec<LabelData>> {
108 debug!(repo = %self.repo, "spawning `glab label list`");
109
110 let output = tokio::process::Command::new("glab")
111 .args(["label", "list"])
112 .arg("--repo")
113 .arg(&self.repo)
114 .arg("--output")
115 .arg("json")
116 .output()
117 .await
118 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label list: {e}")))?;
119
120 if !output.status.success() {
121 return Err(parse_glab_error(&output.stderr).into());
122 }
123
124 let api_responses: Vec<LabelApiResponse> =
125 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
126
127 Ok(api_responses.into_iter().map(LabelData::from).collect())
128 }
129
130 async fn edit(&self, name: &str, args: CreateLabelArgs) -> Result<LabelData> {
131 debug!(repo = %self.repo, name, "spawning `glab label edit`");
132
133 let mut cmd = tokio::process::Command::new("glab");
134 cmd.args(["label", "edit"])
135 .arg("--name")
136 .arg(name)
137 .arg("--repo")
138 .arg(&self.repo)
139 .arg("--color")
140 .arg(&args.color)
141 .arg("--output")
142 .arg("json");
143
144 if let Some(ref desc) = args.description {
145 cmd.arg("--description").arg(desc);
146 }
147
148 let output = cmd
149 .output()
150 .await
151 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label edit: {e}")))?;
152
153 if !output.status.success() {
154 return Err(parse_glab_error(&output.stderr).into());
155 }
156
157 let api_response: LabelApiResponse =
158 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
159
160 Ok(api_response.into())
161 }
162
163 async fn delete(&self, name: &str) -> Result<()> {
164 debug!(repo = %self.repo, name, "spawning `glab label delete`");
165
166 let output = tokio::process::Command::new("glab")
167 .args(["label", "delete"])
168 .arg(name)
169 .arg("--yes")
170 .arg("--repo")
171 .arg(&self.repo)
172 .output()
173 .await
174 .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label delete: {e}")))?;
175
176 if !output.status.success() {
177 return Err(parse_glab_error(&output.stderr).into());
178 }
179
180 Ok(())
181 }
182}
183
184#[derive(Debug, Clone)]
196pub struct GitLabMilestoneProvider {
197 repo: String,
199}
200
201impl GitLabMilestoneProvider {
202 #[must_use]
206 pub fn new(repo: impl Into<String>) -> Self {
207 Self { repo: repo.into() }
208 }
209}
210
211#[derive(Debug, Clone, Deserialize)]
213#[allow(
214 dead_code,
215 reason = "Used for deserialization; not all fields are read"
216)]
217struct MilestoneApiResponse {
218 id: u64,
219 #[serde(default)]
220 iid: Option<u64>,
221 title: String,
222 #[serde(default)]
223 description: Option<String>,
224 state: String,
225 #[serde(default)]
226 due_date: Option<String>,
227 #[serde(default)]
228 start_date: Option<String>,
229 #[serde(default)]
230 created_at: Option<DateTime<Utc>>,
231 #[serde(default)]
232 updated_at: Option<DateTime<Utc>>,
233}
234
235impl From<MilestoneApiResponse> for MilestoneData {
236 fn from(api: MilestoneApiResponse) -> Self {
237 let state = if api.state == "closed" {
238 State::Closed
239 } else {
240 State::Open
241 };
242 let due_on = api.due_date.and_then(|s| {
243 if let Ok(dt) = DateTime::parse_from_rfc3339(&s) {
245 return Some(dt.with_timezone(&Utc));
246 }
247 chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d")
248 .ok()
249 .map(|d| {
250 let naive_dt = d
251 .and_hms_opt(0, 0, 0)
252 .unwrap_or_else(|| d.and_hms_opt(12, 0, 0).unwrap_or_default());
253 DateTime::<Utc>::from_naive_utc_and_offset(naive_dt, Utc)
254 })
255 });
256
257 Self {
258 number: api.iid.unwrap_or(api.id),
259 title: api.title,
260 description: api.description,
261 state,
262 due_on,
263 closed_issues: 0,
264 open_issues: 0,
265 }
266 }
267}
268
269#[async_trait]
270impl MilestoneProvider for GitLabMilestoneProvider {
271 async fn create(&self, args: CreateMilestoneArgs) -> Result<MilestoneData> {
272 debug!(repo = %self.repo, title = %args.title, "spawning `glab milestone create`");
273
274 let mut cmd = tokio::process::Command::new("glab");
275 cmd.args(["milestone", "create"])
276 .arg("--title")
277 .arg(&args.title)
278 .arg("--project")
279 .arg(&self.repo)
280 .arg("--output")
281 .arg("json");
282
283 if let Some(ref desc) = args.description {
284 cmd.arg("--description").arg(desc);
285 }
286
287 if let Some(ref due) = args.due_on {
288 cmd.arg("--due-date")
289 .arg(due.format("%Y-%m-%d").to_string());
290 }
291
292 let output = cmd.output().await.map_err(|e| {
293 CoreError::Platform(format!("Failed to spawn glab milestone create: {e}"))
294 })?;
295
296 if !output.status.success() {
297 return Err(parse_glab_error(&output.stderr).into());
298 }
299
300 let api_response: MilestoneApiResponse =
301 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
302
303 Ok(api_response.into())
304 }
305
306 async fn list(&self) -> Result<Vec<MilestoneData>> {
307 debug!(repo = %self.repo, "spawning `glab milestone list`");
308
309 let output = tokio::process::Command::new("glab")
310 .args(["milestone", "list"])
311 .arg("--project")
312 .arg(&self.repo)
313 .arg("--output")
314 .arg("json")
315 .output()
316 .await
317 .map_err(|e| {
318 CoreError::Platform(format!("Failed to spawn glab milestone list: {e}"))
319 })?;
320
321 if !output.status.success() {
322 return Err(parse_glab_error(&output.stderr).into());
323 }
324
325 let api_responses: Vec<MilestoneApiResponse> =
326 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
327
328 Ok(api_responses.into_iter().map(MilestoneData::from).collect())
329 }
330
331 async fn edit(&self, number: u64, args: CreateMilestoneArgs) -> Result<MilestoneData> {
332 debug!(repo = %self.repo, number, "spawning `glab milestone edit`");
333
334 let mut cmd = tokio::process::Command::new("glab");
335 cmd.args(["milestone", "edit"])
336 .arg(number.to_string())
337 .arg("--project")
338 .arg(&self.repo)
339 .arg("--title")
340 .arg(&args.title)
341 .arg("--output")
342 .arg("json");
343
344 if let Some(ref desc) = args.description {
345 cmd.arg("--description").arg(desc);
346 }
347
348 if let Some(ref due) = args.due_on {
349 cmd.arg("--due-date")
350 .arg(due.format("%Y-%m-%d").to_string());
351 }
352
353 let output = cmd.output().await.map_err(|e| {
354 CoreError::Platform(format!("Failed to spawn glab milestone edit: {e}"))
355 })?;
356
357 if !output.status.success() {
358 return Err(parse_glab_error(&output.stderr).into());
359 }
360
361 let api_response: MilestoneApiResponse =
362 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
363
364 Ok(api_response.into())
365 }
366
367 async fn close(&self, number: u64) -> Result<MilestoneData> {
368 debug!(repo = %self.repo, number, "spawning `glab milestone close`");
369
370 let output = tokio::process::Command::new("glab")
371 .args(["milestone", "close"])
372 .arg(number.to_string())
373 .arg("--project")
374 .arg(&self.repo)
375 .arg("--output")
376 .arg("json")
377 .output()
378 .await
379 .map_err(|e| {
380 CoreError::Platform(format!("Failed to spawn glab milestone close: {e}"))
381 })?;
382
383 if !output.status.success() {
384 return Err(parse_glab_error(&output.stderr).into());
385 }
386
387 let api_response: MilestoneApiResponse =
388 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
389
390 Ok(api_response.into())
391 }
392
393 async fn reopen(&self, number: u64) -> Result<MilestoneData> {
394 debug!(repo = %self.repo, number, "spawning `glab milestone reopen`");
395
396 let output = tokio::process::Command::new("glab")
397 .args(["milestone", "reopen"])
398 .arg(number.to_string())
399 .arg("--project")
400 .arg(&self.repo)
401 .arg("--output")
402 .arg("json")
403 .output()
404 .await
405 .map_err(|e| {
406 CoreError::Platform(format!("Failed to spawn glab milestone reopen: {e}"))
407 })?;
408
409 if !output.status.success() {
410 return Err(parse_glab_error(&output.stderr).into());
411 }
412
413 let api_response: MilestoneApiResponse =
414 serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
415
416 Ok(api_response.into())
417 }
418}
419
420#[cfg(test)]
421mod tests {
422 use super::*;
423
424 #[test]
427 fn test_should_construct_gitlab_label_provider() {
428 let provider = GitLabLabelProvider::new("gitlab-org/gitlab");
429 assert_eq!(provider.repo, "gitlab-org/gitlab");
430 }
431
432 #[test]
433 fn test_should_construct_gitlab_label_provider_from_string() {
434 let repo = String::from("gitlab-org/gitlab");
435 let provider = GitLabLabelProvider::new(repo);
436 assert_eq!(provider.repo, "gitlab-org/gitlab");
437 }
438
439 #[test]
440 fn test_should_debug_format_label_provider() {
441 let provider = GitLabLabelProvider::new("owner/repo");
442 let debug = format!("{provider:?}");
443 assert!(debug.contains("GitLabLabelProvider"));
444 assert!(debug.contains("owner/repo"));
445 }
446
447 #[test]
448 fn test_should_clone_gitlab_label_provider() {
449 let original = GitLabLabelProvider::new("owner/repo");
450 let cloned = original.clone();
451 assert_eq!(original.repo, cloned.repo);
452 }
453
454 #[test]
457 fn test_should_deserialize_label_api_response() {
458 let json = br##"{
459 "name": "bug",
460 "color": "#d73a4a",
461 "description": "Something isn't working"
462 }"##;
463
464 let api: LabelApiResponse = serde_json::from_slice(json).expect("valid LabelApiResponse");
465 let label: LabelData = api.into();
466 assert_eq!(label.name, "bug");
467 assert_eq!(label.color.as_deref(), Some("#d73a4a"));
468 assert_eq!(
469 label.description.as_deref(),
470 Some("Something isn't working")
471 );
472 }
473
474 #[test]
475 fn test_should_deserialize_label_list() {
476 let json = br##"[
477 {"name": "bug", "color": "#d73a4a", "description": "Bug"},
478 {"name": "feature", "color": "#0075ca", "description": null}
479 ]"##;
480
481 let list: Vec<LabelApiResponse> = serde_json::from_slice(json).expect("valid label list");
482 assert_eq!(list.len(), 2);
483 assert_eq!(list[0].name, "bug");
484 assert_eq!(list[1].name, "feature");
485 }
486
487 #[test]
488 fn test_should_deserialize_empty_label_list() {
489 let json = b"[]";
490 let list: Vec<LabelApiResponse> = serde_json::from_slice(json).expect("valid empty list");
491 assert!(list.is_empty());
492 }
493
494 #[test]
497 fn test_should_construct_gitlab_milestone_provider() {
498 let provider = GitLabMilestoneProvider::new("gitlab-org/gitlab");
499 assert_eq!(provider.repo, "gitlab-org/gitlab");
500 }
501
502 #[test]
503 fn test_should_debug_format_milestone_provider() {
504 let provider = GitLabMilestoneProvider::new("owner/repo");
505 let debug = format!("{provider:?}");
506 assert!(debug.contains("GitLabMilestoneProvider"));
507 assert!(debug.contains("owner/repo"));
508 }
509
510 #[test]
511 fn test_should_clone_gitlab_milestone_provider() {
512 let original = GitLabMilestoneProvider::new("owner/repo");
513 let cloned = original.clone();
514 assert_eq!(original.repo, cloned.repo);
515 }
516
517 #[test]
520 fn test_should_deserialize_milestone_api_response() {
521 let json = br#"{
522 "id": 1,
523 "iid": 1,
524 "title": "v1.0 Release",
525 "description": "First stable release",
526 "state": "active",
527 "due_date": "2026-06-01",
528 "created_at": "2026-01-01T00:00:00Z",
529 "updated_at": "2026-01-01T00:00:00Z"
530 }"#;
531
532 let api: MilestoneApiResponse =
533 serde_json::from_slice(json).expect("valid MilestoneApiResponse");
534 let data: MilestoneData = api.into();
535
536 assert_eq!(data.number, 1);
537 assert_eq!(data.title, "v1.0 Release");
538 assert_eq!(data.description, Some("First stable release".into()));
539 assert_eq!(data.state, State::Open);
540 }
541
542 #[test]
543 fn test_should_deserialize_closed_milestone() {
544 let json = br#"{
545 "id": 2,
546 "iid": 2,
547 "title": "v0.9 Beta",
548 "description": null,
549 "state": "closed",
550 "due_date": null,
551 "created_at": "2026-01-01T00:00:00Z",
552 "updated_at": "2026-06-01T00:00:00Z"
553 }"#;
554
555 let api: MilestoneApiResponse =
556 serde_json::from_slice(json).expect("valid MilestoneApiResponse");
557 let data: MilestoneData = api.into();
558 assert_eq!(data.state, State::Closed);
559 assert!(data.description.is_none());
560 }
561
562 #[test]
563 fn test_should_deserialize_milestone_list() {
564 let json = br#"[
565 {"id": 1, "iid": 1, "title": "v1.0", "description": null, "state": "active", "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-01T00:00:00Z"},
566 {"id": 2, "iid": 2, "title": "v0.9", "description": "Beta", "state": "closed", "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-06-01T00:00:00Z"}
567 ]"#;
568
569 let milestones: Vec<MilestoneApiResponse> =
570 serde_json::from_slice(json).expect("valid MilestoneApiResponse list");
571 assert_eq!(milestones.len(), 2);
572 assert_eq!(milestones[0].title, "v1.0");
573 assert_eq!(milestones[1].title, "v0.9");
574 }
575}