Merge pull request #206 from tanishq-dubey/master

Feature: Change File Search to use `mfind`

Author: unsecretised

Cargo.lock

@@ -15,7 +15,6 @@ emojis = "0.8.0"
 global-hotkey = "0.7.0"
 iced = { version = "0.14.0", features = ["image", "tokio"] }
 icns = "0.3.1"
-ignore = "0.4.25"
 image = { version = "0.25.9", features = ["tiff"] }
 libc = "0.2.180"
 log = "0.4.29"

Cargo.toml

@@ -21,6 +21,12 @@ pub const WINDOW_WIDTH: f32 = 500.;
 /// The default window height
 pub const DEFAULT_WINDOW_HEIGHT: f32 = 100.;
 
+/// Maximum file search results returned by a single mdfind invocation.
+pub const FILE_SEARCH_MAX_RESULTS: u32 = 400;
+
+/// Number of results to accumulate before flushing a batch to the UI.
+pub const FILE_SEARCH_BATCH_SIZE: u32 = 10;
+
 /// The rustcast descriptor name to be put for all rustcast commands
 pub const RUSTCAST_DESC_NAME: &str = "Utility";
 
@@ -85,6 +91,9 @@ pub enum Message {
     SwitchToPage(Page),
     ClipboardHistory(ClipBoardContentType),
     ChangeFocus(ArrowKey, u32),
+    FileSearchResult(Vec<App>),
+    FileSearchClear,
+    SetFileSearchSender(tokio::sync::watch::Sender<(String, Vec<String>)>),
     DebouncedSearch(Id),
 }
 

src/app.rs

@@ -27,6 +27,7 @@ use log::{info, warn};
 use objc2::rc::Retained;
 use objc2_app_kit::NSRunningApplication;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+use tokio::io::AsyncBufReadExt;
 use tray_icon::TrayIcon;
 
 use std::collections::HashMap;
@@ -130,6 +131,7 @@ pub struct Tile {
     sender: Option<ExtSender>,
     page: Page,
     pub height: f32,
+    pub file_search_sender: Option<tokio::sync::watch::Sender<(String, Vec<String>)>>,
     debouncer: Debouncer,
 }
 
@@ -182,6 +184,7 @@ impl Tile {
             Subscription::run(check_version),
             Subscription::run(handle_hot_reloading),
             Subscription::run(handle_clipboard_history),
+            Subscription::run(handle_file_search),
             window::close_events().map(Message::HideWindow),
             keyboard::listen().filter_map(|event| {
                 if let keyboard::Event::KeyPressed { key, modifiers, .. } = event {
@@ -377,6 +380,145 @@ fn handle_clipboard_history() -> impl futures::Stream<Item = Message> {
     })
 }
 
+/// Read mdfind stdout line-by-line, sending batched results to the UI.
+///
+/// Returns when stdout reaches EOF, the receiver signals a new query, or
+/// max results are reached. Caller is responsible for process lifetime.
+async fn read_mdfind_results(
+    stdout: tokio::process::ChildStdout,
+    home_dir: &str,
+    receiver: &mut tokio::sync::watch::Receiver<(String, Vec<String>)>,
+    output: &mut iced::futures::channel::mpsc::Sender<Message>,
+) {
+    use crate::app::{FILE_SEARCH_BATCH_SIZE, FILE_SEARCH_MAX_RESULTS};
+
+    let mut reader = tokio::io::BufReader::new(stdout);
+    let mut batch: Vec<crate::app::apps::App> = Vec::with_capacity(FILE_SEARCH_BATCH_SIZE as usize);
+    let mut total_sent: u32 = 0;
+
+    loop {
+        let mut line = String::new();
+        let read_result = tokio::select! {
+            result = reader.read_line(&mut line) => result,
+            _ = receiver.changed() => {
+                // New query arrived — caller will handle it.
+                break;
+            }
+        };
+
+        match read_result {
+            Ok(0) => {
+                // EOF — flush remaining batch.
+                if !batch.is_empty() {
+                    output
+                        .send(Message::FileSearchResult(std::mem::take(&mut batch)))
+                        .await
+                        .ok();
+                }
+                break;
+            }
+            Ok(_) => {
+                if let Some(app) = crate::commands::path_to_app(line.trim(), home_dir) {
+                    batch.push(app);
+                    total_sent += 1;
+                }
+                if batch.len() as u32 >= FILE_SEARCH_BATCH_SIZE {
+                    output
+                        .send(Message::FileSearchResult(std::mem::take(&mut batch)))
+                        .await
+                        .ok();
+                }
+                if total_sent >= FILE_SEARCH_MAX_RESULTS {
+                    if !batch.is_empty() {
+                        output
+                            .send(Message::FileSearchResult(std::mem::take(&mut batch)))
+                            .await
+                            .ok();
+                    }
+                    break;
+                }
+            }
+            Err(_) => break,
+        }
+    }
+}
+
+/// Async subscription that spawns `mdfind` for file search queries.
+///
+/// Uses a `watch` channel so the Tile can push new (query, dirs) pairs.
+/// Each query change cancels any running `mdfind` and starts a fresh one.
+fn handle_file_search() -> impl futures::Stream<Item = Message> {
+    stream::channel(100, async |mut output| {
+        let (sender, mut receiver) =
+            tokio::sync::watch::channel((String::new(), Vec::<String>::new()));
+        output
+            .send(Message::SetFileSearchSender(sender))
+            .await
+            .expect("Failed to send file search sender.");
+
+        let home_dir = std::env::var("HOME").unwrap_or_else(|_| "/".to_string());
+        assert!(!home_dir.is_empty(), "HOME must not be empty.");
+
+        let mut child: Option<tokio::process::Child> = None;
+
+        loop {
+            if receiver.changed().await.is_err() {
+                return;
+            }
+            receiver.borrow_and_update();
+
+            // Kill previous mdfind if still running.
+            if let Some(ref mut proc) = child {
+                proc.kill().await.ok();
+                proc.wait().await.ok();
+            }
+            child = None;
+
+            let (query, dirs) = receiver.borrow().clone();
+            assert!(query.len() < 1024, "Query too long.");
+
+            if query.len() < 2 {
+                output.send(Message::FileSearchClear).await.ok();
+                continue;
+            }
+
+            // The query is passed as a -name argument to mdfind. mdfind interprets
+            // this as a substring match on filenames — not as a glob or shell expression.
+            // Passed via args (not shell), so no shell injection risk.
+            // When dirs is empty, omit -onlyin so mdfind searches system-wide.
+            let mut args: Vec<String> = vec!["-name".to_string(), query.clone()];
+            for dir in &dirs {
+                let expanded = dir.replace("~", &home_dir);
+                args.push("-onlyin".to_string());
+                args.push(expanded);
+            }
+
+            let spawn_result = tokio::process::Command::new("mdfind")
+                .args(&args)
+                .stdout(std::process::Stdio::piped())
+                .stderr(std::process::Stdio::null())
+                .kill_on_drop(true)
+                .spawn();
+
+            let mut proc = match spawn_result {
+                Ok(p) => p,
+                Err(err) => {
+                    warn!("Failed to spawn mdfind: {err}");
+                    continue;
+                }
+            };
+
+            let stdout = match proc.stdout.take() {
+                Some(s) => s,
+                None => continue,
+            };
+            child = Some(proc);
+
+            read_mdfind_results(stdout, &home_dir, &mut receiver, &mut output).await;
+        }
+    })
+}
+
 /// Handles the rx / receiver for sending and receiving messages
 fn handle_recipient() -> impl futures::Stream<Item = Message> {
     stream::channel(100, async |mut output| {

src/app/tile.rs

@@ -83,6 +83,7 @@ pub fn new(hotkey: HotKey, config: &Config) -> (Tile, Task<Message>) {
             sender: None,
             page: Page::Main,
             height: DEFAULT_WINDOW_HEIGHT,
+            file_search_sender: None,
             debouncer: Debouncer::new(config.debounce_delay),
         },
         Task::batch([open.map(|_| Message::OpenWindow)]),

src/app/tile/elm.rs

@@ -27,7 +27,6 @@ use crate::app::tile::AppIndex;
 use crate::app::{Message, Page, tile::Tile};
 use crate::calculator::Expr;
 use crate::commands::Function;
-use crate::commands::search_for_file;
 use crate::config::Config;
 use crate::debounce::DebouncePolicy;
 use crate::unit_conversion;
@@ -432,6 +431,37 @@ pub fn handle_update(tile: &mut Tile, message: Message) -> Task<Message> {
             Task::none()
         }
 
+        Message::SetFileSearchSender(sender) => {
+            tile.file_search_sender = Some(sender);
+            Task::none()
+        }
+
+        Message::FileSearchResult(apps) => {
+            assert!(apps.len() <= 50, "Batch must not exceed 50 results.");
+            if tile.page == Page::FileSearch {
+                let prev_display_count = std::cmp::min(5, tile.results.len());
+                tile.results.extend(apps);
+                let new_display_count = std::cmp::min(5, tile.results.len());
+                // Only resize when the visible row count changes (max 5).
+                if new_display_count != prev_display_count && new_display_count > 0 {
+                    return window::latest().map(move |x| {
+                        Message::ResizeWindow(
+                            x.unwrap(),
+                            ((new_display_count * 55) + 35 + DEFAULT_WINDOW_HEIGHT as usize) as f32,
+                        )
+                    });
+                }
+            }
+            Task::none()
+        }
+
+        Message::FileSearchClear => {
+            if tile.page == Page::FileSearch {
+                tile.results.clear();
+            }
+            Task::none()
+        }
+
         Message::SearchQueryChanged(input, id) => {
             tile.focus_id = 0;
 
@@ -589,15 +619,20 @@ fn execute_query(tile: &mut Tile, id: Id) -> Task<Message> {
         }
     }
 
-    if tile.page != Page::FileSearch {
-        tile.handle_search_query_changed();
-    } else {
-        tile.results = search_for_file(
-            &tile.query_lc,
-            tile.config.search_dirs.iter().map(|x| x.as_str()).collect(),
-        );
+    if tile.page == Page::FileSearch {
+        // File search is async — dispatch to the mdfind subscription and
+        // return immediately. Results arrive via FileSearchResult messages.
+        if let Some(ref sender) = tile.file_search_sender {
+            tile.results.clear();
+            sender
+                .send((tile.query_lc.clone(), tile.config.search_dirs.clone()))
+                .ok();
+        }
+        return task;
     }
 
+    tile.handle_search_query_changed();
+
     if !tile.results.is_empty() {
         tile.results.par_sort_by_key(|x| -x.ranking);