github-rust 0.2.1

Rust library for GitHub API integration with GraphQL/REST support
Documentation
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;

/// URL-encode a path segment for safe use in GitHub API URLs.
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,
}

/// Maximum number of pages to fetch for starred repositories.
/// This limits total results to 10,000 repositories (100 pages * 100 per page).
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 {
        // Safety limit to prevent infinite loops or excessive API calls
        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); // GitHub max is 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,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json;

    #[test]
    fn test_stargazer_deserialization() {
        let json_data = r#"[
            {
                "starred_at": "2015-09-11T10:42:05Z",
                "user": {
                    "login": "testuser",
                    "id": 12345,
                    "node_id": "MDQ6VXNlcjEyMzQ1",
                    "avatar_url": "https://avatars.githubusercontent.com/u/12345?v=4",
                    "gravatar_id": "",
                    "url": "https://api.github.com/users/testuser",
                    "html_url": "https://github.com/testuser",
                    "followers_url": "https://api.github.com/users/testuser/followers",
                    "following_url": "https://api.github.com/users/testuser/following{/other_user}",
                    "gists_url": "https://api.github.com/users/testuser/gists{/gist_id}",
                    "starred_url": "https://api.github.com/users/testuser/starred{/owner}{/repo}",
                    "subscriptions_url": "https://api.github.com/users/testuser/subscriptions",
                    "organizations_url": "https://api.github.com/users/testuser/orgs",
                    "repos_url": "https://api.github.com/users/testuser/repos",
                    "events_url": "https://api.github.com/users/testuser/events{/privacy}",
                    "received_events_url": "https://api.github.com/users/testuser/received_events",
                    "type": "User",
                    "site_admin": false
                }
            }
        ]"#;

        let stargazers: Vec<StargazerWithDate> =
            serde_json::from_str(json_data).expect("Failed to deserialize stargazers");
        assert_eq!(stargazers.len(), 1);
        assert_eq!(stargazers[0].starred_at, "2015-09-11T10:42:05Z");
        assert_eq!(stargazers[0].user.login, "testuser");
        assert_eq!(stargazers[0].user.id, 12345);
        assert!(!stargazers[0].user.site_admin);
    }
}