@mbe24/99problems 0.2.0 → 0.3.1

package/src/source/bitbucket/cloud/model.rs

@@ -0,0 +1,211 @@
+use serde::Deserialize;
+
+use super::super::query::BitbucketFilters;
+use crate::model::Comment;
+
+#[derive(Deserialize)]
+pub(super) struct BitbucketPage<T> {
+    pub(super) values: Vec<T>,
+    pub(super) next: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct BitbucketPullRequestItem {
+    pub(super) id: u64,
+    pub(super) title: String,
+    pub(super) state: String,
+    pub(super) description: Option<String>,
+    pub(super) summary: Option<BitbucketRichText>,
+    pub(super) author: Option<BitbucketUser>,
+    pub(super) created_on: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct BitbucketCommentItem {
+    pub(super) user: Option<BitbucketUser>,
+    pub(super) created_on: Option<String>,
+    pub(super) content: Option<BitbucketRichText>,
+    pub(super) inline: Option<BitbucketInline>,
+    pub(super) deleted: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct BitbucketInline {
+    pub(super) path: Option<String>,
+    pub(super) from: Option<u64>,
+    pub(super) to: Option<u64>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct BitbucketRichText {
+    pub(super) raw: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub(super) struct BitbucketUser {
+    pub(super) display_name: Option<String>,
+    pub(super) nickname: Option<String>,
+    pub(super) username: Option<String>,
+}
+
+pub(super) fn matches_pr_filters(
+    item: &BitbucketPullRequestItem,
+    filters: &BitbucketFilters,
+) -> bool {
+    if !matches_pr_state(item.state.as_str(), filters.state.as_deref()) {
+        return false;
+    }
+    if let Some(author) = filters.author.as_deref()
+        && !user_matches(item.author.as_ref(), author)
+    {
+        return false;
+    }
+    if let Some(since) = filters.since.as_deref()
+        && let Some(created) = item.created_on.as_deref()
+        && created < since
+    {
+        return false;
+    }
+    matches_terms(
+        &[
+            item.title.as_str(),
+            item.description.as_deref().unwrap_or(""),
+            item.summary
+                .as_ref()
+                .and_then(|c| c.raw.as_deref())
+                .unwrap_or(""),
+        ],
+        filters,
+    )
+}
+
+fn matches_terms(haystack_parts: &[&str], filters: &BitbucketFilters) -> bool {
+    let mut terms = filters.search_terms.clone();
+    terms.extend(filters.labels.clone());
+    if let Some(milestone) = filters.milestone.as_deref() {
+        terms.push(milestone.to_string());
+    }
+    if terms.is_empty() {
+        return true;
+    }
+    let haystack = haystack_parts.join(" ").to_ascii_lowercase();
+    terms
+        .iter()
+        .all(|term| haystack.contains(&term.to_ascii_lowercase()))
+}
+
+fn matches_pr_state(state: &str, filter_state: Option<&str>) -> bool {
+    let state = state.to_ascii_lowercase();
+    let Some(filter) = filter_state.map(str::to_ascii_lowercase) else {
+        return true;
+    };
+    match filter.as_str() {
+        "open" | "opened" => state == "open",
+        "closed" => matches!(state.as_str(), "merged" | "declined" | "superseded"),
+        "merged" => state == "merged",
+        "declined" => state == "declined",
+        "all" => true,
+        other => state == other,
+    }
+}
+
+fn user_matches(user: Option<&BitbucketUser>, needle: &str) -> bool {
+    let Some(user) = user else {
+        return false;
+    };
+    let needle = needle.to_ascii_lowercase();
+    user.display_name
+        .as_deref()
+        .map(str::to_ascii_lowercase)
+        .is_some_and(|v| v == needle)
+        || user
+            .nickname
+            .as_deref()
+            .map(str::to_ascii_lowercase)
+            .is_some_and(|v| v == needle)
+        || user
+            .username
+            .as_deref()
+            .map(str::to_ascii_lowercase)
+            .is_some_and(|v| v == needle)
+}
+
+pub(super) fn map_pr_comment(
+    item: BitbucketCommentItem,
+    include_review_comments: bool,
+) -> Option<Comment> {
+    let (kind, review_path, review_line, review_side) = if let Some(inline) = item.inline {
+        if !include_review_comments {
+            return None;
+        }
+        let review_line = inline.to.or(inline.from);
+        let review_side = if inline.to.is_some() {
+            Some("RIGHT".to_string())
+        } else if inline.from.is_some() {
+            Some("LEFT".to_string())
+        } else {
+            None
+        };
+        (
+            "review_comment".to_string(),
+            inline.path,
+            review_line,
+            review_side,
+        )
+    } else {
+        ("issue_comment".to_string(), None, None, None)
+    };
+
+    Some(Comment {
+        author: item.user.and_then(select_author_name),
+        created_at: item.created_on.unwrap_or_default(),
+        body: item.content.and_then(|c| c.raw),
+        kind: Some(kind),
+        review_path,
+        review_line,
+        review_side,
+    })
+}
+
+fn select_author_name(user: BitbucketUser) -> Option<String> {
+    user.nickname.or(user.username).or(user.display_name)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn pr_state_filter_maps_open_closed_and_merged() {
+        assert!(matches_pr_state("OPEN", Some("open")));
+        assert!(matches_pr_state("DECLINED", Some("closed")));
+        assert!(matches_pr_state("MERGED", Some("merged")));
+        assert!(!matches_pr_state("OPEN", Some("merged")));
+    }
+
+    #[test]
+    fn map_pr_review_comment_sets_review_fields() {
+        let item = BitbucketCommentItem {
+            user: Some(BitbucketUser {
+                display_name: Some("Alice".into()),
+                nickname: Some("alice".into()),
+                username: None,
+            }),
+            created_on: Some("2026-01-01T00:00:00.000000+00:00".into()),
+            content: Some(BitbucketRichText {
+                raw: Some("Looks good".into()),
+            }),
+            inline: Some(BitbucketInline {
+                path: Some("src/lib.rs".into()),
+                from: None,
+                to: Some(42),
+            }),
+            deleted: Some(false),
+        };
+        let mapped = map_pr_comment(item, true).expect("expected comment");
+        assert_eq!(mapped.kind.as_deref(), Some("review_comment"));
+        assert_eq!(mapped.review_path.as_deref(), Some("src/lib.rs"));
+        assert_eq!(mapped.review_line, Some(42));
+        assert_eq!(mapped.review_side.as_deref(), Some("RIGHT"));
+    }
+}

package/src/source/bitbucket/datacenter/api.rs

@@ -0,0 +1,74 @@
+use anyhow::Result;
+use reqwest::StatusCode;
+use serde::de::DeserializeOwned;
+use tracing::{debug, trace};
+
+use super::super::BitbucketSource;
+use super::super::shared::{apply_auth, parse_bitbucket_json, send};
+use super::model::BitbucketDcPage;
+
+impl BitbucketSource {
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn datacenter_get_pages_stream<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        params: &[(String, String)],
+        token: Option<&str>,
+        per_page: u32,
+        emit: &mut dyn FnMut(T) -> Result<()>,
+    ) -> Result<usize> {
+        let per_page = per_page.clamp(1, 100);
+        let mut emitted = 0usize;
+        let mut start = 0u32;
+
+        loop {
+            debug!(url = %url, start, per_page, "fetching Bitbucket Data Center page");
+            let mut query_params = params.to_vec();
+            query_params.push(("start".to_string(), start.to_string()));
+            query_params.push(("limit".to_string(), per_page.to_string()));
+
+            let request = apply_auth(self.client.get(url), token)
+                .header("Accept", "application/json")
+                .query(&query_params);
+            let response = send(request, "page fetch")?;
+            let page: BitbucketDcPage<T> = parse_bitbucket_json(response, token, "page fetch")?;
+            trace!(
+                count = page.values.len(),
+                is_last_page = page.is_last_page,
+                "decoded Bitbucket Data Center page"
+            );
+
+            for item in page.values {
+                emit(item)?;
+                emitted += 1;
+            }
+
+            if page.is_last_page {
+                break;
+            }
+
+            match page.next_page_start {
+                Some(next) => start = next,
+                None => break,
+            }
+        }
+
+        Ok(emitted)
+    }
+
+    pub(super) fn datacenter_get_one<T: DeserializeOwned>(
+        &self,
+        url: &str,
+        token: Option<&str>,
+        operation: &str,
+    ) -> Result<Option<T>> {
+        let request = apply_auth(self.client.get(url), token).header("Accept", "application/json");
+        let response = send(request, operation)?;
+        if response.status() == StatusCode::NOT_FOUND {
+            return Ok(None);
+        }
+
+        let item = parse_bitbucket_json(response, token, operation)?;
+        Ok(Some(item))
+    }
+}

package/src/source/bitbucket/datacenter/mod.rs

@@ -0,0 +1,181 @@
+use anyhow::Result;
+
+use self::model::{
+    BitbucketDcActivityItem, BitbucketDcPullRequestItem, collect_comments_from_activity,
+    matches_pr_filters,
+};
+use super::BitbucketSource;
+use super::query::{parse_bitbucket_query, parse_project_repo};
+use crate::error::AppError;
+use crate::model::{Comment, Conversation};
+use crate::source::{ContentKind, FetchRequest, FetchTarget};
+
+mod api;
+mod model;
+
+impl BitbucketSource {
+    pub(super) fn fetch_datacenter_stream(
+        &self,
+        req: &FetchRequest,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        match &req.target {
+            FetchTarget::Search { raw_query } => {
+                self.search_datacenter_stream(req, raw_query, emit)
+            }
+            FetchTarget::Id {
+                repo,
+                id,
+                kind,
+                allow_fallback_to_pr: _,
+            } => self.fetch_datacenter_by_id_stream(req, repo, id, *kind, emit),
+        }
+    }
+
+    fn search_datacenter_stream(
+        &self,
+        req: &FetchRequest,
+        raw_query: &str,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let mut filters = parse_bitbucket_query(raw_query);
+        if !filters.kind_explicit {
+            filters.kind = ContentKind::Pr;
+        }
+        if matches!(filters.kind, ContentKind::Issue) {
+            return Err(AppError::usage(
+                "Bitbucket Data Center supports pull requests only. Use --type pr or omit --type.",
+            )
+            .into());
+        }
+
+        let (project, repo_slug) = parse_project_repo(filters.repo.as_deref())?;
+        let repo = format!("{project}/{repo_slug}");
+        self.search_datacenter_prs_stream(req, &repo, &filters, emit)
+    }
+
+    fn search_datacenter_prs_stream(
+        &self,
+        req: &FetchRequest,
+        repo: &str,
+        filters: &super::query::BitbucketFilters,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let (project, repo_slug) = parse_project_repo(Some(repo))?;
+        let url = format!(
+            "{}/rest/api/latest/projects/{project}/repos/{repo_slug}/pull-requests",
+            self.base_url
+        );
+        let params = vec![("state".to_string(), "ALL".to_string())];
+
+        let mut emitted = 0usize;
+        self.datacenter_get_pages_stream(
+            &url,
+            &params,
+            req.token.as_deref(),
+            req.per_page,
+            &mut |item: BitbucketDcPullRequestItem| {
+                if !matches_pr_filters(&item, filters) {
+                    return Ok(());
+                }
+                emit(self.fetch_datacenter_pr_conversation(repo, item, req)?)?;
+                emitted += 1;
+                Ok(())
+            },
+        )?;
+
+        Ok(emitted)
+    }
+
+    fn fetch_datacenter_by_id_stream(
+        &self,
+        req: &FetchRequest,
+        repo: &str,
+        id: &str,
+        kind: ContentKind,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        let id = id.parse::<u64>().map_err(|_| {
+            AppError::usage(format!(
+                "Bitbucket Data Center expects a numeric pull request id, got '{id}'."
+            ))
+        })?;
+
+        if matches!(kind, ContentKind::Issue) {
+            return Err(AppError::usage(
+                "Bitbucket Data Center supports pull requests only. Use --type pr or omit --type.",
+            )
+            .into());
+        }
+
+        if let Some(pr) = self.fetch_datacenter_pr_by_id(repo, id, req)? {
+            emit(self.fetch_datacenter_pr_conversation(repo, pr, req)?)?;
+            return Ok(1);
+        }
+
+        Err(AppError::not_found(format!("Pull request #{id} not found in repo {repo}.")).into())
+    }
+
+    fn fetch_datacenter_pr_by_id(
+        &self,
+        repo: &str,
+        id: u64,
+        req: &FetchRequest,
+    ) -> Result<Option<BitbucketDcPullRequestItem>> {
+        let (project, repo_slug) = parse_project_repo(Some(repo))?;
+        let url = format!(
+            "{}/rest/api/latest/projects/{project}/repos/{repo_slug}/pull-requests/{id}",
+            self.base_url
+        );
+        self.datacenter_get_one(&url, req.token.as_deref(), "pull request fetch")
+    }
+
+    fn fetch_datacenter_pr_conversation(
+        &self,
+        repo: &str,
+        item: BitbucketDcPullRequestItem,
+        req: &FetchRequest,
+    ) -> Result<Conversation> {
+        let comments = if req.include_comments {
+            self.fetch_datacenter_pr_comments(repo, item.id, req)?
+        } else {
+            Vec::new()
+        };
+
+        Ok(Conversation {
+            id: item.id.to_string(),
+            title: item.title,
+            state: item.state,
+            body: item.description.filter(|body| !body.is_empty()),
+            comments,
+        })
+    }
+
+    fn fetch_datacenter_pr_comments(
+        &self,
+        repo: &str,
+        id: u64,
+        req: &FetchRequest,
+    ) -> Result<Vec<Comment>> {
+        let (project, repo_slug) = parse_project_repo(Some(repo))?;
+        let url = format!(
+            "{}/rest/api/latest/projects/{project}/repos/{repo_slug}/pull-requests/{id}/activities",
+            self.base_url
+        );
+
+        let mut comments = Vec::new();
+        self.datacenter_get_pages_stream(
+            &url,
+            &[],
+            req.token.as_deref(),
+            req.per_page,
+            &mut |item: BitbucketDcActivityItem| {
+                collect_comments_from_activity(item, req.include_review_comments, &mut comments);
+                Ok(())
+            },
+        )?;
+
+        comments.sort_by(|a, b| a.created_at.cmp(&b.created_at));
+        Ok(comments)
+    }
+}