ferrous_forge/rust_version/
github.rs

1//! GitHub API client for fetching Rust releases
2
3use crate::{Error, Result};
4use chrono::{DateTime, Utc};
5use reqwest::Client;
6use semver::Version;
7use serde::{Deserialize, Serialize};
8
9const GITHUB_API_BASE: &str = "https://api.github.com";
10const RUST_REPO_OWNER: &str = "rust-lang";
11const RUST_REPO_NAME: &str = "rust";
12
13/// Default version for deserialization
14fn default_version() -> Version {
15    Version::new(0, 0, 0)
16}
17
18/// GitHub release information
19#[derive(Debug, Clone, Serialize, Deserialize)]
20pub struct GitHubRelease {
21    /// Release ID
22    pub id: u64,
23    /// Tag name (e.g., "1.90.0")
24    pub tag_name: String,
25    /// Release name
26    pub name: String,
27    /// Release description/notes
28    pub body: String,
29    /// Is this a draft?
30    pub draft: bool,
31    /// Is this a prerelease?
32    pub prerelease: bool,
33    /// Creation date
34    pub created_at: DateTime<Utc>,
35    /// Publication date
36    pub published_at: Option<DateTime<Utc>>,
37    /// HTML URL to the release page
38    pub html_url: String,
39    /// Parsed semantic version
40    #[serde(skip, default = "default_version")]
41    pub version: Version,
42}
43
44/// Simplified author information
45#[derive(Debug, Clone, Serialize, Deserialize)]
46pub struct Author {
47    /// GitHub username
48    pub login: String,
49    /// GitHub user ID
50    pub id: u64,
51}
52
53/// GitHub API client
54pub struct GitHubClient {
55    client: Client,
56    auth_token: Option<String>,
57}
58
59impl GitHubClient {
60    /// Create a new GitHub client
61    pub fn new(auth_token: Option<String>) -> Result<Self> {
62        let client = Client::builder()
63            .timeout(std::time::Duration::from_secs(30))
64            .user_agent(format!("ferrous-forge/{}", env!("CARGO_PKG_VERSION")))
65            .build()
66            .map_err(|e| Error::network(format!("Failed to create HTTP client: {}", e)))?;
67
68        Ok(Self { client, auth_token })
69    }
70
71    /// Get the latest stable release
72    pub async fn get_latest_release(&self) -> Result<GitHubRelease> {
73        let url = format!(
74            "{}/repos/{}/{}/releases/latest",
75            GITHUB_API_BASE, RUST_REPO_OWNER, RUST_REPO_NAME
76        );
77
78        let response = self.make_github_request(&url).await?;
79        self.check_response_status(&response)?;
80
81        let mut release: GitHubRelease = response
82            .json()
83            .await
84            .map_err(|e| Error::parse(format!("Failed to parse release JSON: {}", e)))?;
85
86        // Parse version from tag
87        release.version = self.parse_version_from_tag(&release.tag_name)?;
88
89        Ok(release)
90    }
91
92    /// Make a GitHub API request with authentication
93    async fn make_github_request(&self, url: &str) -> Result<reqwest::Response> {
94        let mut request = self
95            .client
96            .get(url)
97            .header("Accept", "application/vnd.github.v3+json");
98
99        if let Some(token) = &self.auth_token {
100            request = request.header("Authorization", format!("token {}", token));
101        }
102
103        request
104            .send()
105            .await
106            .map_err(|e| Error::network(format!("Failed to fetch from GitHub: {}", e)))
107    }
108
109    /// Check response status and handle rate limiting
110    fn check_response_status(&self, response: &reqwest::Response) -> Result<()> {
111        if response.status() == 429 {
112            let retry_after = response
113                .headers()
114                .get("X-RateLimit-Reset")
115                .and_then(|v| v.to_str().ok())
116                .and_then(|s| s.parse::<u64>().ok())
117                .unwrap_or(60);
118
119            return Err(Error::rate_limited(retry_after));
120        }
121
122        if !response.status().is_success() {
123            return Err(Error::network(format!(
124                "GitHub API returned status: {}",
125                response.status()
126            )));
127        }
128
129        Ok(())
130    }
131
132    /// Get multiple recent releases
133    pub async fn get_releases(&self, count: usize) -> Result<Vec<GitHubRelease>> {
134        let url = format!(
135            "{}/repos/{}/{}/releases?per_page={}",
136            GITHUB_API_BASE, RUST_REPO_OWNER, RUST_REPO_NAME, count
137        );
138
139        let response = self.make_github_request(&url).await?;
140        self.check_response_status(&response)?;
141
142        let mut releases: Vec<GitHubRelease> = response
143            .json()
144            .await
145            .map_err(|e| Error::parse(format!("Failed to parse releases JSON: {}", e)))?;
146
147        // Parse versions for all releases
148        for release in &mut releases {
149            release.version = self.parse_version_from_tag(&release.tag_name)?;
150        }
151
152        // Filter out pre-releases from stable channel
153        Ok(releases.into_iter().filter(|r| !r.prerelease).collect())
154    }
155
156    /// Parse semantic version from tag name
157    fn parse_version_from_tag(&self, tag: &str) -> Result<Version> {
158        let version_str = tag.strip_prefix('v').unwrap_or(tag);
159        Version::parse(version_str)
160            .map_err(|e| Error::parse(format!("Failed to parse version '{}': {}", tag, e)))
161    }
162}
163
164#[cfg(test)]
165#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
166mod tests {
167    use super::*;
168
169    #[test]
170    fn test_parse_version_from_tag() {
171        let client = GitHubClient::new(None).unwrap();
172
173        assert_eq!(
174            client.parse_version_from_tag("1.90.0").unwrap(),
175            Version::new(1, 90, 0)
176        );
177
178        assert_eq!(
179            client.parse_version_from_tag("v1.90.0").unwrap(),
180            Version::new(1, 90, 0)
181        );
182    }
183
184    #[tokio::test]
185    #[ignore] // Requires network access
186    async fn test_get_latest_release() -> Result<()> {
187        let client = GitHubClient::new(None)?;
188        let release = client.get_latest_release().await?;
189
190        assert!(!release.tag_name.is_empty());
191        assert!(release.version.major >= 1);
192        Ok(())
193    }
194}
ferrous_forge/rust_version/github.rs

ferrous_forge/rust_version/
github.rs
