Refactor codebase for consistent indentation and formatting

- Standardized spacing and indentation across multiple modules for improved readability.
- Reorganized `patterns` and `utils` imports for consistency.
- Updated `NyxError` and `NyxResult` related implementations to maintain consistent formatting.
- Enhanced readability in AST patterns for better clarity and maintainability.

src/walk.rs

@@ -1,5 +1,5 @@
-use crossbeam_channel::{bounded, Receiver, Sender};
-use ignore::{overrides::OverrideBuilder, WalkBuilder, WalkState};
+use crossbeam_channel::{Receiver, Sender, bounded};
+use ignore::{WalkBuilder, WalkState, overrides::OverrideBuilder};
 use std::{
     mem,
     path::{Path, PathBuf},
@@ -11,19 +11,17 @@ use crate::utils::Config;
 // ---------------------------------------------------------------------------
 // Internal constants / helpers
 // ---------------------------------------------------------------------------
-const DEFAULT_BATCH:     usize = 8;   // a tad larger for fewer sends
-const CHANNEL_MULTIPLIER:usize = 4;   // capacity = threads × this
 
 type Batch = Vec<PathBuf>;
 
 struct Batcher {
-    tx:    Sender<Batch>,
+    tx: Sender<Batch>,
     batch: Batch,
 }
 impl Batcher {
-    fn push(&mut self, p: PathBuf) {
+    fn push(&mut self, p: PathBuf, batch_size: usize) {
         self.batch.push(p);
-        if self.batch.len() == DEFAULT_BATCH {
+        if self.batch.len() == batch_size {
             self.flush();
         }
     }
@@ -34,7 +32,9 @@ impl Batcher {
     }
 }
 impl Drop for Batcher {
-    fn drop(&mut self) { self.flush(); }
+    fn drop(&mut self) {
+        self.flush();
+    }
 }
 
 // ---------------------------------------------------------------------------
@@ -52,54 +52,55 @@ pub fn spawn_senders(root: &Path, cfg: &Config) -> Receiver<Batch> {
             tracing::warn!("cannot add ignore pattern ‘{dir}’: {e}");
         }
     }
-    let overrides   = ob.build().unwrap();
+    let overrides = ob.build().unwrap();
 
     // ----- 2  channel & thread pool parameters -----------------------------
-    let workers     = cfg.performance.worker_threads.unwrap_or(num_cpus::get());
-    let (tx, rx)    = bounded::<Batch>(workers * CHANNEL_MULTIPLIER);
+    let workers = cfg.performance.worker_threads.unwrap_or(num_cpus::get());
+    let (tx, rx) = bounded::<Batch>(workers * cfg.performance.channel_multiplier);
 
-    let root        = root.to_path_buf();
+    let root = root.to_path_buf();
     let scan_hidden = cfg.scanner.scan_hidden_files;
-    let follow      = cfg.scanner.follow_symlinks;
-    let max_bytes   = cfg.scanner.max_file_size_mb.unwrap_or(0) * 1_048_576;
+    let follow = cfg.scanner.follow_symlinks;
+    let max_bytes = cfg.scanner.max_file_size_mb.unwrap_or(0) * 1_048_576;
+    let batch_size = cfg.performance.batch_size;
 
     // ----- 3  the background walker thread ---------------------------------
     thread::spawn(move || {
         WalkBuilder::new(root)
-          .hidden(!scan_hidden)
-          .follow_links(follow)
-          .threads(workers)
-          .overrides(overrides)
-          .build_parallel()
-          .run(move || {
-              let mut b = Batcher {
-                  tx:    tx.clone(),
-                  batch: Vec::with_capacity(DEFAULT_BATCH),
-              };
+            .hidden(!scan_hidden)
+            .follow_links(follow)
+            .threads(workers)
+            .overrides(overrides)
+            .build_parallel()
+            .run(move || {
+                let mut b = Batcher {
+                    tx: tx.clone(),
+                    batch: Vec::with_capacity(batch_size),
+                };
 
-              Box::new(move |entry| {
-                  tracing::debug!("walking {:?}", entry);
-                  let entry = match entry {
-                      Ok(e) if e.file_type().map(|ft| ft.is_file()).unwrap_or(false) => e,
-                      _ => return WalkState::Continue,
-                  };
+                Box::new(move |entry| {
+                    tracing::debug!("walking {:?}", entry);
+                    let entry = match entry {
+                        Ok(e) if e.file_type().map(|ft| ft.is_file()).unwrap_or(false) => e,
+                        _ => return WalkState::Continue,
+                    };
 
-                  if max_bytes != 0 {
-                      match entry.metadata() {
-                          Ok(m) if m.len() > max_bytes => return WalkState::Continue,
-                          Err(e) => {
-                              tracing::debug!("metadata failed for {:?}: {e}", entry.path());
-                              return WalkState::Continue;
-                          }
-                          _ => {}
-                      }
-                  }
+                    if max_bytes != 0 {
+                        match entry.metadata() {
+                            Ok(m) if m.len() > max_bytes => return WalkState::Continue,
+                            Err(e) => {
+                                tracing::debug!("metadata failed for {:?}: {e}", entry.path());
+                                return WalkState::Continue;
+                            }
+                            _ => {}
+                        }
+                    }
 
-                  tracing::debug!("sending {:?}", entry);
-                  b.push(entry.into_path());
-                  WalkState::Continue
-              })
-          });
+                    tracing::debug!("sending {:?}", entry);
+                    b.push(entry.into_path(), batch_size);
+                    WalkState::Continue
+                })
+            });
     });
 
     rx