Skip to main content

gitflow_gitcode/
review.rs

1//! GitCode Review 提供者实现。
2//!
3//! 通过 `gitcode` CLI 实现 [`ReviewProvider`] trait,支持 PR 审查的评论、
4//! 批准、要求修改及提交审查。
5//! 所有方法通过 `tokio::process::Command` 调用 `gc`,捕获 stdout 并解析 JSON。
6
7use async_trait::async_trait;
8use gitflow_core::{
9    CoreError, Result,
10    review::{ReviewData, ReviewProvider, ReviewState},
11};
12use tracing::debug;
13
14use crate::error::parse_gitcode_error;
15
16/// `gc pr review` 请求的 JSON 字段列表。
17const REVIEW_FIELDS: &str = "id,state,body,author,submittedAt";
18
19/// GitCode Review 提供者,通过 `gitcode` CLI 操作。
20///
21/// 该结构体通过调用 `gitcode` CLI 实现 [`ReviewProvider`] trait 的所有方法,
22/// 使上层命令能够以统一的方式操作 GitCode PR 审查。
23///
24/// # Examples
25///
26/// ```no_run
27/// use gitflow_gitcode::GitCodeReviewProvider;
28///
29/// let provider = GitCodeReviewProvider::new("octocat/hello-world");
30/// ```
31#[derive(Debug, Clone)]
32pub struct GitCodeReviewProvider {
33    /// GitCode `owner/repo`,如 `"byx-darwin/gitflow-cli"`。
34    repo: String,
35}
36
37impl GitCodeReviewProvider {
38    /// 创建新的 GitCode Review 提供者。
39    ///
40    /// `repo` 格式为 `owner/repo`。
41    #[must_use]
42    pub fn new(repo: impl Into<String>) -> Self {
43        Self { repo: repo.into() }
44    }
45}
46
47#[async_trait]
48impl ReviewProvider for GitCodeReviewProvider {
49    async fn comment(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
50        debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --comment`");
51
52        let output = tokio::process::Command::new(crate::gitcode_binary())
53            .args(["pr", "review"])
54            .arg(pr_number.to_string())
55            .arg("--comment")
56            .arg("--body")
57            .arg(body)
58            .arg("--repo")
59            .arg(&self.repo)
60            .arg("--json")
61            .arg(REVIEW_FIELDS)
62            .output()
63            .await
64            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
65
66        if !output.status.success() {
67            return Err(parse_gitcode_error(&output.stderr).into());
68        }
69
70        let review: ReviewData =
71            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
72
73        Ok(review)
74    }
75
76    async fn approve(&self, pr_number: u64, body: Option<&str>) -> Result<ReviewData> {
77        debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --approve`");
78
79        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
80        cmd.args(["pr", "review"])
81            .arg(pr_number.to_string())
82            .arg("--approve")
83            .arg("--repo")
84            .arg(&self.repo)
85            .arg("--json")
86            .arg(REVIEW_FIELDS);
87
88        if let Some(b) = body {
89            cmd.arg("--body").arg(b);
90        }
91
92        let output = cmd
93            .output()
94            .await
95            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
96
97        if !output.status.success() {
98            return Err(parse_gitcode_error(&output.stderr).into());
99        }
100
101        let review: ReviewData =
102            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
103
104        Ok(review)
105    }
106
107    async fn request_changes(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
108        debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --request-changes`");
109
110        let output = tokio::process::Command::new(crate::gitcode_binary())
111            .args(["pr", "review"])
112            .arg(pr_number.to_string())
113            .arg("--request-changes")
114            .arg("--body")
115            .arg(body)
116            .arg("--repo")
117            .arg(&self.repo)
118            .arg("--json")
119            .arg(REVIEW_FIELDS)
120            .output()
121            .await
122            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
123
124        if !output.status.success() {
125            return Err(parse_gitcode_error(&output.stderr).into());
126        }
127
128        let review: ReviewData =
129            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
130
131        Ok(review)
132    }
133
134    async fn submit_review(
135        &self,
136        pr_number: u64,
137        event: ReviewState,
138        body: Option<&str>,
139    ) -> Result<ReviewData> {
140        debug!(repo = %self.repo, number = pr_number, ?event, "spawning `gc pr review`");
141
142        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
143        cmd.args(["pr", "review"])
144            .arg(pr_number.to_string())
145            .arg("--repo")
146            .arg(&self.repo)
147            .arg("--json")
148            .arg(REVIEW_FIELDS);
149
150        match event {
151            ReviewState::Approved => {
152                cmd.arg("--approve");
153            }
154            ReviewState::ChangesRequested => {
155                cmd.arg("--request-changes");
156            }
157            ReviewState::Commented => {
158                cmd.arg("--comment");
159            }
160        }
161
162        if let Some(b) = body {
163            cmd.arg("--body").arg(b);
164        }
165
166        let output = cmd
167            .output()
168            .await
169            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
170
171        if !output.status.success() {
172            return Err(parse_gitcode_error(&output.stderr).into());
173        }
174
175        let review: ReviewData =
176            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
177
178        Ok(review)
179    }
180}
181
182#[cfg(test)]
183mod tests {
184    use super::*;
185
186    #[test]
187    fn test_should_construct_gitcode_review_provider() {
188        let provider = GitCodeReviewProvider::new("octocat/hello-world");
189        assert_eq!(provider.repo, "octocat/hello-world");
190    }
191
192    #[test]
193    fn test_should_construct_gitcode_review_provider_from_string() {
194        let repo = String::from("octocat/hello-world");
195        let provider = GitCodeReviewProvider::new(repo);
196        assert_eq!(provider.repo, "octocat/hello-world");
197    }
198
199    #[test]
200    fn test_should_deserialize_review_data_from_gc_output() {
201        let gc_json = br#"{
202            "id": 2001,
203            "state": "approved",
204            "body": "Looks great, LGTM!",
205            "author": {"login": "reviewer", "id": "42"},
206            "submittedAt": "2026-05-20T14:30:00Z"
207        }"#;
208
209        let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData JSON");
210        assert_eq!(review.id, 2001);
211        assert_eq!(review.state, ReviewState::Approved);
212        assert_eq!(review.body.as_deref(), Some("Looks great, LGTM!"));
213        assert_eq!(review.author.login, "reviewer");
214        assert_eq!(review.author.id, "42");
215    }
216
217    #[test]
218    fn test_should_deserialize_changes_requested_review_from_gc_output() {
219        let gc_json = br#"{
220            "id": 2002,
221            "state": "changes_requested",
222            "body": "Please fix the error handling",
223            "author": {"login": "senior-dev", "id": "7"},
224            "submittedAt": "2026-05-21T09:00:00Z"
225        }"#;
226
227        let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData");
228        assert_eq!(review.state, ReviewState::ChangesRequested);
229        assert_eq!(
230            review.body.as_deref(),
231            Some("Please fix the error handling")
232        );
233    }
234
235    #[test]
236    fn test_should_deserialize_commented_review_from_gc_output() {
237        let gc_json = br#"{
238            "id": 2003,
239            "state": "commented",
240            "body": null,
241            "author": {"login": "observer", "id": "15"},
242            "submittedAt": "2026-05-22T11:00:00Z"
243        }"#;
244
245        let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData");
246        assert_eq!(review.state, ReviewState::Commented);
247        assert!(review.body.is_none());
248    }
249
250    #[test]
251    fn test_should_debug_format_provider() {
252        let provider = GitCodeReviewProvider::new("octocat/hello-world");
253        let debug = format!("{provider:?}");
254        assert!(debug.contains("GitCodeReviewProvider"));
255        assert!(debug.contains("octocat/hello-world"));
256    }
257
258    #[test]
259    fn test_should_create_provider_with_different_repos() {
260        let r1 = GitCodeReviewProvider::new("org/repo-a");
261        let r2 = GitCodeReviewProvider::new("org/repo-b");
262        assert_eq!(r1.repo, "org/repo-a");
263        assert_eq!(r2.repo, "org/repo-b");
264    }
265
266    #[test]
267    fn test_should_clone_gitcode_review_provider() {
268        let original = GitCodeReviewProvider::new("owner/repo");
269        let cloned = original.clone();
270        assert_eq!(original.repo, cloned.repo);
271    }
272}