Skip to main content

gitflow_gitcode/
label.rs

1//! GitCode Label 和 Milestone 提供者实现。
2//!
3//! 通过 `gc label` 和 `gc api` CLI 命令实现 [`LabelProvider`] 和
4//! [`MilestoneProvider`] trait,支持标签和里程碑的完整生命周期管理。
5
6use 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/// GitCode Label 提供者,通过 `gitcode` CLI 管理仓库标签。
22///
23/// # Examples
24///
25/// ```no_run
26/// use gitflow_gitcode::GitCodeLabelProvider;
27///
28/// let provider = GitCodeLabelProvider::new("octocat/hello-world");
29/// ```
30#[derive(Debug, Clone)]
31pub struct GitCodeLabelProvider {
32    /// GitCode `owner/repo`。
33    repo: String,
34}
35
36impl GitCodeLabelProvider {
37    /// 创建新的 GitCode Label 提供者。
38    ///
39    /// `repo` 格式为 `owner/repo`。
40    #[must_use]
41    pub fn new(repo: impl Into<String>) -> Self {
42        Self { repo: repo.into() }
43    }
44}
45
46/// `gc label list/create` 请求的 JSON 字段列表。
47const 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        // Try to parse JSON response, fallback to fetch if not available
135        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    /// 获取指定名称的标签数据(内部辅助方法)。
167    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/// GitCode 里程碑提供者,通过 `gc api` 管理仓库里程碑。
191///
192/// # Examples
193///
194/// ```no_run
195/// use gitflow_gitcode::GitCodeMilestoneProvider;
196///
197/// let provider = GitCodeMilestoneProvider::new("octocat/hello-world");
198/// ```
199#[derive(Debug, Clone)]
200pub struct GitCodeMilestoneProvider {
201    /// GitCode `owner/repo`。
202    repo: String,
203}
204
205impl GitCodeMilestoneProvider {
206    /// 创建新的 GitCode Milestone 提供者。
207    ///
208    /// `repo` 格式为 `owner/repo`。
209    #[must_use]
210    pub fn new(repo: impl Into<String>) -> Self {
211        Self { repo: repo.into() }
212    }
213}
214
215/// `gc api milestones` 返回的 JSON 结构。
216#[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    // --- GitCodeLabelProvider tests ---
402
403    #[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    // --- GitCodeMilestoneProvider tests ---
432
433    #[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    // --- LabelData deserialization tests ---
455
456    #[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    // --- MilestoneData deserialization tests ---
489
490    #[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}