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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
//! Search and filter operations. Implements `impl App` continuation with
//! query mode entry/exit, fuzzy filter, scope computation, and the snippet
//! search helper.
use std::collections::HashSet;
use super::{HostListItem, PingStatus};
use crate::app::App;
/// Search mode state.
#[derive(Default)]
pub struct SearchState {
pub(in crate::app) query: Option<String>,
pub(in crate::app) filtered_indices: Vec<usize>,
pub(in crate::app) filtered_pattern_indices: Vec<usize>,
pub(in crate::app) pre_search_selection: Option<usize>,
/// When a group tab is active, holds the host indices visible in that group.
/// Search results are intersected with this set to scope the search.
pub(in crate::app) scope_indices: Option<HashSet<usize>>,
}
impl SearchState {
pub fn query(&self) -> Option<&str> {
self.query.as_deref()
}
pub fn filtered_indices(&self) -> &[usize] {
&self.filtered_indices
}
pub fn filtered_pattern_indices(&self) -> &[usize] {
&self.filtered_pattern_indices
}
pub fn scope_indices(&self) -> Option<&HashSet<usize>> {
self.scope_indices.as_ref()
}
pub fn set_query(&mut self, value: Option<String>) {
self.query = value;
}
pub fn clear_filtered_indices(&mut self) {
self.filtered_indices.clear();
}
pub fn clear_filtered_pattern_indices(&mut self) {
self.filtered_pattern_indices.clear();
}
/// Append a char to the query string. No-op when the query is inactive.
pub fn push_query_char(&mut self, c: char) {
if let Some(q) = self.query.as_mut() {
q.push(c);
}
}
/// Pop the trailing char from the query string. No-op when the query is inactive.
pub fn pop_query_char(&mut self) {
if let Some(q) = self.query.as_mut() {
q.pop();
}
}
}
impl App {
/// Compute the search scope from the current display list when group-filtered.
fn compute_search_scope(&self) -> Option<HashSet<usize>> {
self.hosts_state.group_filter.as_ref()?;
Some(
self.hosts_state
.display_list
.iter()
.filter_map(|item| {
if let HostListItem::Host { index } = item {
Some(*index)
} else {
None
}
})
.collect(),
)
}
/// Enter search mode.
pub fn start_search(&mut self) {
self.search.pre_search_selection = self.ui.list_state.selected();
self.search.scope_indices = self.compute_search_scope();
self.search.query = Some(String::new());
self.apply_filter();
}
/// Start search with an initial query (for positional arg).
pub fn start_search_with(&mut self, query: &str) {
self.search.pre_search_selection = self.ui.list_state.selected();
self.search.scope_indices = self.compute_search_scope();
self.search.query = Some(query.to_string());
self.apply_filter();
}
/// Cancel search mode and restore normal view.
pub fn cancel_search(&mut self) {
self.ping.filter_down_only = false;
self.search.query = None;
self.search.filtered_indices.clear();
self.search.filtered_pattern_indices.clear();
self.search.scope_indices = None;
// Restore pre-search position (bounds-checked)
if let Some(pos) = self.search.pre_search_selection.take() {
if pos < self.hosts_state.display_list.len() {
self.ui.list_state.select(Some(pos));
} else if let Some(first) = self.hosts_state.display_list.iter().position(|item| {
matches!(
item,
HostListItem::Host { .. } | HostListItem::Pattern { .. }
)
}) {
self.ui.list_state.select(Some(first));
}
}
}
/// Apply the current search query to filter hosts.
pub fn apply_filter(&mut self) {
log::debug!(
"[purple] apply_filter: query={:?} down_only={} scope={}",
self.search.query.as_deref().unwrap_or(""),
self.ping.filter_down_only,
self.search.scope_indices.as_ref().map_or(0, |s| s.len())
);
// Filtered index lists drive the search-mode render path which also
// consumes the render cache; recompute fresh.
self.hosts_state.render_cache.invalidate();
let query = match &self.search.query {
Some(q) if !q.is_empty() => q.clone(),
Some(_) => {
self.search.filtered_indices = (0..self.hosts_state.list.len()).collect();
self.search.filtered_pattern_indices =
(0..self.hosts_state.patterns.len()).collect();
// Scope to group if active
if let Some(ref scope) = self.search.scope_indices {
self.search.filtered_indices.retain(|i| scope.contains(i));
}
if !self.ping.filter_down_only {
let total = self.search.filtered_indices.len()
+ self.search.filtered_pattern_indices.len();
if total == 0 {
self.ui.list_state.select(None);
} else {
self.ui.list_state.select(Some(0));
}
return;
}
// Fall through to down-only filtering below
String::new()
}
None => {
if !self.ping.filter_down_only {
return;
}
// No search query but down-only is active: start with all hosts
self.search.filtered_indices = (0..self.hosts_state.list.len()).collect();
self.search.filtered_pattern_indices = Vec::new();
// Scope to group if active
if let Some(ref scope) = self.search.scope_indices {
self.search.filtered_indices.retain(|i| scope.contains(i));
}
// Fall through to down-only filtering below
String::new()
}
};
if let Some(tag_exact) = query.strip_prefix("tag=") {
// Exact tag match (from tag picker), includes provider name and virtual "stale"/"vault"
let provider_config = &self.providers.config;
self.search.filtered_indices = self
.hosts_state
.list
.iter()
.enumerate()
.filter(|(_, host)| {
(super::eq_ci("stale", tag_exact) && host.stale.is_some())
|| (super::eq_ci("vault-ssh", tag_exact)
&& crate::vault_ssh::resolve_vault_role(
host.vault_ssh.as_deref(),
host.provider.as_deref(),
host.provider_label.as_deref(),
provider_config,
)
.is_some())
|| (super::eq_ci("vault-kv", tag_exact)
&& host
.askpass
.as_deref()
.map(|s| s.starts_with("vault:"))
.unwrap_or(false))
|| host
.provider_tags
.iter()
.chain(host.tags.iter())
.any(|t| super::eq_ci(t, tag_exact))
|| host
.provider
.as_ref()
.is_some_and(|p| super::eq_ci(p, tag_exact))
})
.map(|(i, _)| i)
.collect();
self.search.filtered_pattern_indices = self
.hosts_state
.patterns
.iter()
.enumerate()
.filter(|(_, p)| p.tags.iter().any(|t| super::eq_ci(t, tag_exact)))
.map(|(i, _)| i)
.collect();
} else if let Some(tag_query) = query.strip_prefix("tag:") {
// Fuzzy tag match (manual search), includes provider name and virtual "stale"/"vault".
// Space-separated terms are ANDed: every term must hit a tag/provider field.
let provider_config = &self.providers.config;
let terms: Vec<&str> = tag_query.split_whitespace().collect();
self.search.filtered_indices = self
.hosts_state
.list
.iter()
.enumerate()
.filter(|(_, host)| {
terms.iter().all(|term| {
(super::contains_ci("stale", term) && host.stale.is_some())
|| (super::contains_ci("vault-ssh", term)
&& crate::vault_ssh::resolve_vault_role(
host.vault_ssh.as_deref(),
host.provider.as_deref(),
host.provider_label.as_deref(),
provider_config,
)
.is_some())
|| (super::contains_ci("vault-kv", term)
&& host
.askpass
.as_deref()
.map(|s| s.starts_with("vault:"))
.unwrap_or(false))
|| host
.provider_tags
.iter()
.chain(host.tags.iter())
.any(|t| super::contains_ci(t, term))
|| host
.provider
.as_ref()
.is_some_and(|p| super::contains_ci(p, term))
})
})
.map(|(i, _)| i)
.collect();
self.search.filtered_pattern_indices = self
.hosts_state
.patterns
.iter()
.enumerate()
.filter(|(_, p)| {
terms
.iter()
.all(|term| p.tags.iter().any(|t| super::contains_ci(t, term)))
})
.map(|(i, _)| i)
.collect();
} else {
// Space-separated terms are ANDed: every term must match at least
// one field. Split once, not per host. No terms (whitespace-only
// query) matches everything, so a trailing space while typing does
// not blank the list.
let terms: Vec<&str> = query.split_whitespace().collect();
self.search.filtered_indices = self
.hosts_state
.list
.iter()
.enumerate()
.filter(|(_, host)| {
terms.iter().all(|term| {
super::contains_ci(&host.alias, term)
|| super::contains_ci(&host.hostname, term)
|| super::contains_ci(&host.user, term)
|| host
.provider_tags
.iter()
.chain(host.tags.iter())
.any(|t| super::contains_ci(t, term))
|| host
.provider
.as_ref()
.is_some_and(|p| super::contains_ci(p, term))
})
})
.map(|(i, _)| i)
.collect();
self.search.filtered_pattern_indices = self
.hosts_state
.patterns
.iter()
.enumerate()
.filter(|(_, p)| {
terms.iter().all(|term| {
super::contains_ci(&p.pattern, term)
|| p.tags.iter().any(|t| super::contains_ci(t, term))
})
})
.map(|(i, _)| i)
.collect();
}
// Scope results to the active group if set
if let Some(ref scope) = self.search.scope_indices {
self.search.filtered_indices.retain(|i| scope.contains(i));
}
// Post-filter: keep only unreachable hosts when down-only mode is active
if self.ping.filter_down_only {
self.search.filtered_indices.retain(|&idx| {
let alias = &self.hosts_state.list[idx].alias;
matches!(self.ping.status.get(alias), Some(PingStatus::Unreachable))
});
// Patterns can't be pinged, so hide them in down-only mode
self.search.filtered_pattern_indices.clear();
}
// Reset selection
let total_results =
self.search.filtered_indices.len() + self.search.filtered_pattern_indices.len();
log::debug!(
"[purple] apply_filter matched: hosts={} patterns={}",
self.search.filtered_indices.len(),
self.search.filtered_pattern_indices.len()
);
if total_results == 0 {
self.ui.list_state.select(None);
} else {
self.ui.list_state.select(Some(0));
}
}
/// Return indices of snippets matching the search query.
pub fn filtered_snippet_indices(&self) -> Vec<usize> {
crate::snippet::filtered_indices(self.snippets.store(), self.ui.snippet_search.as_deref())
}
}