Skip to main content

hypermail/
search.rs

1use std::collections::{HashMap, HashSet};
2use std::path::Path;
3
4use crate::config::Config;
5use crate::error::Result;
6use crate::message::EmailInfo;
7use crate::structs::EmailStore;
8
9type BigramIndex = HashMap<String, Vec<usize>>;
10
11pub fn build_bigram_index(store: &EmailStore) -> BigramIndex {
12    let mut index: BigramIndex = HashMap::new();
13
14    for (i, email) in store.emails.iter().enumerate() {
15        let text = extract_searchable_text(email);
16        let bigrams = extract_bigrams(&text);
17        for bigram in bigrams {
18            index.entry(bigram).or_default().push(i);
19        }
20    }
21
22    index
23}
24
25pub fn search_bigrams(query: &str, index: &BigramIndex, _store: &EmailStore) -> Vec<usize> {
26    let query_bigrams = extract_bigrams(query);
27    if query_bigrams.is_empty() {
28        return Vec::new();
29    }
30
31    let mut result_scores: HashMap<usize, usize> = HashMap::new();
32
33    for bigram in &query_bigrams {
34        if let Some(entries) = index.get(bigram) {
35            for &idx in entries {
36                *result_scores.entry(idx).or_default() += 1;
37            }
38        }
39    }
40
41    let threshold = query_bigrams.len().saturating_sub(1);
42    let mut results: Vec<(usize, usize)> =
43        result_scores.into_iter().filter(|(_, score)| *score >= threshold).collect();
44
45    results.sort_by_key(|b| std::cmp::Reverse(b.1));
46
47    results.into_iter().map(|(idx, _)| idx).collect()
48}
49
50fn extract_searchable_text(email: &EmailInfo) -> String {
51    let mut text = String::new();
52
53    if let Some(ref subject) = email.subject {
54        text.push_str(subject);
55        text.push(' ');
56    }
57    if let Some(ref name) = email.name {
58        text.push_str(name);
59        text.push(' ');
60    }
61    if let Some(ref addr) = email.email_addr {
62        text.push_str(addr);
63        text.push(' ');
64    }
65
66    for body in &email.bodylist.bodies {
67        if !body.attached && !body.header {
68            text.push_str(&body.line);
69            text.push(' ');
70        }
71    }
72
73    text
74}
75
76fn extract_bigrams(text: &str) -> Vec<String> {
77    let lower = text.to_lowercase();
78    let chars: Vec<char> =
79        lower.chars().filter(|c| c.is_alphanumeric() || c.is_whitespace()).collect();
80
81    let mut bigrams = HashSet::new();
82    for window in chars.windows(2) {
83        let bigram: String = window.iter().collect();
84        bigrams.insert(bigram);
85    }
86
87    bigrams.into_iter().collect()
88}
89
90pub fn write_search_index(store: &EmailStore, config: &Config) -> Result<String> {
91    let dir = config.dir.as_deref().unwrap_or(".");
92    let search_path = Path::new(dir).join("search_index.txt");
93
94    let mut content = String::new();
95    for email in &store.emails {
96        if email.is_deleted != 0 && config.delete_level < crate::config::DELETE_LEAVES_TEXT {
97            continue;
98        }
99        let text = extract_searchable_text(email);
100        let line = format!("{}|{}", email.msgnum, sanitize_for_search(&text));
101        content.push_str(&line);
102        content.push('\n');
103    }
104
105    std::fs::write(&search_path, &content)?;
106    crate::file_utils::apply_permissions(&search_path, config.filemode);
107    Ok(content)
108}
109
110fn sanitize_for_search(s: &str) -> String {
111    s.chars()
112        .filter(|c| c.is_alphanumeric() || c.is_whitespace() || *c == '.' || *c == '@' || *c == '-')
113        // one record per line: newlines in email text must not start a new record
114        .map(|c| if c.is_whitespace() { ' ' } else { c })
115        .collect()
116}
117
118#[cfg(test)]
119mod tests {
120    use super::*;
121    use crate::message::{Body, BodyChain, EmailInfo};
122
123    #[test]
124    fn test_sanitize_removes_newlines() {
125        assert_eq!(sanitize_for_search("a\n9999|evil\r\n"), "a 9999evil  ");
126    }
127
128    #[test]
129    fn test_search_index_omits_deleted_message_content() {
130        let dir = tempfile::tempdir().unwrap();
131        let mut store = EmailStore::new();
132        let mut deleted = make_email(1, "Private subject", "Private sender", "Private body");
133        deleted.is_deleted = 1;
134        store.add_email(deleted);
135        store.add_email(make_email(2, "Public subject", "Alice", "Public body"));
136        let config = Config {
137            dir: Some(dir.path().to_string_lossy().into_owned()),
138            delete_level: crate::config::DELETE_LEAVES_STUBS,
139            ..Default::default()
140        };
141        let content = write_search_index(&store, &config).unwrap();
142        assert!(!content.contains("Private"), "{content}");
143        assert!(content.contains("Public body"));
144        assert_eq!(content.lines().count(), 1);
145    }
146
147    #[cfg(unix)]
148    #[test]
149    fn test_search_index_uses_private_filemode() {
150        use std::os::unix::fs::PermissionsExt;
151        let dir = tempfile::tempdir().unwrap();
152        let config = Config {
153            dir: Some(dir.path().to_string_lossy().into_owned()),
154            filemode: 0o600,
155            ..Default::default()
156        };
157        write_search_index(&EmailStore::new(), &config).unwrap();
158        let mode = std::fs::metadata(dir.path().join("search_index.txt"))
159            .unwrap()
160            .permissions()
161            .mode();
162        assert_eq!(mode & 0o777, 0o600);
163    }
164
165    fn make_email(msgnum: i32, subject: &str, name: &str, body_text: &str) -> EmailInfo {
166        EmailInfo {
167            msgnum,
168            subject: Some(subject.to_string()),
169            name: Some(name.to_string()),
170            bodylist: BodyChain {
171                bodies: vec![Body {
172                    line: body_text.to_string(),
173                    html: false,
174                    header: false,
175                    parsed_header: false,
176                    attached: false,
177                    demimed: false,
178                    converted: false,
179                    msgnum,
180                }],
181            },
182            ..Default::default()
183        }
184    }
185
186    #[test]
187    fn test_bigram_extraction() {
188        let bigrams = extract_bigrams("hello");
189        assert!(bigrams.contains(&"he".to_string()));
190        assert!(bigrams.contains(&"el".to_string()));
191        assert!(bigrams.contains(&"ll".to_string()));
192        assert!(bigrams.contains(&"lo".to_string()));
193    }
194
195    #[test]
196    fn test_bigram_index() {
197        let mut store = EmailStore::new();
198        store.add_email(make_email(1, "Hello World", "Alice", "This is a test"));
199        store.add_email(make_email(2, "Goodbye World", "Bob", "Another test message"));
200
201        let index = build_bigram_index(&store);
202        assert!(index.contains_key("wo"));
203        assert!(index.contains_key("te"));
204    }
205
206    #[test]
207    fn test_search() {
208        let mut store = EmailStore::new();
209        store.add_email(make_email(1, "Hello World", "Alice", "This is a test message"));
210        store.add_email(make_email(2, "Goodbye World", "Bob", "Another different message"));
211
212        let index = build_bigram_index(&store);
213        let results = search_bigrams("hello", &index, &store);
214        assert_eq!(results.len(), 1);
215        assert_eq!(store.emails[results[0]].msgnum, 1);
216    }
217
218    #[test]
219    fn test_extract_searchable_text() {
220        let email = make_email(1, "Test Subject", "Alice", "Body content");
221        let text = extract_searchable_text(&email);
222        assert!(text.contains("Test Subject"));
223        assert!(text.contains("Alice"));
224        assert!(text.contains("Body content"));
225    }
226}