1use crate::error::*;
2use crate::github::client::GitHubClient;
3use crate::github::models::Repository;
4use crate::github::types::*;
5use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
6use serde::Deserialize;
7
8fn encode_path_segment(segment: &str) -> String {
10 utf8_percent_encode(segment, NON_ALPHANUMERIC).to_string()
11}
12
13#[derive(Deserialize)]
14struct RestRepository {
15 id: u64,
16 node_id: String,
17 name: String,
18 full_name: String,
19 description: Option<String>,
20 html_url: String,
21 homepage: Option<String>,
22 created_at: String,
23 updated_at: String,
24 pushed_at: Option<String>,
25 private: bool,
26 fork: bool,
27 archived: bool,
28 stargazers_count: u32,
29 forks_count: u32,
30 subscribers_count: Option<u32>,
31 language: Option<String>,
32 license: Option<RestLicense>,
33 default_branch: String,
34 topics: Vec<String>,
35}
36
37#[derive(Deserialize)]
38struct RestLicense {
39 name: String,
40 spdx_id: Option<String>,
41}
42
43#[derive(Deserialize)]
44struct LanguageStats {
45 #[serde(flatten)]
46 languages: std::collections::HashMap<String, u64>,
47}
48
49#[derive(Deserialize)]
50pub struct UserProfile {
51 pub login: String,
52 pub name: Option<String>,
53}
54
55pub async fn get_repository_info(
56 client: &GitHubClient,
57 owner: &str,
58 name: &str,
59) -> Result<Repository> {
60 let encoded_owner = encode_path_segment(owner);
61 let encoded_name = encode_path_segment(name);
62 let repo_url = format!(
63 "{}/repos/{}/{}",
64 client.rest_url(),
65 encoded_owner,
66 encoded_name
67 );
68
69 let response = client.get(&repo_url).send().await?;
70
71 let response = super::response::check(response)
72 .await
73 .map_err(|error| error.with_repository_context(owner, name))?;
74
75 let rest_repo: RestRepository = response.json().await?;
76
77 let languages_url = format!(
78 "{}/repos/{}/{}/languages",
79 client.rest_url(),
80 encoded_owner,
81 encoded_name
82 );
83 let lang_response = client.get(&languages_url).send().await?;
84 let language_stats: Option<LanguageStats> =
85 if lang_response.status() != reqwest::StatusCode::NOT_FOUND {
86 Some(super::response::check(lang_response).await?.json().await?)
87 } else {
88 tracing::debug!(status = %lang_response.status(), "Language breakdown unavailable");
89 None
90 };
91
92 Ok(convert_rest_repository(rest_repo, language_stats))
93}
94
95pub async fn get_user_profile(client: &GitHubClient) -> Result<UserProfile> {
96 let user_url = format!("{}/user", client.rest_url());
97
98 let response = client.get(&user_url).send().await?;
99
100 let response = super::response::check(response).await?;
101
102 let user_profile: UserProfile = response.json().await?;
103 Ok(user_profile)
104}
105
106#[derive(Deserialize)]
107struct StarredRepository {
108 full_name: String,
109}
110
111const MAX_STARRED_PAGES: u32 = 100;
114
115pub async fn get_user_starred_repositories(client: &GitHubClient) -> Result<Vec<String>> {
116 let mut all_starred = Vec::new();
117 let mut page = 1;
118 let per_page = 100;
119
120 loop {
121 if page > MAX_STARRED_PAGES {
123 return Err(GitHubError::PaginationError(
124 "Starred repositories exceed the 100-page safety limit".into(),
125 ));
126 }
127 let starred_url = format!(
128 "{}/user/starred?per_page={}&page={}",
129 client.rest_url(),
130 per_page,
131 page
132 );
133
134 let response = client.get(&starred_url).send().await?;
135
136 let response = super::response::check(response).await?;
137
138 let starred_repos: Vec<StarredRepository> = response.json().await?;
139
140 if starred_repos.is_empty() {
141 break;
142 }
143
144 let repo_count = starred_repos.len();
145 all_starred.extend(starred_repos.into_iter().map(|repo| repo.full_name));
146
147 if repo_count < per_page {
148 break;
149 }
150
151 page += 1;
152 }
153
154 Ok(all_starred)
155}
156
157pub async fn get_repository_stargazers(
158 client: &GitHubClient,
159 owner: &str,
160 name: &str,
161 per_page: Option<u32>,
162 page: Option<u32>,
163) -> Result<Vec<StargazerWithDate>> {
164 let per_page = per_page.unwrap_or(30).min(100); let page = page.unwrap_or(1);
166 if per_page == 0 || page == 0 {
167 return Err(GitHubError::InvalidInput(
168 "page and per_page must be greater than zero".into(),
169 ));
170 }
171
172 let encoded_owner = encode_path_segment(owner);
173 let encoded_name = encode_path_segment(name);
174 let stargazers_url = format!(
175 "{}/repos/{}/{}/stargazers?per_page={}&page={}",
176 client.rest_url(),
177 encoded_owner,
178 encoded_name,
179 per_page,
180 page
181 );
182
183 let response = client
184 .get(&stargazers_url)
185 .headers(reqwest::header::HeaderMap::from_iter([(
186 reqwest::header::ACCEPT,
187 reqwest::header::HeaderValue::from_static("application/vnd.github.v3.star+json"),
188 )]))
189 .send()
190 .await?;
191
192 let response = super::response::check(response)
193 .await
194 .map_err(|error| error.with_repository_context(owner, name))?;
195
196 let stargazers: Vec<StargazerWithDate> = response.json().await?;
197 Ok(stargazers)
198}
199
200fn convert_rest_repository(rest: RestRepository, lang_stats: Option<LanguageStats>) -> Repository {
201 let languages_complete = lang_stats.is_some();
202 let languages = lang_stats.map(|stats| {
203 let mut languages: Vec<_> = stats
204 .languages
205 .into_iter()
206 .map(|(name, bytes)| crate::github::models::LanguageUsage {
207 language: Language { name, color: None },
208 bytes,
209 })
210 .collect();
211 languages.sort_by(|a, b| {
212 b.bytes
213 .cmp(&a.bytes)
214 .then_with(|| a.language.name.cmp(&b.language.name))
215 });
216 languages
217 });
218 Repository {
219 node_id: rest.node_id,
220 database_id: Some(rest.id),
221 name: rest.name,
222 name_with_owner: rest.full_name,
223 description: rest.description,
224 url: rest.html_url,
225 homepage_url: rest.homepage,
226 created_at: rest.created_at,
227 updated_at: rest.updated_at,
228 pushed_at: rest.pushed_at,
229 is_private: rest.private,
230 is_fork: rest.fork,
231 is_archived: rest.archived,
232 stargazer_count: rest.stargazers_count,
233 fork_count: rest.forks_count,
234 watcher_count: rest.subscribers_count,
235 open_issue_count: None,
236 pull_request_count: None,
237 release_count: None,
238 primary_language: rest.language.map(|name| Language { name, color: None }),
239 languages,
240 languages_complete,
241 license_info: rest.license.map(|l| License {
242 name: l.name,
243 spdx_id: l.spdx_id,
244 }),
245 default_branch: Some(rest.default_branch),
246 topics: rest.topics,
247 }
248}
249
250#[cfg(test)]
251mod tests {
252 use super::*;
253 use serde_json;
254
255 #[test]
256 fn test_stargazer_deserialization() {
257 let json_data = r#"[
258 {
259 "starred_at": "2015-09-11T10:42:05Z",
260 "user": {
261 "login": "testuser",
262 "id": 12345,
263 "node_id": "MDQ6VXNlcjEyMzQ1",
264 "avatar_url": "https://avatars.githubusercontent.com/u/12345?v=4",
265 "gravatar_id": "",
266 "url": "https://api.github.com/users/testuser",
267 "html_url": "https://github.com/testuser",
268 "followers_url": "https://api.github.com/users/testuser/followers",
269 "following_url": "https://api.github.com/users/testuser/following{/other_user}",
270 "gists_url": "https://api.github.com/users/testuser/gists{/gist_id}",
271 "starred_url": "https://api.github.com/users/testuser/starred{/owner}{/repo}",
272 "subscriptions_url": "https://api.github.com/users/testuser/subscriptions",
273 "organizations_url": "https://api.github.com/users/testuser/orgs",
274 "repos_url": "https://api.github.com/users/testuser/repos",
275 "events_url": "https://api.github.com/users/testuser/events{/privacy}",
276 "received_events_url": "https://api.github.com/users/testuser/received_events",
277 "type": "User",
278 "site_admin": false
279 }
280 }
281 ]"#;
282
283 let stargazers: Vec<StargazerWithDate> =
284 serde_json::from_str(json_data).expect("Failed to deserialize stargazers");
285 assert_eq!(stargazers.len(), 1);
286 assert_eq!(stargazers[0].starred_at, "2015-09-11T10:42:05Z");
287 assert_eq!(stargazers[0].user.login, "testuser");
288 assert_eq!(stargazers[0].user.id, 12345);
289 assert!(!stargazers[0].user.site_admin);
290 }
291}