tarzi 0.1.11

Rust-native lite search for AI applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Parser module for extracting search results from different content types
//!
//! This module provides parsers for extracting search results from HTML content
//! and other formats returned by search engines.

pub mod baidu;
pub mod base;
pub mod bing;
pub mod brave;
pub mod duckduckgo;
pub mod google;
pub mod sogou_weixin;

use crate::search::types::SearchEngineType;

// Re-export parser types
pub use baidu::BaiduParser;
pub use base::BaseParser;
pub use bing::BingParser;
pub use brave::BraveParser;
pub use duckduckgo::DuckDuckGoParser;
pub use google::GoogleParser;
pub use sogou_weixin::SogouWeixinParser;

/// Factory for creating parsers based on search engine type
pub struct ParserFactory;

impl ParserFactory {
    pub fn new() -> Self {
        Self
    }

    /// Get a parser for the given search engine type
    pub fn get_parser(&self, engine_type: &SearchEngineType) -> Box<dyn BaseParser> {
        match engine_type {
            // Web query parsers (HTML-based)
            SearchEngineType::Bing => Box::new(BingParser::new()),
            SearchEngineType::DuckDuckGo => Box::new(DuckDuckGoParser::new()),
            SearchEngineType::Google => Box::new(GoogleParser::new()),
            SearchEngineType::BraveSearch => Box::new(BraveParser::new()),
            SearchEngineType::Baidu => Box::new(BaiduParser::new()),
            SearchEngineType::SougouWeixin => Box::new(SogouWeixinParser::new()),
        }
    }
}

impl Default for ParserFactory {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parser_factory() {
        let factory = ParserFactory::new();

        // Test that we get the correct parser for each engine type
        let bing_parser = factory.get_parser(&SearchEngineType::Bing);
        assert_eq!(bing_parser.name(), "BingParser");

        let duckduckgo_parser = factory.get_parser(&SearchEngineType::DuckDuckGo);
        assert_eq!(duckduckgo_parser.name(), "DuckDuckGoParser");

        let google_parser = factory.get_parser(&SearchEngineType::Google);
        assert_eq!(google_parser.name(), "GoogleParser");

        let brave_parser = factory.get_parser(&SearchEngineType::BraveSearch);
        assert_eq!(brave_parser.name(), "BraveParser");

        let baidu_parser = factory.get_parser(&SearchEngineType::Baidu);
        assert_eq!(baidu_parser.name(), "BaiduParser");
    }

    #[test]
    fn test_parser_support() {
        let factory = ParserFactory::new();

        // Test that each parser supports its own engine type
        let parsers = vec![
            ("BingParser", factory.get_parser(&SearchEngineType::Bing)),
            (
                "DuckDuckGoParser",
                factory.get_parser(&SearchEngineType::DuckDuckGo),
            ),
            (
                "GoogleParser",
                factory.get_parser(&SearchEngineType::Google),
            ),
            (
                "BraveParser",
                factory.get_parser(&SearchEngineType::BraveSearch),
            ),
            ("BaiduParser", factory.get_parser(&SearchEngineType::Baidu)),
        ];

        for (name, parser) in parsers {
            assert!(
                parser.supports(&SearchEngineType::Bing)
                    || parser.supports(&SearchEngineType::DuckDuckGo)
                    || parser.supports(&SearchEngineType::Google)
                    || parser.supports(&SearchEngineType::BraveSearch)
                    || parser.supports(&SearchEngineType::Baidu),
                "Parser {name} should support at least one engine type"
            );
        }
    }

    #[test]
    fn test_all_parsers_with_different_limits() {
        let factory = ParserFactory::new();
        let html = "<html><body>Test content</body></html>";

        let parsers = vec![
            ("BingParser", factory.get_parser(&SearchEngineType::Bing)),
            (
                "GoogleParser",
                factory.get_parser(&SearchEngineType::Google),
            ),
            (
                "DuckDuckGoParser",
                factory.get_parser(&SearchEngineType::DuckDuckGo),
            ),
            (
                "BraveParser",
                factory.get_parser(&SearchEngineType::BraveSearch),
            ),
            ("BaiduParser", factory.get_parser(&SearchEngineType::Baidu)),
        ];

        for (name, parser) in parsers {
            assert_eq!(parser.name(), name);

            // Test with different limits
            for limit in [1, 5, 10] {
                let results = parser.parse(html, limit).unwrap();
                assert!(results.len() <= limit);
                assert!(results.len() <= 10); // All our mock parsers limit to 10

                // Verify ranking is correct
                for (i, result) in results.iter().enumerate() {
                    assert_eq!(result.rank, i + 1);
                }
            }
        }
    }
}