Initial commit
CI / test (macos-latest) (push) Canceled after 0s
CI / test (ubuntu-latest) (push) Canceled after 0s
CI / test (windows-latest) (push) Canceled after 0s
CI / release (macos-latest, aarch64-apple-darwin) (push) Canceled after 0s
CI / release (ubuntu-latest, x86_64-unknown-linux-gnu) (push) Canceled after 0s
CI / release (windows-latest, x86_64-pc-windows-msvc) (push) Canceled after 0s

This commit is contained in:
Torbjörn Molin committed 2026-10-21 08:52:46 +02:00
commit 0d94f2bf2e
28 files changed
+11076

No files matched your search

+327
View File
@@ -0,0 +1,327 @@
//! The "Find in files" tab.
use std::collections::HashSet;
use std::path::PathBuf;
use std::sync::Arc;
use std::sync::atomic::Ordering;
use egui::text::LayoutJob;
use egui::{Key, RichText, TextFormat, Ui};
use crate::grep::{self, GrepOptions, GrepShared};
use crate::job::{Generation, Notify};
use crate::passes::SearchQuery;
use crate::ui::log_tab::{fmt_num, fmt_size};
use crate::ui::palette;
pub enum GrepAction {
Open { path: PathBuf, offset: u64, query: SearchQuery },
Status(String),
}
#[derive(Clone, Copy)]
enum Row {
File(usize),
Hit(usize, usize),
}
pub struct GrepTab {
pub opts: GrepOptions,
folder_text: String,
max_mb_text: String,
generation: Generation,
shared: Option<Arc<GrepShared>>,
/// The query the current results were produced with.
ran: Option<GrepOptions>,
error: Option<String>,
collapsed: HashSet<usize>,
rows: Vec<Row>,
rows_key: (usize, usize),
selected: Option<usize>,
notify: Notify,
}
impl GrepTab {
pub fn new(folder: Option<PathBuf>, notify: Notify) -> Self {
let opts = GrepOptions { folder: folder.unwrap_or_default(), ..Default::default() };
Self {
folder_text: opts.folder.display().to_string(),
max_mb_text: String::new(),
opts,
generation: Generation::new(),
shared: None,
ran: None,
error: None,
collapsed: HashSet::new(),
rows: Vec::new(),
rows_key: (usize::MAX, 0),
selected: None,
notify,
}
}
pub fn title(&self) -> String {
match self.opts.folder.file_name() {
Some(n) => format!("Find in {}", n.to_string_lossy()),
None => "Find in files".into(),
}
}
pub fn set_folder(&mut self, folder: PathBuf) {
self.folder_text = folder.display().to_string();
self.opts.folder = folder;
}
pub fn start(&mut self) {
self.opts.folder = PathBuf::from(self.folder_text.trim());
self.opts.max_file_mb = self.max_mb_text.trim().parse().unwrap_or(0);
self.error = None;
self.collapsed.clear();
self.selected = None;
self.rows_key = (usize::MAX, 0);
if self.opts.query.text.is_empty() {
self.error = Some("Enter a pattern".into());
return;
}
if !self.opts.folder.is_dir() {
self.error = Some(format!("{} is not a folder", self.opts.folder.display()));
return;
}
match grep::spawn(self.opts.clone(), self.generation.bump(), self.notify.clone()) {
Ok(s) => {
self.shared = Some(s);
self.ran = Some(self.opts.clone());
}
Err(e) => self.error = Some(format!("{e:#}")),
}
}
pub fn cancel(&mut self) {
self.generation.cancel();
}
fn rebuild_rows(&mut self, files: &[grep::FileResult]) {
let key = (files.len(), self.collapsed.len());
if key == self.rows_key {
return;
}
self.rows_key = key;
self.rows.clear();
for (fi, f) in files.iter().enumerate() {
self.rows.push(Row::File(fi));
if !self.collapsed.contains(&fi) {
self.rows.extend((0..f.hits.len()).map(|hi| Row::Hit(fi, hi)));
}
}
}
pub fn show(&mut self, ui: &mut Ui) -> Vec<GrepAction> {
let mut actions = Vec::new();
egui::Panel::top("grep_inputs").show(ui, |ui| self.inputs(ui, &mut actions));
egui::CentralPanel::default().show(ui, |ui| self.results(ui, &mut actions));
actions
}
fn inputs(&mut self, ui: &mut Ui, _actions: &mut [GrepAction]) {
let mut go = false;
egui::Grid::new("grep_grid").num_columns(2).spacing([8.0, 4.0]).show(ui, |ui| {
ui.label("Folder");
ui.horizontal(|ui| {
ui.add(egui::TextEdit::singleline(&mut self.folder_text).desired_width(420.0));
if ui.button("Browse…").clicked()
&& let Some(d) = rfd::FileDialog::new().pick_folder()
{
self.folder_text = d.display().to_string();
}
});
ui.end_row();
ui.label("Pattern");
ui.horizontal(|ui| {
let r = ui.add(
egui::TextEdit::singleline(&mut self.opts.query.text)
.desired_width(320.0)
.hint_text("text or regex"),
);
go |= r.lost_focus() && ui.input(|i| i.key_pressed(Key::Enter));
ui.toggle_value(&mut self.opts.query.regex, ".*").on_hover_text("Regex");
ui.toggle_value(&mut self.opts.query.case_sensitive, "Aa").on_hover_text("Case sensitive");
ui.toggle_value(&mut self.opts.query.whole_word, "\\b").on_hover_text("Whole word");
});
ui.end_row();
ui.label("Include");
ui.horizontal(|ui| {
ui.add(egui::TextEdit::singleline(&mut self.opts.include).desired_width(180.0));
ui.label("Exclude");
ui.add(
egui::TextEdit::singleline(&mut self.opts.exclude).desired_width(140.0).hint_text("*.gz;old/**"),
);
});
ui.end_row();
ui.label("");
ui.horizontal(|ui| {
ui.checkbox(&mut self.opts.recursive, "Recursive");
ui.checkbox(&mut self.opts.respect_gitignore, "Respect .gitignore");
ui.checkbox(&mut self.opts.skip_binary, "Skip binary files");
ui.label("Max size (MB)");
ui.add(egui::TextEdit::singleline(&mut self.max_mb_text).desired_width(50.0).hint_text("any"));
});
ui.end_row();
});
ui.horizontal(|ui| {
let running = self.shared.as_ref().is_some_and(|s| !s.is_done());
if ui.button("🔍 Search").clicked() || go {
self.start();
}
if running && ui.button("Cancel").clicked() {
self.cancel();
if let Some(s) = &self.shared {
s.done.store(true, Ordering::Release);
}
}
if let Some(s) = self.shared.clone() {
let files = s.results.lock().unwrap();
let matches: usize = files.iter().map(|f| f.hits.len()).sum();
let searched = s.files_searched.load(Ordering::Relaxed);
ui.label(format!(
"{} matches in {} of {} files{}",
fmt_num(matches as u64),
fmt_num(files.len() as u64),
fmt_num(searched as u64),
if running { " (searching…)" } else { "" }
));
if s.capped.load(Ordering::Relaxed) || files.iter().any(|f| f.truncated) {
ui.colored_label(ui.visuals().warn_fg_color, "results capped (10,000 per file, 1M total)");
}
let errs = s.errors.lock().unwrap();
if !errs.is_empty() {
ui.colored_label(ui.visuals().warn_fg_color, format!("{} errors", errs.len()))
.on_hover_text(errs.iter().take(20).cloned().collect::<Vec<_>>().join("\n"));
}
drop(errs);
if !files.is_empty() {
if ui.button("📋 Copy").on_hover_text("Copy as path:line:text").clicked() {
ui.ctx().copy_text(grep::export_text(&files));
}
if ui.button("Export…").clicked()
&& let Some(p) = rfd::FileDialog::new().set_file_name("grep-results.txt").save_file()
{
let _ = std::fs::write(p, grep::export_text(&files));
}
}
}
if let Some(e) = &self.error {
ui.colored_label(ui.visuals().error_fg_color, e);
}
});
}
fn results(&mut self, ui: &mut Ui, actions: &mut Vec<GrepAction>) {
let Some(shared) = self.shared.clone() else {
ui.weak("Pick a folder and a pattern, then press Search. Double-click a hit to open it.");
return;
};
let files = shared.results.lock().unwrap();
self.rebuild_rows(&files);
let root = self.ran.as_ref().map(|o| o.folder.clone()).unwrap_or_default();
let query = self.ran.as_ref().map(|o| o.query.clone()).unwrap_or_default();
// Selectable labels are padded; the virtualized rows must use the same height.
let pad = ui.spacing().button_padding.y * 2.0;
let row_h = ui.spacing().interact_size.y.max(ui.text_style_height(&egui::TextStyle::Monospace) + pad);
let dark = ui.visuals().dark_mode;
let font = egui::FontId::monospace(ui.text_style_height(&egui::TextStyle::Monospace) - 1.0);
let text_color = ui.visuals().text_color();
let weak = ui.visuals().weak_text_color();
let mut open: Option<(usize, usize)> = None;
let mut toggle: Option<usize> = None;
// Keyboard: Up/Down to move, Enter to open.
if !ui.ctx().egui_wants_keyboard_input() && !self.rows.is_empty() {
let (up, down, enter) =
ui.input(|i| (i.key_pressed(Key::ArrowUp), i.key_pressed(Key::ArrowDown), i.key_pressed(Key::Enter)));
let cur = self.selected.unwrap_or(0);
if down {
self.selected = Some((cur + 1).min(self.rows.len() - 1));
}
if up {
self.selected = Some(cur.saturating_sub(1));
}
if enter && let Some(Row::Hit(f, h)) = self.selected.and_then(|s| self.rows.get(s).copied()) {
open = Some((f, h));
}
}
egui::ScrollArea::both().auto_shrink(false).show_rows(ui, row_h, self.rows.len(), |ui, range| {
for i in range {
let selected = self.selected == Some(i);
match self.rows[i] {
Row::File(fi) => {
let f = &files[fi];
let arrow = if self.collapsed.contains(&fi) { "▶" } else { "▼" };
let text = format!(
"{arrow} {} ({} matches{}, {})",
grep::display_path(&root, &f.path),
fmt_num(f.hits.len() as u64),
if f.truncated { "+" } else { "" },
fmt_size(f.size)
);
let r = ui.selectable_label(selected, RichText::new(text).strong());
if r.clicked() {
self.selected = Some(i);
toggle = Some(fi);
}
}
Row::Hit(fi, hi) => {
let h = &files[fi].hits[hi];
let mut job = LayoutJob::default();
job.append(&format!("{:>8}: ", h.line_number), 16.0, TextFormat::simple(font.clone(), weak));
let mut pos = 0;
let (bg, fg) = palette::match_colors("amber", dark);
for r in &h.ranges {
if r.start < pos || r.end > h.text.len() {
continue;
}
job.append(&h.text[pos..r.start], 0.0, TextFormat::simple(font.clone(), text_color));
job.append(
&h.text[r.clone()],
0.0,
TextFormat { background: bg, ..TextFormat::simple(font.clone(), fg) },
);
pos = r.end;
}
job.append(&h.text[pos..], 0.0, TextFormat::simple(font.clone(), text_color));
job.wrap.max_width = f32::INFINITY;
let r = ui.selectable_label(selected, job);
if r.clicked() {
self.selected = Some(i);
}
if r.double_clicked() {
open = Some((fi, hi));
}
r.context_menu(|ui| {
if ui.button("Open in viewer").clicked() {
open = Some((fi, hi));
ui.close();
}
if ui.button("Copy line").clicked() {
ui.ctx().copy_text(h.text.clone());
ui.close();
}
});
}
}
}
});
if let Some(fi) = toggle
&& !self.collapsed.remove(&fi)
{
self.collapsed.insert(fi);
}
if let Some((fi, hi)) = open {
let f = &files[fi];
actions.push(GrepAction::Open { path: f.path.clone(), offset: f.hits[hi].offset, query: query.clone() });
}
}
}