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, Session,
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    /// Create a new provider from a shared [`Session`].
47    ///
48    /// This enables state reuse across multiple operations in workflow chains.
49    #[must_use]
50    pub fn with_session(session: &Session) -> Self {
51        Self {
52            repo: session.repo.clone(),
53        }
54    }
55}
56
57#[async_trait]
58impl ReviewProvider for GitCodeReviewProvider {
59    async fn comment(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
60        debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --comment`");
61
62        let output = tokio::process::Command::new(crate::gitcode_binary())
63            .args(["pr", "review"])
64            .arg(pr_number.to_string())
65            .arg("--comment")
66            .arg("--body")
67            .arg(body)
68            .arg("--repo")
69            .arg(&self.repo)
70            .arg("--json")
71            .arg(REVIEW_FIELDS)
72            .output()
73            .await
74            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
75
76        if !output.status.success() {
77            return Err(parse_gitcode_error(&output.stderr).into());
78        }
79
80        let review: ReviewData =
81            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
82
83        Ok(review)
84    }
85
86    async fn approve(&self, pr_number: u64, body: Option<&str>) -> Result<ReviewData> {
87        debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --approve`");
88
89        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
90        cmd.args(["pr", "review"])
91            .arg(pr_number.to_string())
92            .arg("--approve")
93            .arg("--repo")
94            .arg(&self.repo)
95            .arg("--json")
96            .arg(REVIEW_FIELDS);
97
98        if let Some(b) = body {
99            cmd.arg("--body").arg(b);
100        }
101
102        let output = cmd
103            .output()
104            .await
105            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
106
107        if !output.status.success() {
108            return Err(parse_gitcode_error(&output.stderr).into());
109        }
110
111        let review: ReviewData =
112            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
113
114        Ok(review)
115    }
116
117    async fn request_changes(&self, pr_number: u64, body: &str) -> Result<ReviewData> {
118        debug!(repo = %self.repo, number = pr_number, "spawning `gc pr review --request-changes`");
119
120        let output = tokio::process::Command::new(crate::gitcode_binary())
121            .args(["pr", "review"])
122            .arg(pr_number.to_string())
123            .arg("--request-changes")
124            .arg("--body")
125            .arg(body)
126            .arg("--repo")
127            .arg(&self.repo)
128            .arg("--json")
129            .arg(REVIEW_FIELDS)
130            .output()
131            .await
132            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
133
134        if !output.status.success() {
135            return Err(parse_gitcode_error(&output.stderr).into());
136        }
137
138        let review: ReviewData =
139            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
140
141        Ok(review)
142    }
143
144    async fn submit_review(
145        &self,
146        pr_number: u64,
147        event: ReviewState,
148        body: Option<&str>,
149    ) -> Result<ReviewData> {
150        debug!(repo = %self.repo, number = pr_number, ?event, "spawning `gc pr review`");
151
152        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
153        cmd.args(["pr", "review"])
154            .arg(pr_number.to_string())
155            .arg("--repo")
156            .arg(&self.repo)
157            .arg("--json")
158            .arg(REVIEW_FIELDS);
159
160        match event {
161            ReviewState::Approved => {
162                cmd.arg("--approve");
163            }
164            ReviewState::ChangesRequested => {
165                cmd.arg("--request-changes");
166            }
167            ReviewState::Commented => {
168                cmd.arg("--comment");
169            }
170        }
171
172        if let Some(b) = body {
173            cmd.arg("--body").arg(b);
174        }
175
176        let output = cmd
177            .output()
178            .await
179            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode: {e}")))?;
180
181        if !output.status.success() {
182            return Err(parse_gitcode_error(&output.stderr).into());
183        }
184
185        let review: ReviewData =
186            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
187
188        Ok(review)
189    }
190}
191
192#[cfg(test)]
193mod tests {
194    use super::*;
195
196    #[test]
197    fn test_should_construct_gitcode_review_provider() {
198        let provider = GitCodeReviewProvider::new("octocat/hello-world");
199        assert_eq!(provider.repo, "octocat/hello-world");
200    }
201
202    #[test]
203    fn test_should_construct_gitcode_review_provider_from_string() {
204        let repo = String::from("octocat/hello-world");
205        let provider = GitCodeReviewProvider::new(repo);
206        assert_eq!(provider.repo, "octocat/hello-world");
207    }
208
209    #[test]
210    fn test_should_deserialize_review_data_from_gc_output() {
211        let gc_json = br#"{
212            "id": 2001,
213            "state": "approved",
214            "body": "Looks great, LGTM!",
215            "author": {"login": "reviewer", "id": "42"},
216            "submittedAt": "2026-05-20T14:30:00Z"
217        }"#;
218
219        let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData JSON");
220        assert_eq!(review.id, 2001);
221        assert_eq!(review.state, ReviewState::Approved);
222        assert_eq!(review.body.as_deref(), Some("Looks great, LGTM!"));
223        assert_eq!(review.author.login, "reviewer");
224        assert_eq!(review.author.id, "42");
225    }
226
227    #[test]
228    fn test_should_deserialize_changes_requested_review_from_gc_output() {
229        let gc_json = br#"{
230            "id": 2002,
231            "state": "changes_requested",
232            "body": "Please fix the error handling",
233            "author": {"login": "senior-dev", "id": "7"},
234            "submittedAt": "2026-05-21T09:00:00Z"
235        }"#;
236
237        let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData");
238        assert_eq!(review.state, ReviewState::ChangesRequested);
239        assert_eq!(
240            review.body.as_deref(),
241            Some("Please fix the error handling")
242        );
243    }
244
245    #[test]
246    fn test_should_deserialize_commented_review_from_gc_output() {
247        let gc_json = br#"{
248            "id": 2003,
249            "state": "commented",
250            "body": null,
251            "author": {"login": "observer", "id": "15"},
252            "submittedAt": "2026-05-22T11:00:00Z"
253        }"#;
254
255        let review: ReviewData = serde_json::from_slice(gc_json).expect("valid ReviewData");
256        assert_eq!(review.state, ReviewState::Commented);
257        assert!(review.body.is_none());
258    }
259
260    #[test]
261    fn test_should_debug_format_provider() {
262        let provider = GitCodeReviewProvider::new("octocat/hello-world");
263        let debug = format!("{provider:?}");
264        assert!(debug.contains("GitCodeReviewProvider"));
265        assert!(debug.contains("octocat/hello-world"));
266    }
267
268    #[test]
269    fn test_should_create_provider_with_different_repos() {
270        let r1 = GitCodeReviewProvider::new("org/repo-a");
271        let r2 = GitCodeReviewProvider::new("org/repo-b");
272        assert_eq!(r1.repo, "org/repo-a");
273        assert_eq!(r2.repo, "org/repo-b");
274    }
275
276    #[test]
277    fn test_should_clone_gitcode_review_provider() {
278        let original = GitCodeReviewProvider::new("owner/repo");
279        let cloned = original.clone();
280        assert_eq!(original.repo, cloned.repo);
281    }
282}