@mbe24/99problems 0.2.0 → 0.3.1

package/src/source/github/api.rs

@@ -0,0 +1,128 @@
+use anyhow::Result;
+use reqwest::blocking::{RequestBuilder, Response};
+use serde::Deserialize;
+use tracing::{debug, trace};
+
+use super::model::{
+    ConversationSeed, IssueCommentItem, ReviewCommentItem, map_issue_comment, map_review_comment,
+};
+use super::{GITHUB_API_BASE, GITHUB_API_VERSION, GitHubSource, PAGE_SIZE};
+use crate::error::{AppError, app_error_from_decode, app_error_from_reqwest};
+use crate::model::{Comment, Conversation};
+use crate::source::FetchRequest;
+
+impl GitHubSource {
+    pub(super) fn apply_auth(req: RequestBuilder, token: Option<&str>) -> RequestBuilder {
+        match token {
+            Some(t) => req
+                .header("Authorization", format!("Bearer {t}"))
+                .header("X-GitHub-Api-Version", GITHUB_API_VERSION),
+            None => req,
+        }
+    }
+
+    pub(super) fn bounded_per_page(per_page: u32) -> u32 {
+        per_page.clamp(1, PAGE_SIZE)
+    }
+
+    pub(super) fn send(req: RequestBuilder, operation: &str) -> Result<Response> {
+        req.send()
+            .map_err(|err| app_error_from_reqwest("GitHub", operation, &err).into())
+    }
+
+    pub(super) fn get_pages<T: for<'de> Deserialize<'de>>(
+        &self,
+        url: &str,
+        token: Option<&str>,
+        per_page: u32,
+    ) -> Result<Vec<T>> {
+        let mut results = vec![];
+        let mut page = 1u32;
+        let per_page = Self::bounded_per_page(per_page);
+
+        loop {
+            debug!(url = %url, page, per_page, "fetching GitHub page");
+            let req = self.client.get(url).query(&[
+                ("per_page", per_page.to_string()),
+                ("page", page.to_string()),
+            ]);
+            let req = Self::apply_auth(req, token);
+            let resp = Self::send(req, "page fetch")?;
+
+            if !resp.status().is_success() {
+                let status = resp.status();
+                let body = resp
+                    .text()
+                    .map_err(|err| app_error_from_reqwest("GitHub", "error body read", &err))?;
+                return Err(AppError::from_http("GitHub", "page fetch", status, &body).into());
+            }
+
+            let has_next = resp
+                .headers()
+                .get("link")
+                .and_then(|v| v.to_str().ok())
+                .is_some_and(|l| l.contains(r#"rel="next""#));
+
+            let items: Vec<T> = resp
+                .json()
+                .map_err(|err| app_error_from_decode("GitHub", "page fetch", err))?;
+            trace!(count = items.len(), page, "decoded GitHub page");
+            let done = items.is_empty() || !has_next;
+            results.extend(items);
+            if done {
+                break;
+            }
+            page += 1;
+        }
+
+        Ok(results)
+    }
+
+    pub(super) fn fetch_issue_comments(
+        &self,
+        repo: &str,
+        id: u64,
+        req: &FetchRequest,
+    ) -> Result<Vec<Comment>> {
+        let comments_url = format!("{GITHUB_API_BASE}/repos/{repo}/issues/{id}/comments");
+        let raw_comments: Vec<IssueCommentItem> =
+            self.get_pages(&comments_url, req.token.as_deref(), req.per_page)?;
+        Ok(raw_comments.into_iter().map(map_issue_comment).collect())
+    }
+
+    pub(super) fn fetch_review_comments(
+        &self,
+        repo: &str,
+        id: u64,
+        req: &FetchRequest,
+    ) -> Result<Vec<Comment>> {
+        let comments_url = format!("{GITHUB_API_BASE}/repos/{repo}/pulls/{id}/comments");
+        let raw_comments: Vec<ReviewCommentItem> =
+            self.get_pages(&comments_url, req.token.as_deref(), req.per_page)?;
+        Ok(raw_comments.into_iter().map(map_review_comment).collect())
+    }
+
+    pub(super) fn fetch_conversation(
+        &self,
+        repo: &str,
+        item: ConversationSeed,
+        req: &FetchRequest,
+    ) -> Result<Conversation> {
+        let mut comments = Vec::new();
+        if req.include_comments {
+            comments = self.fetch_issue_comments(repo, item.id, req)?;
+            if item.is_pr && req.include_review_comments {
+                comments.extend(self.fetch_review_comments(repo, item.id, req)?);
+                comments.sort_by(|a, b| a.created_at.cmp(&b.created_at));
+            }
+        }
+
+        Ok(Conversation {
+            id: item.id.to_string(),
+            title: item.title,
+            state: item.state,
+            body: item.body,
+            comments,
+        })
+    }
+}

package/src/source/github/mod.rs

@@ -0,0 +1,191 @@
+use anyhow::Result;
+use reqwest::blocking::Client;
+use tracing::{debug, trace, warn};
+
+use super::{ContentKind, FetchRequest, FetchTarget, Source};
+use crate::error::{AppError, app_error_from_decode, app_error_from_reqwest};
+use crate::model::Conversation;
+
+mod api;
+mod model;
+mod query;
+
+use model::{ConversationSeed, IssueItem, SearchResponse};
+use query::{extract_repo, repo_from_repository_url};
+
+pub(super) const GITHUB_API_BASE: &str = "https://api.github.com";
+pub(super) const GITHUB_API_VERSION: &str = "2022-11-28";
+pub(super) const PAGE_SIZE: u32 = 100;
+
+pub struct GitHubSource {
+    client: Client,
+}
+
+impl GitHubSource {
+    /// Create a GitHub source client.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if the HTTP client cannot be constructed.
+    pub fn new() -> Result<Self> {
+        let client = Client::builder()
+            .user_agent(concat!("99problems-cli/", env!("CARGO_PKG_VERSION")))
+            .build()?;
+        Ok(Self { client })
+    }
+
+    fn search_stream(
+        &self,
+        req: &FetchRequest,
+        raw_query: &str,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let search_url = format!("{GITHUB_API_BASE}/search/issues");
+        let mut page = 1u32;
+        let mut emitted = 0usize;
+        let per_page = Self::bounded_per_page(req.per_page);
+        let repo_from_query = extract_repo(raw_query);
+
+        loop {
+            debug!(page, per_page, "fetching GitHub search page");
+            let req_http = self.client.get(&search_url).query(&[
+                ("q", raw_query),
+                ("per_page", &per_page.to_string()),
+                ("page", &page.to_string()),
+            ]);
+            let req_http = Self::apply_auth(req_http, req.token.as_deref());
+            let resp = Self::send(req_http, "search")?;
+
+            if !resp.status().is_success() {
+                let status = resp.status();
+                let body = resp
+                    .text()
+                    .map_err(|err| app_error_from_reqwest("GitHub", "error body read", &err))?;
+                return Err(AppError::from_http("GitHub", "search", status, &body).into());
+            }
+
+            let search: SearchResponse = resp
+                .json()
+                .map_err(|err| app_error_from_decode("GitHub", "search", err))?;
+            trace!(
+                count = search.items.len(),
+                page, "decoded GitHub search page"
+            );
+            let done = search.items.len() < per_page as usize;
+            for item in search.items {
+                let repo = item
+                    .repository_url
+                    .as_deref()
+                    .and_then(repo_from_repository_url)
+                    .or_else(|| repo_from_query.clone())
+                    .ok_or_else(|| {
+                        AppError::usage(format!(
+                            "Could not determine repo for item #{}. Include repo:owner/name in query.",
+                            item.number
+                        ))
+                    })?;
+
+                let conversation = self.fetch_conversation(
+                    &repo,
+                    ConversationSeed {
+                        id: item.number,
+                        title: item.title,
+                        state: item.state,
+                        body: item.body,
+                        is_pr: item.pull_request.is_some(),
+                    },
+                    req,
+                )?;
+                emit(conversation)?;
+                emitted += 1;
+            }
+            if done {
+                break;
+            }
+            page += 1;
+        }
+
+        Ok(emitted)
+    }
+
+    fn fetch_by_id_stream(
+        &self,
+        req: &FetchRequest,
+        repo: &str,
+        id: &str,
+        kind: ContentKind,
+        allow_fallback_to_pr: bool,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let issue_id = id.parse::<u64>().map_err(|_| {
+            AppError::usage(format!("GitHub expects a numeric issue/PR id, got '{id}'."))
+        })?;
+        let issue_url = format!("{GITHUB_API_BASE}/repos/{repo}/issues/{issue_id}");
+        let request = Self::apply_auth(self.client.get(&issue_url), req.token.as_deref());
+        let resp = Self::send(request, "issue fetch")?;
+        if !resp.status().is_success() {
+            let status = resp.status();
+            let body = resp
+                .text()
+                .map_err(|err| app_error_from_reqwest("GitHub", "error body read", &err))?;
+            return Err(AppError::from_http("GitHub", "issue fetch", status, &body).into());
+        }
+        let issue: IssueItem = resp
+            .json()
+            .map_err(|err| app_error_from_decode("GitHub", "issue fetch", err))?;
+        let is_pr = issue.pull_request.is_some();
+
+        match kind {
+            ContentKind::Issue if is_pr && !allow_fallback_to_pr => {
+                return Err(AppError::usage(format!(
+                    "ID {issue_id} in repo {repo} is a pull request. Use --type pr or omit --type."
+                ))
+                .into());
+            }
+            ContentKind::Issue if is_pr && allow_fallback_to_pr => {
+                warn!(
+                    "Warning: --id defaulted to issue, but found PR #{issue_id}; use --type pr for clarity."
+                );
+            }
+            ContentKind::Pr if !is_pr => {
+                return Err(AppError::usage(format!(
+                    "ID {issue_id} in repo {repo} is an issue, not a pull request."
+                ))
+                .into());
+            }
+            _ => {}
+        }
+
+        let conversation = self.fetch_conversation(
+            repo,
+            ConversationSeed {
+                id: issue.number,
+                title: issue.title,
+                state: issue.state,
+                body: issue.body,
+                is_pr,
+            },
+            req,
+        )?;
+        emit(conversation)?;
+        Ok(1)
+    }
+}
+
+impl Source for GitHubSource {
+    fn fetch_stream(
+        &self,
+        req: &FetchRequest,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        match &req.target {
+            FetchTarget::Search { raw_query } => self.search_stream(req, raw_query, emit),
+            FetchTarget::Id {
+                repo,
+                id,
+                kind,
+                allow_fallback_to_pr,
+            } => self.fetch_by_id_stream(req, repo, id, *kind, *allow_fallback_to_pr, emit),
+        }
+    }
+}

package/src/source/github/model.rs

@@ -0,0 +1,84 @@
+use serde::Deserialize;
+
+use crate::model::Comment;
+
+#[derive(Deserialize)]
+pub(super) struct SearchResponse {
+    pub(super) items: Vec<SearchItem>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct SearchItem {
+    pub(super) number: u64,
+    pub(super) title: String,
+    pub(super) state: String,
+    pub(super) body: Option<String>,
+    pub(super) repository_url: Option<String>,
+    pub(super) pull_request: Option<PullRequestMarker>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct IssueItem {
+    pub(super) number: u64,
+    pub(super) title: String,
+    pub(super) state: String,
+    pub(super) body: Option<String>,
+    pub(super) pull_request: Option<PullRequestMarker>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct PullRequestMarker {}
+
+#[derive(Deserialize)]
+pub(super) struct IssueCommentItem {
+    pub(super) user: Option<UserItem>,
+    pub(super) created_at: String,
+    pub(super) body: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct ReviewCommentItem {
+    pub(super) user: Option<UserItem>,
+    pub(super) created_at: String,
+    pub(super) body: Option<String>,
+    pub(super) path: Option<String>,
+    pub(super) line: Option<u64>,
+    pub(super) side: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct UserItem {
+    pub(super) login: String,
+}
+
+pub(super) struct ConversationSeed {
+    pub(super) id: u64,
+    pub(super) title: String,
+    pub(super) state: String,
+    pub(super) body: Option<String>,
+    pub(super) is_pr: bool,
+}
+
+pub(super) fn map_issue_comment(c: IssueCommentItem) -> Comment {
+    Comment {
+        author: c.user.map(|u| u.login),
+        created_at: c.created_at,
+        body: c.body,
+        kind: Some("issue_comment".into()),
+        review_path: None,
+        review_line: None,
+        review_side: None,
+    }
+}
+
+pub(super) fn map_review_comment(c: ReviewCommentItem) -> Comment {
+    Comment {
+        author: c.user.map(|u| u.login),
+        created_at: c.created_at,
+        body: c.body,
+        kind: Some("review_comment".into()),
+        review_path: c.path,
+        review_line: c.line,
+        review_side: c.side,
+    }
+}

package/src/source/github/query.rs

@@ -0,0 +1,50 @@
+use super::GITHUB_API_BASE;
+
+/// Extract `owner/repo` from a query string containing `repo:owner/repo`.
+#[must_use]
+pub fn extract_repo(query: &str) -> Option<String> {
+    query
+        .split_whitespace()
+        .find(|t| t.starts_with("repo:"))
+        .map(|t| t.trim_start_matches("repo:").to_string())
+}
+
+pub(super) fn repo_from_repository_url(url: &str) -> Option<String> {
+    let prefix = format!("{GITHUB_API_BASE}/repos/");
+    url.strip_prefix(&prefix)
+        .map(std::string::ToString::to_string)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn extract_repo_finds_token() {
+        assert_eq!(
+            extract_repo("is:issue state:closed repo:owner/repo Event"),
+            Some("owner/repo".into())
+        );
+    }
+
+    #[test]
+    fn extract_repo_returns_none_when_absent() {
+        assert_eq!(extract_repo("is:issue state:closed Event"), None);
+    }
+
+    #[test]
+    fn repo_from_repository_url_parses_repo() {
+        assert_eq!(
+            repo_from_repository_url("https://api.github.com/repos/owner/repo"),
+            Some("owner/repo".into())
+        );
+    }
+
+    #[test]
+    fn repo_from_repository_url_returns_none_for_non_github_api_url() {
+        assert_eq!(
+            repo_from_repository_url("https://example.com/repos/owner/repo"),
+            None
+        );
+    }
+}