release:add more tests, tidy up API comments

Author: alexcu2718

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fdf"
-version = "0.7.8"
+version = "0.7.7"
 rust-version = "1.85.0"
 edition = "2024"
 license = "MIT"

Cargo.toml

@@ -1,4 +1,5 @@
 use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
+use fdf::access_dirent;
 
 use core::num::NonZeroU64;
 use std::hint::black_box;
@@ -103,15 +104,19 @@ fn bench_strlen(c: &mut Criterion) {
             group.bench_with_input(
                 BenchmarkId::new("const_time_swar", size_name),
                 &entry,
-                |b, e| b.iter(|| unsafe { black_box(dirent_const_time_strlen(black_box(e))) }),
+                |b, e| {
+                    b.iter(|| unsafe {
+                        black_box(dirent_const_time_strlen(black_box(e as *const _)))
+                    })
+                },
             );
 
             group.bench_with_input(
                 BenchmarkId::new("libc_strlen", size_name),
                 &entry,
                 |b, e| {
                     b.iter(|| unsafe {
-                        black_box(libc::strlen(black_box(e.d_name.as_ptr() as *const _)))
+                        black_box(libc::strlen(black_box(access_dirent!(e, d_name).cast())))
                     })
                 },
             );
@@ -141,7 +146,9 @@ fn bench_strlen(c: &mut Criterion) {
                 let mut total = 0;
                 for entry in &all_entries {
                     total += unsafe {
-                        black_box(libc::strlen(black_box(entry.d_name.as_ptr() as *const _)))
+                        black_box(libc::strlen(black_box(
+                            access_dirent!(entry, d_name).cast(),
+                        )))
                     };
                 }
                 black_box(total) //make sure compiler does not optimise this away

benches/dirent_bench.rs

@@ -21,5 +21,4 @@ fn main() {
         max_filename_len >= 255,
         "NAME_MAX is not appropriately set!"
     );
-
 }

build.rs

@@ -102,15 +102,16 @@ impl FinderBuilder {
         self
     }
     #[must_use]
-    /// Set whether to use short paths in regex matching, defaults to true
+    /// Set whether to use short paths in regex/glob matching, defaults to true
+    /// This is over-ridden if the search term contains a '/'
     pub const fn file_name_only(mut self, short_path: bool) -> Self {
         self.file_name_only = short_path;
         self
     }
     #[must_use]
     /// Set extension to match, defaults to no extension
-    pub fn extension_match<C: AsRef<str>>(mut self, extension_match: C) -> Self {
-        let ext = extension_match.as_ref().as_bytes();
+    pub fn extension<C: AsRef<str>>(mut self, extension: C) -> Self {
+        let ext = extension.as_ref().as_bytes();
 
         if ext.is_empty() {
             self.extension_match = None;
@@ -147,8 +148,7 @@ impl FinderBuilder {
 
     /// Sets whether to follow symlinks (default: false).
     ///
-    /// # Warning
-    /// Enabling this may cause infinite recursion, although there are protections in place against it!
+    /// This will not recurse infinitely but can provide more results than expected
     #[must_use]
     pub const fn follow_symlinks(mut self, follow_symlinks: bool) -> Self {
         self.follow_symlinks = follow_symlinks;

src/finderbuilder.rs

@@ -477,16 +477,13 @@ pub trait DirentConstructor {
         let path_buffer = self.path_buffer();
         // SAFETY: The `base_len` is guaranteed to be a valid index into `path_buffer`
         let buffer = unsafe { &mut path_buffer.get_unchecked_mut(base_len..) };
-        // SAFETY:
-        // - `d_name` and `buffer` don't overlap (different memory regions)
+
+        // SAFETY: `d_name` and `buffer` don't overlap (different memory regions)
         // - Both pointers are properly aligned for byte copying
-        // - `name_len` is within `buffer` bounds (checked by debug assertion)
+        // - `name_len` is within `buffer` bounds
         unsafe { core::ptr::copy_nonoverlapping(d_name, buffer.as_mut_ptr(), name_len) };
-
-        /*
-         SAFETY: the buffer is guaranteed null terminated and we're accessing in bounds
-        */
         #[allow(clippy::multiple_unsafe_ops_per_block)]
+        // SAFETY: the buffer is guaranteed null terminated and we're accessing in bounds
         unsafe {
             CStr::from_bytes_with_nul_unchecked(path_buffer.get_unchecked(..base_len + name_len))
         }

src/iter.rs

@@ -455,9 +455,8 @@ impl Finder {
             .search_config
             .depth
             .is_some_and(|depth| dir.depth >= depth.get())
-            
         {
-            if should_send{
+            if should_send {
                 let _ = sender.send(vec![dir.clone()]);
             } // cloning costs very little here.
             return false; // depth limit reached, stop processing

src/lib.rs

@@ -266,7 +266,7 @@ fn main() -> Result<(), SearchConfigError> {
         .fixed_string(args.fixed_string)
         .canonicalise_root(args.absolute_path)
         .file_name_only(!args.full_path)
-        .extension_match(args.extension.unwrap_or_else(String::new))
+        .extension(args.extension.unwrap_or_else(String::new))
         .max_depth(args.depth)
         .follow_symlinks(args.follow_symlinks)
         .filter_by_size(args.size)

src/main.rs

@@ -5,7 +5,7 @@ mod tests {
     use crate::Finder;
     use crate::cli_helpers::*;
     use crate::{DirEntry, FileType};
-    use crate::{find_char_in_word, find_zero_byte_u64};
+    use crate::{find_char_in_word, find_last_char_in_word, find_zero_byte_u64};
     use chrono::{Duration as ChronoDuration, Utc};
     use env_home::env_home_dir;
     use filetime::{FileTime, set_file_times};
@@ -464,6 +464,12 @@ mod tests {
         assert_eq!(find_char_in_word(b'o', bytes), Some(4));
     }
 
+    #[test]
+    fn test_last_char_at_end() {
+        let bytes = create_byte_array("hello");
+        assert_eq!(find_last_char_in_word(b'l', bytes), Some(3));
+    }
+
     #[test]
     fn test_char_not_found() {
         let bytes = create_byte_array("hello");
@@ -1255,6 +1261,49 @@ mod tests {
         }
     }
 
+    #[test]
+    #[allow(unused)]
+    fn test_home_extension() {
+        let pattern: &str = ".";
+
+        let home_dir = env_home_dir();
+        if home_dir.is_some() {
+            let finder = Finder::init(home_dir.unwrap().as_os_str())
+                .pattern(&pattern)
+                .extension("c")
+                .keep_hidden(true)
+                .keep_dirs(true)
+                .build()
+                .unwrap();
+
+            let result = finder.traverse().unwrap().into_iter();
+
+            let collected: Vec<_> = std::hint::black_box(result.collect());
+        }
+    }
+
+    #[test]
+    #[allow(unused)]
+    fn test_home_extension_symlink() {
+        let pattern: &str = ".";
+
+        let home_dir = env_home_dir();
+        if home_dir.is_some() {
+            let finder = Finder::init(home_dir.unwrap().as_os_str())
+                .pattern(&pattern)
+                .follow_symlinks(true)
+                .extension("c")
+                .keep_hidden(true)
+                .keep_dirs(true)
+                .build()
+                .unwrap();
+
+            let result = finder.traverse().unwrap().into_iter();
+
+            let collected: Vec<_> = std::hint::black_box(result.collect());
+        }
+    }
+
     #[test]
     #[allow(unused)]
     fn test_home_symlink() {

src/test.rs

@@ -12,9 +12,8 @@ const_from_env!(
 );
 //basically this is the should allow getdents to grab a lot of entries in one go
 
-
 #[cfg(any(target_os = "linux", target_os = "android"))]
-const_assert!(BUFFER_SIZE>=4096,"Buffer size too small!");
+const_assert!(BUFFER_SIZE >= 4096, "Buffer size too small!");
 
 #[cfg(any(target_os = "linux", target_os = "android"))]
 //we only use a buffer for syscalls on linux because of stable ABI(because we don't need to use a buffer for `ReadDir`)