Skip to main content

gitflow_gitlab/
label.rs

1//! GitLab Label 和 Milestone 提供者实现。
2//!
3//! 通过 `glab label` 和 `glab milestone` 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_glab_error;
20
21/// GitLab Label 提供者,通过 `glab` CLI 管理仓库标签。
22///
23/// # Examples
24///
25/// ```no_run
26/// use gitflow_gitlab::GitLabLabelProvider;
27///
28/// let provider = GitLabLabelProvider::new("gitlab-org/gitlab");
29/// ```
30#[derive(Debug, Clone)]
31pub struct GitLabLabelProvider {
32    /// GitLab `namespace/project`。
33    repo: String,
34}
35
36impl GitLabLabelProvider {
37    /// 创建新的 GitLab Label 提供者。
38    ///
39    /// `repo` 格式为 `namespace/project`。
40    #[must_use]
41    pub fn new(repo: impl Into<String>) -> Self {
42        Self { repo: repo.into() }
43    }
44}
45
46/// `glab label --output json` 返回的 JSON 结构。
47#[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// ── Milestone Provider ──────────────────────────────────────────────
185
186/// GitLab 里程碑提供者,通过 `glab milestone` 管理仓库里程碑。
187///
188/// # Examples
189///
190/// ```no_run
191/// use gitflow_gitlab::GitLabMilestoneProvider;
192///
193/// let provider = GitLabMilestoneProvider::new("gitlab-org/gitlab");
194/// ```
195#[derive(Debug, Clone)]
196pub struct GitLabMilestoneProvider {
197    /// GitLab `namespace/project`。
198    repo: String,
199}
200
201impl GitLabMilestoneProvider {
202    /// 创建新的 GitLab Milestone 提供者。
203    ///
204    /// `repo` 格式为 `namespace/project`。
205    #[must_use]
206    pub fn new(repo: impl Into<String>) -> Self {
207        Self { repo: repo.into() }
208    }
209}
210
211/// `glab milestone --output json` 返回的 JSON 结构。
212#[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            // GitLab returns due_date as "YYYY-MM-DD" or ISO 8601
244            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    // --- GitLabLabelProvider tests ---
425
426    #[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    // --- LabelData deserialization tests ---
455
456    #[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    // --- GitLabMilestoneProvider tests ---
495
496    #[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    // --- MilestoneData deserialization tests ---
518
519    #[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}