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