@mbe24/99problems 0.2.0 → 0.3.1

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

@@ -0,0 +1,327 @@
+use serde::Deserialize;
+
+use super::super::query::BitbucketFilters;
+use crate::model::Comment;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct BitbucketDcPage<T> {
+    pub(super) values: Vec<T>,
+    pub(super) is_last_page: bool,
+    pub(super) next_page_start: Option<u32>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct BitbucketDcPullRequestItem {
+    pub(super) id: u64,
+    pub(super) title: String,
+    pub(super) state: String,
+    pub(super) description: Option<String>,
+    pub(super) author: Option<BitbucketDcParticipant>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct BitbucketDcParticipant {
+    pub(super) user: Option<BitbucketDcUser>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct BitbucketDcCommentItem {
+    pub(super) text: Option<String>,
+    pub(super) author: Option<BitbucketDcUser>,
+    pub(super) created_date: Option<i64>,
+    pub(super) anchor: Option<BitbucketDcAnchor>,
+    #[serde(default)]
+    pub(super) comments: Vec<BitbucketDcCommentItem>,
+    pub(super) deleted: Option<bool>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct BitbucketDcActivityItem {
+    pub(super) action: Option<String>,
+    pub(super) comment: Option<BitbucketDcCommentItem>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct BitbucketDcAnchor {
+    pub(super) path: Option<String>,
+    pub(super) src_path: Option<String>,
+    pub(super) line: Option<u64>,
+    pub(super) line_type: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(super) struct BitbucketDcUser {
+    pub(super) display_name: Option<String>,
+    pub(super) name: Option<String>,
+    pub(super) slug: Option<String>,
+}
+
+pub(super) fn matches_pr_filters(
+    item: &BitbucketDcPullRequestItem,
+    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()
+        && !participant_matches(item.author.as_ref(), author)
+    {
+        return false;
+    }
+
+    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 = [
+        item.title.as_str(),
+        item.description.as_deref().unwrap_or(""),
+    ]
+    .join(" ")
+    .to_ascii_lowercase();
+    terms
+        .iter()
+        .all(|term| haystack.contains(&term.to_ascii_lowercase()))
+}
+
+fn participant_matches(participant: Option<&BitbucketDcParticipant>, needle: &str) -> bool {
+    let Some(user) = participant.and_then(|p| p.user.as_ref()) else {
+        return false;
+    };
+    user_matches(user, needle)
+}
+
+fn user_matches(user: &BitbucketDcUser, needle: &str) -> bool {
+    let needle = needle.to_ascii_lowercase();
+    user.display_name
+        .as_deref()
+        .map(str::to_ascii_lowercase)
+        .is_some_and(|v| v == needle)
+        || user
+            .name
+            .as_deref()
+            .map(str::to_ascii_lowercase)
+            .is_some_and(|v| v == needle)
+        || user
+            .slug
+            .as_deref()
+            .map(str::to_ascii_lowercase)
+            .is_some_and(|v| v == needle)
+}
+
+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,
+    }
+}
+
+pub(super) fn collect_pr_comment(
+    item: BitbucketDcCommentItem,
+    include_review_comments: bool,
+    out: &mut Vec<Comment>,
+) {
+    if item.deleted.unwrap_or(false) {
+        return;
+    }
+
+    if let Some(mapped) = map_pr_comment(&item, include_review_comments) {
+        out.push(mapped);
+    }
+
+    for reply in item.comments {
+        collect_pr_comment(reply, include_review_comments, out);
+    }
+}
+
+pub(super) fn collect_comments_from_activity(
+    activity: BitbucketDcActivityItem,
+    include_review_comments: bool,
+    out: &mut Vec<Comment>,
+) {
+    if !activity
+        .action
+        .as_deref()
+        .is_some_and(|action| action.eq_ignore_ascii_case("COMMENTED"))
+    {
+        return;
+    }
+    if let Some(comment) = activity.comment {
+        collect_pr_comment(comment, include_review_comments, out);
+    }
+}
+
+fn map_pr_comment(item: &BitbucketDcCommentItem, include_review_comments: bool) -> Option<Comment> {
+    let anchor = item.anchor.as_ref();
+    let is_review =
+        anchor.is_some_and(|a| a.line.is_some() || a.path.is_some() || a.src_path.is_some());
+    if is_review && !include_review_comments {
+        return None;
+    }
+
+    let kind = if is_review {
+        "review_comment"
+    } else {
+        "issue_comment"
+    }
+    .to_string();
+
+    let review_path = anchor.and_then(|a| a.path.clone().or_else(|| a.src_path.clone()));
+    let review_side = anchor.and_then(|a| match a.line_type.as_deref() {
+        Some("REMOVED") => Some("LEFT".to_string()),
+        Some("ADDED") => Some("RIGHT".to_string()),
+        _ => None,
+    });
+
+    Some(Comment {
+        author: item.author.as_ref().and_then(select_author_name),
+        created_at: item
+            .created_date
+            .map(|value| value.to_string())
+            .unwrap_or_default(),
+        body: item.text.clone(),
+        kind: Some(kind),
+        review_path,
+        review_line: anchor.and_then(|a| a.line),
+        review_side,
+    })
+}
+
+fn select_author_name(user: &BitbucketDcUser) -> Option<String> {
+    user.display_name
+        .clone()
+        .or_else(|| user.name.clone())
+        .or_else(|| user.slug.clone())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn collects_nested_review_comment_metadata() {
+        let mut out = Vec::new();
+        collect_pr_comment(
+            BitbucketDcCommentItem {
+                text: Some("root".into()),
+                author: Some(BitbucketDcUser {
+                    display_name: Some("Alice".into()),
+                    name: Some("alice".into()),
+                    slug: None,
+                }),
+                created_date: Some(1),
+                anchor: Some(BitbucketDcAnchor {
+                    path: Some("src/lib.rs".into()),
+                    src_path: None,
+                    line: Some(12),
+                    line_type: Some("ADDED".into()),
+                }),
+                comments: vec![BitbucketDcCommentItem {
+                    text: Some("reply".into()),
+                    author: None,
+                    created_date: Some(2),
+                    anchor: None,
+                    comments: vec![],
+                    deleted: Some(false),
+                }],
+                deleted: Some(false),
+            },
+            true,
+            &mut out,
+        );
+
+        assert_eq!(out.len(), 2);
+        assert_eq!(out[0].kind.as_deref(), Some("review_comment"));
+        assert_eq!(out[0].review_path.as_deref(), Some("src/lib.rs"));
+        assert_eq!(out[0].review_line, Some(12));
+        assert_eq!(out[0].review_side.as_deref(), Some("RIGHT"));
+        assert_eq!(out[1].kind.as_deref(), Some("issue_comment"));
+    }
+
+    #[test]
+    fn skips_review_comments_when_disabled() {
+        let mut out = Vec::new();
+        collect_pr_comment(
+            BitbucketDcCommentItem {
+                text: Some("root".into()),
+                author: None,
+                created_date: Some(1),
+                anchor: Some(BitbucketDcAnchor {
+                    path: Some("src/lib.rs".into()),
+                    src_path: None,
+                    line: Some(12),
+                    line_type: Some("ADDED".into()),
+                }),
+                comments: vec![],
+                deleted: Some(false),
+            },
+            false,
+            &mut out,
+        );
+
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn activity_filter_ignores_non_comment_actions() {
+        let mut out = Vec::new();
+        collect_comments_from_activity(
+            BitbucketDcActivityItem {
+                action: Some("OPENED".into()),
+                comment: Some(BitbucketDcCommentItem {
+                    text: Some("x".into()),
+                    author: None,
+                    created_date: Some(1),
+                    anchor: None,
+                    comments: vec![],
+                    deleted: Some(false),
+                }),
+            },
+            true,
+            &mut out,
+        );
+        assert!(out.is_empty());
+    }
+
+    #[test]
+    fn activity_filter_collects_commented_action() {
+        let mut out = Vec::new();
+        collect_comments_from_activity(
+            BitbucketDcActivityItem {
+                action: Some("COMMENTED".into()),
+                comment: Some(BitbucketDcCommentItem {
+                    text: Some("hello".into()),
+                    author: None,
+                    created_date: Some(1),
+                    anchor: None,
+                    comments: vec![],
+                    deleted: Some(false),
+                }),
+            },
+            true,
+            &mut out,
+        );
+        assert_eq!(out.len(), 1);
+        assert_eq!(out[0].kind.as_deref(), Some("issue_comment"));
+    }
+}

package/src/source/bitbucket/mod.rs

@@ -0,0 +1,90 @@
+use anyhow::Result;
+use reqwest::blocking::Client;
+
+use super::{FetchRequest, Source};
+use crate::error::AppError;
+use crate::model::Conversation;
+
+mod cloud;
+mod datacenter;
+mod query;
+mod shared;
+
+const BITBUCKET_CLOUD_API_BASE: &str = "https://api.bitbucket.org/2.0";
+const PAGE_SIZE: u32 = 50;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum BitbucketDeployment {
+    Cloud,
+    Selfhosted,
+}
+
+impl BitbucketDeployment {
+    fn parse(raw: &str) -> Result<Self> {
+        match raw {
+            "cloud" => Ok(Self::Cloud),
+            "selfhosted" => Ok(Self::Selfhosted),
+            other => Err(AppError::usage(format!(
+                "Invalid bitbucket deployment '{other}'. Supported: cloud, selfhosted."
+            ))
+            .into()),
+        }
+    }
+}
+
+pub struct BitbucketSource {
+    pub(super) client: Client,
+    deployment: BitbucketDeployment,
+    pub(super) base_url: String,
+}
+
+impl BitbucketSource {
+    /// Create a Bitbucket source client.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if deployment is missing/invalid or the HTTP client
+    /// cannot be constructed.
+    pub fn new(platform_url: Option<String>, deployment: Option<String>) -> Result<Self> {
+        let deployment = deployment.ok_or_else(|| {
+            AppError::usage(
+                "Bitbucket deployment is required. Set [instances.<alias>].deployment or pass --deployment (cloud|selfhosted).",
+            )
+        })?;
+        let deployment = BitbucketDeployment::parse(&deployment)?;
+        let base_url = match deployment {
+            BitbucketDeployment::Cloud => BITBUCKET_CLOUD_API_BASE.to_string(),
+            BitbucketDeployment::Selfhosted => platform_url
+                .ok_or_else(|| {
+                    AppError::usage(
+                        "Bitbucket selfhosted deployment requires --url or [instances.<alias>].url.",
+                    )
+                })?
+                .trim_end_matches('/')
+                .to_string(),
+        };
+
+        let client = Client::builder()
+            .user_agent(concat!("99problems-cli/", env!("CARGO_PKG_VERSION")))
+            .build()?;
+
+        Ok(Self {
+            client,
+            deployment,
+            base_url,
+        })
+    }
+}
+
+impl Source for BitbucketSource {
+    fn fetch_stream(
+        &self,
+        req: &FetchRequest,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize> {
+        match self.deployment {
+            BitbucketDeployment::Cloud => self.fetch_cloud_stream(req, emit),
+            BitbucketDeployment::Selfhosted => self.fetch_datacenter_stream(req, emit),
+        }
+    }
+}

package/src/source/bitbucket/query.rs

@@ -0,0 +1,169 @@
+use anyhow::Result;
+
+use crate::error::AppError;
+use crate::source::ContentKind;
+
+#[derive(Debug, Clone)]
+pub(super) struct BitbucketFilters {
+    pub(super) repo: Option<String>,
+    pub(super) kind: ContentKind,
+    pub(super) kind_explicit: bool,
+    pub(super) state: Option<String>,
+    pub(super) labels: Vec<String>,
+    pub(super) author: Option<String>,
+    pub(super) since: Option<String>,
+    pub(super) milestone: Option<String>,
+    pub(super) search_terms: Vec<String>,
+}
+
+impl Default for BitbucketFilters {
+    fn default() -> Self {
+        Self {
+            repo: None,
+            kind: ContentKind::Pr,
+            kind_explicit: false,
+            state: None,
+            labels: vec![],
+            author: None,
+            since: None,
+            milestone: None,
+            search_terms: vec![],
+        }
+    }
+}
+
+pub(super) fn parse_bitbucket_query(raw_query: &str) -> BitbucketFilters {
+    let mut filters = BitbucketFilters::default();
+
+    for token in raw_query.split_whitespace() {
+        if token == "is:issue" {
+            filters.kind = ContentKind::Issue;
+            filters.kind_explicit = true;
+            continue;
+        }
+        if token == "is:pr" {
+            filters.kind = ContentKind::Pr;
+            filters.kind_explicit = true;
+            continue;
+        }
+        if let Some(kind) = token.strip_prefix("type:") {
+            if kind == "issue" {
+                filters.kind = ContentKind::Issue;
+                filters.kind_explicit = true;
+                continue;
+            }
+            if kind == "pr" {
+                filters.kind = ContentKind::Pr;
+                filters.kind_explicit = true;
+                continue;
+            }
+        }
+        if let Some(repo) = token.strip_prefix("repo:") {
+            filters.repo = Some(repo.to_string());
+            continue;
+        }
+        if let Some(state) = token.strip_prefix("state:") {
+            filters.state = Some(state.to_string());
+            continue;
+        }
+        if let Some(label) = token.strip_prefix("label:") {
+            filters.labels.push(label.to_string());
+            continue;
+        }
+        if let Some(author) = token.strip_prefix("author:") {
+            filters.author = Some(author.to_string());
+            continue;
+        }
+        if let Some(since) = token.strip_prefix("created:>=") {
+            filters.since = Some(since.to_string());
+            continue;
+        }
+        if let Some(milestone) = token.strip_prefix("milestone:") {
+            filters.milestone = Some(milestone.to_string());
+            continue;
+        }
+
+        filters.search_terms.push(token.to_string());
+    }
+
+    filters
+}
+
+/// Parse `workspace/repo_slug` from `repo:` input.
+///
+/// # Errors
+///
+/// Returns an error when the repository path is missing or malformed.
+pub(super) fn parse_workspace_repo(raw_repo: Option<&str>) -> Result<(String, String)> {
+    parse_repo_pair(raw_repo, "workspace/repo_slug")
+}
+
+/// Parse `project/repo_slug` from `repo:` input.
+///
+/// # Errors
+///
+/// Returns an error when the repository path is missing or malformed.
+pub(super) fn parse_project_repo(raw_repo: Option<&str>) -> Result<(String, String)> {
+    parse_repo_pair(raw_repo, "project/repo_slug")
+}
+
+fn parse_repo_pair(raw_repo: Option<&str>, expected_format: &str) -> Result<(String, String)> {
+    let repo = raw_repo.ok_or_else(|| {
+        AppError::usage(format!(
+            "No repo: found in query. Use --repo or include 'repo:{expected_format}' in -q"
+        ))
+    })?;
+    let mut parts = repo.split('/');
+    let first = parts.next().unwrap_or_default().trim();
+    let second = parts.next().unwrap_or_default().trim();
+    let tail = parts.next();
+    if first.is_empty() || second.is_empty() || tail.is_some() {
+        return Err(AppError::usage(format!(
+            "Bitbucket repo must be '{expected_format}', got '{repo}'."
+        ))
+        .into());
+    }
+    Ok((first.to_string(), second.to_string()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_bitbucket_query_extracts_filters() {
+        let q = parse_bitbucket_query(
+            "is:pr repo:workspace/repo state:closed label:bug author:alice created:>=2025-01-01 milestone:v1 text",
+        );
+        assert!(matches!(q.kind, ContentKind::Pr));
+        assert!(q.kind_explicit);
+        assert_eq!(q.repo.as_deref(), Some("workspace/repo"));
+        assert_eq!(q.state.as_deref(), Some("closed"));
+        assert_eq!(q.labels, vec!["bug"]);
+        assert_eq!(q.author.as_deref(), Some("alice"));
+        assert_eq!(q.since.as_deref(), Some("2025-01-01"));
+        assert_eq!(q.milestone.as_deref(), Some("v1"));
+        assert_eq!(q.search_terms, vec!["text"]);
+    }
+
+    #[test]
+    fn parse_query_defaults_to_pr_without_explicit_kind() {
+        let q = parse_bitbucket_query("repo:workspace/repo state:open");
+        assert!(matches!(q.kind, ContentKind::Pr));
+        assert!(!q.kind_explicit);
+    }
+
+    #[test]
+    fn parse_workspace_repo_requires_workspace_and_repo_slug() {
+        let err = parse_workspace_repo(Some("workspace"))
+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("workspace/repo_slug"));
+    }
+
+    #[test]
+    fn parse_project_repo_requires_project_and_repo_slug() {
+        let err = parse_project_repo(Some("PROJECT")).unwrap_err().to_string();
+        assert!(err.contains("project/repo_slug"));
+    }
+}

package/src/source/bitbucket/shared/auth.rs

@@ -0,0 +1,54 @@
+use reqwest::blocking::RequestBuilder;
+
+pub(in crate::source::bitbucket) fn apply_auth(
+    req: RequestBuilder,
+    token: Option<&str>,
+) -> RequestBuilder {
+    match resolve_auth_mode(token) {
+        AuthMode::None => req,
+        AuthMode::Bearer(token) => req.bearer_auth(token),
+        AuthMode::Basic { user, secret } => req.basic_auth(user, Some(secret)),
+    }
+}
+
+fn resolve_auth_mode(token: Option<&str>) -> AuthMode<'_> {
+    match token {
+        Some(t) if t.contains(':') => {
+            let (user, secret) = t.split_once(':').unwrap_or_default();
+            AuthMode::Basic { user, secret }
+        }
+        Some(t) => AuthMode::Bearer(t),
+        None => AuthMode::None,
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum AuthMode<'a> {
+    None,
+    Bearer(&'a str),
+    Basic { user: &'a str, secret: &'a str },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn resolve_auth_mode_prefers_explicit_basic() {
+        assert_eq!(
+            resolve_auth_mode(Some("user:pass")),
+            AuthMode::Basic {
+                user: "user",
+                secret: "pass"
+            }
+        );
+    }
+
+    #[test]
+    fn resolve_auth_mode_uses_bearer_for_plain_tokens() {
+        assert_eq!(
+            resolve_auth_mode(Some("ATxxxx")),
+            AuthMode::Bearer("ATxxxx")
+        );
+    }
+}

package/src/source/bitbucket/shared/http.rs

@@ -0,0 +1,59 @@
+use anyhow::Result;
+use reqwest::StatusCode;
+use reqwest::blocking::{RequestBuilder, Response};
+use serde::de::DeserializeOwned;
+
+use crate::error::{AppError, app_error_from_decode, app_error_from_reqwest};
+
+pub(in crate::source::bitbucket) fn send(req: RequestBuilder, operation: &str) -> Result<Response> {
+    req.send()
+        .map_err(|err| app_error_from_reqwest("Bitbucket", operation, &err).into())
+}
+
+pub(in crate::source::bitbucket) fn parse_bitbucket_json<T: DeserializeOwned>(
+    resp: Response,
+    token: Option<&str>,
+    operation: &str,
+) -> Result<T> {
+    let status = resp.status();
+    let body = resp.text()?;
+    if !status.is_success() {
+        if status == StatusCode::UNAUTHORIZED || status == StatusCode::FORBIDDEN {
+            return Err(AppError::auth(format!(
+                "Bitbucket API {operation} error {status}: {}. {}",
+                body_snippet(&body),
+                auth_hint(token)
+            ))
+            .with_provider("bitbucket")
+            .with_http_status(status)
+            .into());
+        }
+        return Err(AppError::from_http("Bitbucket", operation, status, &body)
+            .with_provider("bitbucket")
+            .into());
+    }
+
+    serde_json::from_str(&body).map_err(|err| {
+        app_error_from_decode(
+            "Bitbucket",
+            operation,
+            format!("{err} (body starts with: {})", body_snippet(&body)),
+        )
+        .into()
+    })
+}
+
+fn auth_hint(token: Option<&str>) -> &'static str {
+    if token.is_some() {
+        "Check Bitbucket token credentials and scopes."
+    } else {
+        "No Bitbucket token detected. Set --token, BITBUCKET_TOKEN, or [instances.<alias>].token."
+    }
+}
+
+fn body_snippet(body: &str) -> String {
+    body.chars()
+        .take(200)
+        .collect::<String>()
+        .replace('\n', " ")
+}

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

@@ -0,0 +1,5 @@
+mod auth;
+mod http;
+
+pub(super) use auth::apply_auth;
+pub(super) use http::{parse_bitbucket_json, send};