Skip to main content

fetchium_core/compare/
parser.rs

1//! Parse comparison queries like "A vs B vs C" into individual items (Phase 5, PRD §10).
2
3/// A parsed comparison query.
4#[derive(Debug, Clone)]
5pub struct ComparisonQuery {
6    /// The individual items to compare.
7    pub items: Vec<String>,
8    /// Original query string.
9    pub raw_query: String,
10}
11
12/// Parse a comparison query into its constituent items.
13///
14/// Recognises common separators: "vs", "versus", "or", "compared to", "vs.".
15pub fn parse_comparison_query(query: &str) -> ComparisonQuery {
16    let separators = [" vs ", " versus ", " or ", " compared to ", " vs. "];
17
18    for sep in &separators {
19        if query.to_lowercase().contains(sep) {
20            let items: Vec<String> = query
21                .to_lowercase()
22                .split(sep)
23                .map(|s| s.trim().to_string())
24                .filter(|s| !s.is_empty())
25                .collect();
26            if items.len() >= 2 {
27                return ComparisonQuery {
28                    items,
29                    raw_query: query.to_string(),
30                };
31            }
32        }
33    }
34
35    // "compare X Y Z" prefix
36    let lower = query.to_lowercase();
37    if let Some(rest) = lower.strip_prefix("compare ") {
38        let items: Vec<String> = rest.split_whitespace().map(|s| s.to_string()).collect();
39        if items.len() >= 2 {
40            return ComparisonQuery {
41                items,
42                raw_query: query.to_string(),
43            };
44        }
45    }
46
47    // Fallback: treat the whole query as one item
48    ComparisonQuery {
49        items: vec![query.to_string()],
50        raw_query: query.to_string(),
51    }
52}
53
54#[cfg(test)]
55mod tests {
56    use super::*;
57
58    #[test]
59    fn parse_vs_separator() {
60        let q = parse_comparison_query("React vs Vue vs Svelte");
61        assert_eq!(q.items, vec!["react", "vue", "svelte"]);
62    }
63
64    #[test]
65    fn parse_versus() {
66        let q = parse_comparison_query("Rust versus Go");
67        assert_eq!(q.items, vec!["rust", "go"]);
68    }
69
70    #[test]
71    fn parse_compared_to() {
72        let q = parse_comparison_query("Python compared to JavaScript");
73        assert_eq!(q.items, vec!["python", "javascript"]);
74    }
75
76    #[test]
77    fn parse_compare_prefix() {
78        let q = parse_comparison_query("compare Redis Memcached");
79        assert_eq!(q.items.len(), 2);
80    }
81
82    #[test]
83    fn single_item_fallback() {
84        let q = parse_comparison_query("Rust programming language");
85        assert_eq!(q.items.len(), 1);
86    }
87}