use crate::error::*;
use crate::github::client::GitHubClient;
use crate::github::models::Repository;
use crate::github::types::*;
use percent_encoding::{NON_ALPHANUMERIC, utf8_percent_encode};
use serde::Deserialize;
fn encode_path_segment(segment: &str) -> String {
utf8_percent_encode(segment, NON_ALPHANUMERIC).to_string()
}
#[derive(Deserialize)]
struct RestRepository {
id: u64,
node_id: String,
name: String,
full_name: String,
description: Option<String>,
html_url: String,
homepage: Option<String>,
created_at: String,
updated_at: String,
pushed_at: Option<String>,
private: bool,
fork: bool,
archived: bool,
stargazers_count: u32,
forks_count: u32,
subscribers_count: Option<u32>,
language: Option<String>,
license: Option<RestLicense>,
default_branch: String,
topics: Vec<String>,
}
#[derive(Deserialize)]
struct RestLicense {
name: String,
spdx_id: Option<String>,
}
#[derive(Deserialize)]
struct LanguageStats {
#[serde(flatten)]
languages: std::collections::HashMap<String, u64>,
}
#[derive(Deserialize)]
pub struct UserProfile {
pub login: String,
pub name: Option<String>,
}
pub async fn get_repository_info(
client: &GitHubClient,
owner: &str,
name: &str,
) -> Result<Repository> {
let encoded_owner = encode_path_segment(owner);
let encoded_name = encode_path_segment(name);
let repo_url = format!(
"{}/repos/{}/{}",
client.rest_url(),
encoded_owner,
encoded_name
);
let response = client.get(&repo_url).send().await?;
let response = super::response::check(response)
.await
.map_err(|error| error.with_repository_context(owner, name))?;
let rest_repo: RestRepository = response.json().await?;
let languages_url = format!(
"{}/repos/{}/{}/languages",
client.rest_url(),
encoded_owner,
encoded_name
);
let lang_response = client.get(&languages_url).send().await?;
let language_stats: Option<LanguageStats> =
if lang_response.status() != reqwest::StatusCode::NOT_FOUND {
Some(super::response::check(lang_response).await?.json().await?)
} else {
tracing::debug!(status = %lang_response.status(), "Language breakdown unavailable");
None
};
Ok(convert_rest_repository(rest_repo, language_stats))
}
pub async fn get_user_profile(client: &GitHubClient) -> Result<UserProfile> {
let user_url = format!("{}/user", client.rest_url());
let response = client.get(&user_url).send().await?;
let response = super::response::check(response).await?;
let user_profile: UserProfile = response.json().await?;
Ok(user_profile)
}
#[derive(Deserialize)]
struct StarredRepository {
full_name: String,
}
const MAX_STARRED_PAGES: u32 = 100;
pub async fn get_user_starred_repositories(client: &GitHubClient) -> Result<Vec<String>> {
let mut all_starred = Vec::new();
let mut page = 1;
let per_page = 100;
loop {
if page > MAX_STARRED_PAGES {
return Err(GitHubError::PaginationError(
"Starred repositories exceed the 100-page safety limit".into(),
));
}
let starred_url = format!(
"{}/user/starred?per_page={}&page={}",
client.rest_url(),
per_page,
page
);
let response = client.get(&starred_url).send().await?;
let response = super::response::check(response).await?;
let starred_repos: Vec<StarredRepository> = response.json().await?;
if starred_repos.is_empty() {
break;
}
let repo_count = starred_repos.len();
all_starred.extend(starred_repos.into_iter().map(|repo| repo.full_name));
if repo_count < per_page {
break;
}
page += 1;
}
Ok(all_starred)
}
pub async fn get_repository_stargazers(
client: &GitHubClient,
owner: &str,
name: &str,
per_page: Option<u32>,
page: Option<u32>,
) -> Result<Vec<StargazerWithDate>> {
let per_page = per_page.unwrap_or(30).min(100); let page = page.unwrap_or(1);
if per_page == 0 || page == 0 {
return Err(GitHubError::InvalidInput(
"page and per_page must be greater than zero".into(),
));
}
let encoded_owner = encode_path_segment(owner);
let encoded_name = encode_path_segment(name);
let stargazers_url = format!(
"{}/repos/{}/{}/stargazers?per_page={}&page={}",
client.rest_url(),
encoded_owner,
encoded_name,
per_page,
page
);
let response = client
.get(&stargazers_url)
.headers(reqwest::header::HeaderMap::from_iter([(
reqwest::header::ACCEPT,
reqwest::header::HeaderValue::from_static("application/vnd.github.v3.star+json"),
)]))
.send()
.await?;
let response = super::response::check(response)
.await
.map_err(|error| error.with_repository_context(owner, name))?;
let stargazers: Vec<StargazerWithDate> = response.json().await?;
Ok(stargazers)
}
fn convert_rest_repository(rest: RestRepository, lang_stats: Option<LanguageStats>) -> Repository {
let languages_complete = lang_stats.is_some();
let languages = lang_stats.map(|stats| {
let mut languages: Vec<_> = stats
.languages
.into_iter()
.map(|(name, bytes)| crate::github::models::LanguageUsage {
language: Language { name, color: None },
bytes,
})
.collect();
languages.sort_by(|a, b| {
b.bytes
.cmp(&a.bytes)
.then_with(|| a.language.name.cmp(&b.language.name))
});
languages
});
Repository {
node_id: rest.node_id,
database_id: Some(rest.id),
name: rest.name,
name_with_owner: rest.full_name,
description: rest.description,
url: rest.html_url,
homepage_url: rest.homepage,
created_at: rest.created_at,
updated_at: rest.updated_at,
pushed_at: rest.pushed_at,
is_private: rest.private,
is_fork: rest.fork,
is_archived: rest.archived,
stargazer_count: rest.stargazers_count,
fork_count: rest.forks_count,
watcher_count: rest.subscribers_count,
open_issue_count: None,
pull_request_count: None,
release_count: None,
primary_language: rest.language.map(|name| Language { name, color: None }),
languages,
languages_complete,
license_info: rest.license.map(|l| License {
name: l.name,
spdx_id: l.spdx_id,
}),
default_branch: Some(rest.default_branch),
topics: rest.topics,
}
}