@mbe24/99problems 0.1.1 → 0.3.0

package/src/source/jira/query.rs

@@ -0,0 +1,153 @@
+use anyhow::Result;
+
+use crate::error::AppError;
+use crate::source::ContentKind;
+
+#[derive(Debug)]
+pub(super) struct JiraFilters {
+    pub(super) repo: Option<String>,
+    pub(super) kind: ContentKind,
+    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 JiraFilters {
+    fn default() -> Self {
+        Self {
+            repo: None,
+            kind: ContentKind::Issue,
+            state: None,
+            labels: vec![],
+            author: None,
+            since: None,
+            milestone: None,
+            search_terms: vec![],
+        }
+    }
+}
+
+pub(super) fn parse_jira_query(raw_query: &str) -> JiraFilters {
+    let mut filters = JiraFilters::default();
+
+    for token in raw_query.split_whitespace() {
+        if token == "is:issue" {
+            filters.kind = ContentKind::Issue;
+            continue;
+        }
+        if token == "is:pr" {
+            filters.kind = ContentKind::Pr;
+            continue;
+        }
+        if let Some(kind) = token.strip_prefix("type:") {
+            if kind == "issue" {
+                filters.kind = ContentKind::Issue;
+                continue;
+            }
+            if kind == "pr" {
+                filters.kind = ContentKind::Pr;
+                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
+}
+
+pub(super) fn build_jql(filters: &JiraFilters) -> Result<String> {
+    let project = filters.repo.as_deref().ok_or_else(|| {
+        AppError::usage("No repo: found in query. Use --repo with Jira project key.")
+    })?;
+
+    let mut clauses = vec![format!("project = {}", quote_jql(project))];
+    if let Some(state) = filters.state.as_deref() {
+        match state.to_ascii_lowercase().as_str() {
+            "open" | "opened" => clauses.push("statusCategory != Done".into()),
+            "closed" => clauses.push("statusCategory = Done".into()),
+            "all" => {}
+            _ => clauses.push(format!("status = {}", quote_jql(state))),
+        }
+    }
+
+    for label in &filters.labels {
+        clauses.push(format!("labels = {}", quote_jql(label)));
+    }
+    if let Some(author) = &filters.author {
+        clauses.push(format!("reporter = {}", quote_jql(author)));
+    }
+    if let Some(since) = &filters.since {
+        clauses.push(format!("created >= {}", quote_jql(since)));
+    }
+    if let Some(milestone) = &filters.milestone {
+        clauses.push(format!("fixVersion = {}", quote_jql(milestone)));
+    }
+    if !filters.search_terms.is_empty() {
+        clauses.push(format!(
+            "text ~ {}",
+            quote_jql(&filters.search_terms.join(" "))
+        ));
+    }
+
+    Ok(clauses.join(" AND "))
+}
+
+fn quote_jql(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\\\""))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_jira_query_extracts_filters() {
+        let q = parse_jira_query(
+            "repo:CLOUD state:closed label:api author:alice created:>=2024-01-01 milestone:v1 text",
+        );
+        assert_eq!(q.repo.as_deref(), Some("CLOUD"));
+        assert!(matches!(q.kind, ContentKind::Issue));
+        assert_eq!(q.state.as_deref(), Some("closed"));
+        assert_eq!(q.labels, vec!["api"]);
+        assert_eq!(q.author.as_deref(), Some("alice"));
+        assert_eq!(q.since.as_deref(), Some("2024-01-01"));
+        assert_eq!(q.milestone.as_deref(), Some("v1"));
+        assert_eq!(q.search_terms, vec!["text"]);
+    }
+
+    #[test]
+    fn build_jql_maps_closed_to_done_category() {
+        let q = parse_jira_query("repo:CLOUD state:closed");
+        let jql = build_jql(&q).unwrap();
+        assert!(jql.contains("project = \"CLOUD\""));
+        assert!(jql.contains("statusCategory = Done"));
+    }
+}

package/src/source/mod.rs

@@ -1,19 +1,76 @@
 use crate::model::Conversation;
 use anyhow::Result;
 
-pub mod github_issues;
+pub mod bitbucket;
+pub mod github;
+pub mod gitlab;
+pub mod jira;
 
-/// A pluggable data source that fetches issue conversations.
+/// A pluggable data source that fetches issue/PR conversations.
 pub trait Source {
-    fn fetch(&self, query: &Query) -> Result<Vec<Conversation>>;
-    fn fetch_one(&self, repo: &str, issue_id: u64) -> Result<Conversation>;
+    /// Fetch issue or pull request conversations for a request target and emit
+    /// each conversation incrementally.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error when request validation fails, authentication fails,
+    /// or the remote platform returns a non-success/invalid response.
+    fn fetch_stream(
+        &self,
+        req: &FetchRequest,
+        emit: &mut dyn FnMut(Conversation) -> Result<()>,
+    ) -> Result<usize>;
+
+    /// Fetch all conversations and collect them into memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error when request validation fails, authentication fails,
+    /// remote calls fail, or emitted conversations cannot be collected.
+    fn fetch(&self, req: &FetchRequest) -> Result<Vec<Conversation>> {
+        let mut conversations = Vec::new();
+        self.fetch_stream(req, &mut |conversation| {
+            conversations.push(conversation);
+            Ok(())
+        })?;
+        Ok(conversations)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ContentKind {
+    Issue,
+    Pr,
+}
+
+#[derive(Debug, Clone)]
+pub enum FetchTarget {
+    Search {
+        raw_query: String,
+    },
+    Id {
+        repo: String,
+        id: String,
+        kind: ContentKind,
+        allow_fallback_to_pr: bool,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub struct FetchRequest {
+    pub target: FetchTarget,
+    pub per_page: u32,
+    pub token: Option<String>,
+    pub account_email: Option<String>,
+    pub include_comments: bool,
+    pub include_review_comments: bool,
 }
 
 /// Parsed search parameters passed to a Source.
 #[derive(Debug, Default, Clone)]
 #[allow(dead_code)]
 pub struct Query {
-    /// Full raw query string (GitHub search syntax), e.g. "is:issue state:closed Event repo:owner/repo"
+    /// Full raw query string (platform search syntax), e.g. "state:closed Event repo:owner/repo"
     pub raw: String,
     pub per_page: u32,
     pub token: Option<String>,
@@ -21,12 +78,18 @@ pub struct Query {
 
 impl Query {
     /// Build a query by merging a raw string with convenience shorthands.
-    /// Shorthands are only appended if their qualifier isn't already present.
+    /// Shorthands are only appended if their qualifier isn't already present in the raw string.
+    #[must_use]
+    #[allow(clippy::too_many_arguments)]
     pub fn build(
         raw: Option<String>,
+        kind: &str,
         repo: Option<String>,
         state: Option<String>,
         labels: Option<String>,
+        author: Option<String>,
+        since: Option<String>,
+        milestone: Option<String>,
         per_page: u32,
         token: Option<String>,
     ) -> Self {
@@ -36,6 +99,17 @@ impl Query {
             parts.push(r);
         }
 
+        // Inject type qualifier unless already present
+        if !parts
+            .iter()
+            .any(|p| p.contains("is:issue") || p.contains("is:pr") || p.contains("type:"))
+        {
+            match kind {
+                "pr" => parts.push("is:pr".into()),
+                _ => parts.push("is:issue".into()),
+            }
+        }
+
         if let Some(repo) = repo
             && !parts.iter().any(|p| p.contains("repo:"))
         {
@@ -54,6 +128,21 @@ impl Query {
                 }
             }
         }
+        if let Some(author) = author
+            && !parts.iter().any(|p| p.contains("author:"))
+        {
+            parts.push(format!("author:{author}"));
+        }
+        if let Some(since) = since
+            && !parts.iter().any(|p| p.contains("created:"))
+        {
+            parts.push(format!("created:>={since}"));
+        }
+        if let Some(milestone) = milestone
+            && !parts.iter().any(|p| p.contains("milestone:"))
+        {
+            parts.push(format!("milestone:{milestone}"));
+        }
 
         Query {
             raw: parts.join(" "),
@@ -67,29 +156,36 @@ impl Query {
 mod tests {
     use super::*;
 
-    #[test]
-    fn build_query_appends_repo_and_state() {
-        let q = Query::build(
-            Some("is:issue Event".into()),
-            Some("owner/repo".into()),
-            Some("closed".into()),
+    fn build(raw: Option<&str>, kind: &str, repo: Option<&str>, state: Option<&str>) -> Query {
+        Query::build(
+            raw.map(std::convert::Into::into),
+            kind,
+            repo.map(std::convert::Into::into),
+            state.map(std::convert::Into::into),
+            None,
+            None,
+            None,
             None,
             100,
             None,
-        );
+        )
+    }
+
+    #[test]
+    fn build_query_appends_repo_and_state() {
+        let q = build(Some("Event"), "issue", Some("owner/repo"), Some("closed"));
         assert!(q.raw.contains("repo:owner/repo"));
         assert!(q.raw.contains("state:closed"));
-        assert!(q.raw.contains("is:issue Event"));
+        assert!(q.raw.contains("Event"));
+        assert!(q.raw.contains("is:issue"));
     }
 
     #[test]
     fn build_query_does_not_duplicate_repo() {
-        let q = Query::build(
-            Some("is:issue repo:owner/repo".into()),
-            Some("other/repo".into()),
-            None,
-            None,
-            100,
+        let q = build(
+            Some("is:issue repo:owner/repo"),
+            "issue",
+            Some("other/repo"),
             None,
         );
         assert_eq!(q.raw.matches("repo:").count(), 1);
@@ -97,14 +193,73 @@ mod tests {
 
     #[test]
     fn build_query_handles_multiple_labels() {
-        let q = Query::build(None, None, None, Some("bug,enhancement".into()), 100, None);
+        let q = Query::build(
+            None,
+            "issue",
+            None,
+            None,
+            Some("bug,enhancement".into()),
+            None,
+            None,
+            None,
+            100,
+            None,
+        );
         assert!(q.raw.contains("label:bug"));
         assert!(q.raw.contains("label:enhancement"));
     }
 
     #[test]
-    fn build_query_empty_produces_empty_raw() {
-        let q = Query::build(None, None, None, None, 100, None);
-        assert_eq!(q.raw.trim(), "");
+    fn build_query_empty_produces_type_qualifier() {
+        let q = build(None, "issue", None, None);
+        assert!(q.raw.contains("is:issue"));
+    }
+
+    #[test]
+    fn build_query_pr_type_injects_is_pr() {
+        let q = build(None, "pr", Some("owner/repo"), None);
+        assert!(q.raw.contains("is:pr"));
+        assert!(!q.raw.contains("is:issue"));
+    }
+
+    #[test]
+    fn build_query_does_not_duplicate_type() {
+        let q = build(Some("is:pr repo:owner/repo"), "pr", None, None);
+        assert_eq!(q.raw.matches("is:pr").count(), 1);
+    }
+
+    #[test]
+    fn build_query_author_and_since() {
+        let q = Query::build(
+            None,
+            "issue",
+            None,
+            None,
+            None,
+            Some("octocat".into()),
+            Some("2024-01-01".into()),
+            None,
+            100,
+            None,
+        );
+        assert!(q.raw.contains("author:octocat"));
+        assert!(q.raw.contains("created:>=2024-01-01"));
+    }
+
+    #[test]
+    fn build_query_milestone() {
+        let q = Query::build(
+            None,
+            "issue",
+            None,
+            None,
+            None,
+            None,
+            None,
+            Some("v1.0".into()),
+            100,
+            None,
+        );
+        assert!(q.raw.contains("milestone:v1.0"));
     }
 }