fix ci

Author: dmtrKovalenko

crates/fff-core/src/background_watcher.rs

@@ -686,11 +686,9 @@ fn handle_debounced_events(
     if need_full_git_rescan || !files_to_update_git_status.is_empty() {
         let sp = shared_picker.clone();
         let sf = shared_frecency.clone();
-        let git_workdir = repo.as_ref().map(|r| {
-            r.workdir()
-                .unwrap_or_else(|| r.path())
-                .to_path_buf()
-        });
+        let git_workdir = repo
+            .as_ref()
+            .map(|r| r.workdir().unwrap_or_else(|| r.path()).to_path_buf());
         let full_rescan = need_full_git_rescan;
         let need_picker_rescan = need_full_rescan;
         let files = files_to_update_git_status;

crates/fff-core/src/bigram_filter.rs

@@ -724,7 +724,7 @@ pub(crate) fn build_bigram_index(
 
     // in progress bigram walk + rust's ignore crate allocates shit ton of garbage memory
     // all custom allocators would think this is available resource while we do not allocate
-    // afte the sync, so it's very important to let the unused memory go back to the OS
+    // after the sync, so it's very important to let the unused memory go back to the OS
     crate::file_picker::hint_allocator_collect();
 
     index

crates/fff-core/src/file_picker.rs

@@ -1414,7 +1414,7 @@ impl FilePicker {
         let overlay = self.sync_data.bigram_overlay.as_ref().map(Arc::clone);
         let pos = slot.index();
 
-        // this is the only way to actaully know if the file is on disk, we CAN NOT
+        // this is the only way to actually know if the file is on disk, we CAN NOT
         // rely on the watcher to proive the latest state of the file, do the actual check
         let metadata = match std::fs::metadata(path) {
             Ok(m) => {
@@ -1503,6 +1503,9 @@ impl FilePicker {
 
     fn tombstone_file(&mut self, index: usize) {
         let file = &mut self.sync_data.files[index];
+        if file.is_deleted() {
+            return;
+        }
 
         file.set_deleted(true);
         file.invalidate_mmap(&self.cache_budget);
@@ -1520,13 +1523,16 @@ impl FilePicker {
 
     fn untombstone_file(&mut self, index: usize) {
         let file = &mut self.sync_data.files[index];
+        if !file.is_deleted() {
+            return;
+        }
         file.set_deleted(false);
 
         self.sync_data.live_count += 1;
     }
 
     /// Marks file as deleted, make sure that if you call this yourself these changes can be reverted
-    /// by the internal mechanics if the file actully exists on the disk, use only if you know that
+    /// by the internal mechanics if the file actually exists on the disk, use only if you know that
     /// the file going to be disapperaed or if you do not have the watcher installed
     pub fn remove_file_by_path(&mut self, path: impl AsRef<Path>) -> bool {
         let path = path.as_ref();
@@ -1939,7 +1945,7 @@ pub(crate) fn warmup_mmaps(
     base_path: &Path,
     arena: ArenaPtr,
 ) {
-    // for most of the use cases mmaps limit would be signficantly smaller than arepo
+    // for most of the use cases mmaps limit would be significantly smaller than arepo
     for file in files.iter() {
         if file.is_likely_hot()
             || file.is_binary()

crates/fff-core/src/grep.rs

@@ -1655,8 +1655,11 @@ fn fuzzy_grep_search<'a>(
                     return None;
                 }
 
-
-                let file_arena = if file.is_overflow() { overflow_arena } else { arena };
+                let file_arena = if file.is_overflow() {
+                    overflow_arena
+                } else {
+                    arena
+                };
                 let file_bytes = file.get_content_for_search(buf, file_arena, base_path, budget)?;
 
                 // File-level prefilter: check if enough distinct needle chars

crates/fff-core/src/scan.rs

@@ -315,7 +315,7 @@ impl ScanJob {
         let budget: &ContentCacheBudget = &unsafe_snapshot.budget;
         let files: &[crate::types::FileItem] = &unsafe_snapshot.files[..unsafe_snapshot.base_count];
 
-        // unified bigram and warmup_mmaps in one go, it's important to reuse open files as much as possible 
+        // unified bigram and warmup_mmaps in one go, it's important to reuse open files as much as possible
         if config.content_indexing && !signals.cancelled.load(Ordering::Acquire) {
             let indexable_files = &files[..unsafe_snapshot.indexable_count.min(files.len())];
             let index = build_bigram_index(

crates/fff-core/tests/fuzz_real_repos.rs

@@ -1,7 +1,7 @@
 //! Proptest-driven fuzz test against real GitHub repos with a live watcher.
 //!
 //! Clones real repository, runs the simulated close to real user sereies of file system ewvents and
-//! verifies that fff can still find the correct files. Test cases are randomzied and preserved
+//! verifies that fff can still find the correct files. Test cases are randomized and preserved
 //! using proptest
 //!
 //! Run:
@@ -104,7 +104,11 @@ fn copy_repo_to_workdir(cached: &Path, workdir: &Path) {
         .arg(workdir)
         .output()
         .expect("cp -r failed");
-    assert!(out.status.success(), "cp -r failed: {}", String::from_utf8_lossy(&out.stderr));
+    assert!(
+        out.status.success(),
+        "cp -r failed: {}",
+        String::from_utf8_lossy(&out.stderr)
+    );
 }
 
 fn collect_text_files(base: &Path) -> Vec<PathBuf> {
@@ -156,7 +160,9 @@ fn collect_text_files(base: &Path) -> Vec<PathBuf> {
         if path.is_empty() {
             continue;
         }
-        let Ok(s) = std::str::from_utf8(path) else { continue };
+        let Ok(s) = std::str::from_utf8(path) else {
+            continue;
+        };
         if ignored_set.contains(s) {
             continue;
         }
@@ -199,7 +205,9 @@ fn inject_marker(path: &Path, marker: &str, seed: u32) -> Option<String> {
 /// Revert a file by restoring the original line at the same position
 /// where inject_marker placed the marker.
 fn revert_marker(path: &Path, marker: &str, original_line: &str) {
-    let Ok(content) = fs::read_to_string(path) else { return };
+    let Ok(content) = fs::read_to_string(path) else {
+        return;
+    };
     let marker_line = format!("// {marker}");
     let result: String = content
         .lines()
@@ -293,9 +301,8 @@ fn run_scenario(ops: &[Op]) {
     // Stream fff logs at info+ level by default. Override with RUST_LOG.
     let _ = tracing_subscriber::fmt()
         .with_env_filter(
-            tracing_subscriber::EnvFilter::try_from_default_env().unwrap_or_else(|_| {
-                tracing_subscriber::EnvFilter::new("warn,fff_search=info")
-            }),
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("warn,fff_search=info")),
         )
         .with_test_writer()
         .try_init();
@@ -389,7 +396,13 @@ fn run_scenario(ops: &[Op]) {
                 let content = fs::read_to_string(&path).unwrap_or_default();
                 let new_content = content
                     .lines()
-                    .map(|l| if l == old_marker_line { format!("// {new_marker}") } else { l.to_string() })
+                    .map(|l| {
+                        if l == old_marker_line {
+                            format!("// {new_marker}")
+                        } else {
+                            l.to_string()
+                        }
+                    })
                     .collect::<Vec<_>>()
                     .join("\n")
                     + "\n";
@@ -426,7 +439,13 @@ fn run_scenario(ops: &[Op]) {
                     let content = fs::read_to_string(target).unwrap_or_default();
                     let new_content = content
                         .lines()
-                        .map(|l| if l == old_marker_line { format!("// {marker}") } else { l.to_string() })
+                        .map(|l| {
+                            if l == old_marker_line {
+                                format!("// {marker}")
+                            } else {
+                                l.to_string()
+                            }
+                        })
                         .collect::<Vec<_>>()
                         .join("\n")
                         + "\n";
@@ -436,8 +455,7 @@ fn run_scenario(ops: &[Op]) {
                     tracked[pos].last_write_sec = epoch_secs();
                 } else {
                     // First edit: inject marker at a deterministic line
-                    let original = inject_marker(target, &marker, *seed)
-                        .unwrap_or_default();
+                    let original = inject_marker(target, &marker, *seed).unwrap_or_default();
                     tracked.push(TrackedFile {
                         relative,
                         marker,
@@ -540,7 +558,9 @@ fn run_scenario(ops: &[Op]) {
                             last_failure = Some(format!(
                                 "{mode_name} grep for {:?} in {:?} not found\n\
                                  is_created={} exists={} on_disk_has_marker={}",
-                                tf.marker, tf.relative, tf.is_created,
+                                tf.marker,
+                                tf.relative,
+                                tf.is_created,
                                 workdir.join(&tf.relative).exists(),
                                 fs::read_to_string(workdir.join(&tf.relative))
                                     .map(|c| c.contains(&tf.marker))
@@ -561,9 +581,7 @@ fn run_scenario(ops: &[Op]) {
                             let found = grep_finds(picker, dead, GrepMode::PlainText);
                             drop(guard);
                             if found {
-                                last_failure = Some(format!(
-                                    "dead marker {dead:?} still findable"
-                                ));
+                                last_failure = Some(format!("dead marker {dead:?} still findable"));
                                 all_ok = false;
                                 break;
                             }
@@ -578,9 +596,8 @@ fn run_scenario(ops: &[Op]) {
                             let files = grep_file_list(picker, ig, GrepMode::PlainText);
                             drop(guard);
                             if !files.is_empty() {
-                                last_failure = Some(format!(
-                                    "ignored marker {ig:?} found in {files:?}"
-                                ));
+                                last_failure =
+                                    Some(format!("ignored marker {ig:?} found in {files:?}"));
                                 all_ok = false;
                                 break;
                             }
@@ -590,7 +607,9 @@ fn run_scenario(ops: &[Op]) {
                     if all_ok {
                         eprintln!(
                             "  op[{op_idx}] verify OK: {mode_name} mode, {} live, {} dead, {} ignored",
-                            tracked.len(), dead_markers.len(), ignored_markers.len(),
+                            tracked.len(),
+                            dead_markers.len(),
+                            ignored_markers.len(),
                         );
                         break;
                     }
@@ -616,8 +635,12 @@ fn run_scenario(ops: &[Op]) {
         let guard = shared_picker.read().unwrap();
         let picker = guard.as_ref().unwrap();
 
-        let live_ok = tracked.iter().all(|tf| grep_finds(picker, &tf.marker, GrepMode::PlainText));
-        let dead_ok = dead_markers.iter().all(|d| !grep_finds(picker, d, GrepMode::PlainText));
+        let live_ok = tracked
+            .iter()
+            .all(|tf| grep_finds(picker, &tf.marker, GrepMode::PlainText));
+        let dead_ok = dead_markers
+            .iter()
+            .all(|d| !grep_finds(picker, d, GrepMode::PlainText));
         drop(guard);
 
         if live_ok && dead_ok {

crates/fff-nvim/Cargo.toml

@@ -96,7 +96,7 @@ tempfile = "3.8"
 
 [[bench]]
 name = "indexing_and_search"
-path = "benches/fuzzy_seearch_bench.rs"
+path = "benches/fuzzy_search_bench.rs"
 harness = false
 
 [[bench]]