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 .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}