rm: fix rustfmt, cspell, and clippy CI failures

- Run rustfmt to fix formatting in safe_remove_dir_recursive_impl
- Replace British English spellings with American English in comments
  (materialising→materializing, minimising→minimizing, amortised→amortized,
   initialisation→initialization, behaviour→behavior)
- Fix clippy: use inline format arg in panic! in safe_traversal test
- Add technical terms to cspell jargon dictionary:
  EMFILE, ENFILE, ENOMEM, NOFILE, getdents, btrfs, diriter, readdir

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 2 people

.vscode/cspell.dictionaries/jargon.wordlist.txt

@@ -34,6 +34,15 @@ dequeue
 dev
 EINTR
 eintr
+EMFILE
+emfile
+ENFILE
+ENOMEM
+getdents
+btrfs
+diriter
+NOFILE
+readdir
 nextest
 SIGUSR
 nonprinting

src/uu/rm/src/platform/unix.rs

@@ -362,7 +362,7 @@ fn is_emfile(e: &io::Error) -> bool {
 /// A frame starts as `Live` (fd open, lazy iteration via `DirIter`).  When
 /// the process runs out of file descriptors — which limits tree depth to
 /// approximately `RLIMIT_NOFILE` (≈ 1 024) — `try_reclaim_fd` demotes the
-/// oldest live frame to `Drained` by materialising its remaining entries into
+/// oldest live frame to `Drained` by materializing its remaining entries into
 /// a `Vec` and closing the fd.  Subsequent entry-yielding uses the vec; fd
 /// operations (stat, unlink, open-child) temporarily re-open the directory
 /// from `StackFrame::dir_path`.
@@ -419,7 +419,7 @@ struct StackFrame {
 /// Returns `true` if a frame was demoted; `false` if all non-top frames are
 /// already `Drained` (which means we are genuinely out of fds).
 ///
-/// Materialising the oldest frame first minimises the chance of collecting a
+/// Materializing the oldest frame first minimizes the chance of collecting a
 /// large sibling list: for deep linear chains the bottom frames have already
 /// exhausted their children before a new level is pushed.
 ///
@@ -562,7 +562,7 @@ pub(super) fn safe_remove_dir_recursive_impl(
     options: &Options,
     progress_bar: Option<&ProgressBar>,
 ) -> bool {
-    // Iterative, allocation-minimising implementation.
+    // Iterative, allocation-minimizing implementation.
     //
     // Design goals (see https://github.com/uutils/coreutils/issues/11222):
     //   • One shared `PathBuf` for the entire traversal instead of one `join()`
@@ -577,7 +577,7 @@ pub(super) fn safe_remove_dir_recursive_impl(
     //
     // Fd budget: each `Live` frame holds exactly one open fd.  When the process
     // runs out of file descriptors (`EMFILE`/`ENFILE`), `try_reclaim_fd` demotes
-    // the oldest live frame to `Drained` — its remaining entries are materialised
+    // the oldest live frame to `Drained` — its remaining entries are materialized
     // into a `Vec<OsString>` and its fd is closed.  Subsequent fd-requiring
     // operations on a `Drained` frame re-open the directory from `dir_path` on
     // demand.  This allows traversal of trees of arbitrary depth at the cost of
@@ -681,7 +681,7 @@ pub(super) fn safe_remove_dir_recursive_impl(
 
             // ── Normal child entry ────────────────────────────────────────────
             Some(Ok(entry)) => {
-                // Extend the shared path accumulator in-place — amortised O(1),
+                // Extend the shared path accumulator in-place — amortized O(1),
                 // no heap allocation if there is spare capacity.
                 current_path.push(&entry.name);
 
@@ -696,19 +696,18 @@ pub(super) fn safe_remove_dir_recursive_impl(
                 //
                 // Fallback: stat when in interactive mode (need mode/size for
                 // the prompt) or when the filesystem reports DT_UNKNOWN.
-                let needs_stat = options.interactive != InteractiveMode::Never
-                    || entry.file_type.is_none();
+                let needs_stat =
+                    options.interactive != InteractiveMode::Never || entry.file_type.is_none();
 
                 let (is_dir, stat_opt) = if needs_stat {
                     match frame_stat_at(stack.last().unwrap(), entry.name.as_ref()) {
                         Ok(s) => {
-                            let is_dir = ((s.st_mode as libc::mode_t) & libc::S_IFMT)
-                                == libc::S_IFDIR;
+                            let is_dir =
+                                ((s.st_mode as libc::mode_t) & libc::S_IFMT) == libc::S_IFDIR;
                             (is_dir, Some(s))
                         }
                         Err(e) => {
-                            let err =
-                                handle_error_with_force(e, current_path.as_path(), options);
+                            let err = handle_error_with_force(e, current_path.as_path(), options);
                             stack.last_mut().unwrap().had_error |= err;
                             current_path.pop();
                             continue;
@@ -832,9 +831,7 @@ pub(super) fn safe_remove_dir_recursive_impl(
                     // File or symlink: prompt then unlink.
                     // In Never mode stat_opt is None and we always remove.
                     let should_remove = match stat_opt {
-                        Some(ref s) => {
-                            prompt_file_with_stat(current_path.as_path(), s, options)
-                        }
+                        Some(ref s) => prompt_file_with_stat(current_path.as_path(), s, options),
                         None => true,
                     };
                     if should_remove {

src/uucore/src/lib/features/safe_traversal.rs

@@ -1471,7 +1471,11 @@ mod tests {
         fs::write(temp_dir.path().join("gamma"), "c").unwrap();
 
         let dir_fd = DirFd::open(temp_dir.path(), SymlinkBehavior::Follow).unwrap();
-        let mut names: Vec<OsString> = dir_fd.iter_dir().unwrap().map(|r| r.unwrap().name).collect();
+        let mut names: Vec<OsString> = dir_fd
+            .iter_dir()
+            .unwrap()
+            .map(|r| r.unwrap().name)
+            .collect();
         names.sort();
 
         assert_eq!(
@@ -1498,7 +1502,11 @@ mod tests {
         fs::write(temp_dir.path().join("file"), "x").unwrap();
 
         let dir_fd = DirFd::open(temp_dir.path(), SymlinkBehavior::Follow).unwrap();
-        let names: Vec<OsString> = dir_fd.iter_dir().unwrap().map(|r| r.unwrap().name).collect();
+        let names: Vec<OsString> = dir_fd
+            .iter_dir()
+            .unwrap()
+            .map(|r| r.unwrap().name)
+            .collect();
 
         assert!(!names.contains(&OsString::from(".")));
         assert!(!names.contains(&OsString::from("..")));
@@ -1533,7 +1541,7 @@ mod tests {
         // A sentinel file ensures the directory is non-empty, so the first
         // `getdents64` call is deferred until after we close the fd below.
         // Without it, an empty directory may return EOF (0) during Dir::from_fd
-        // initialisation, making iter.next() return None instead of Some(Err(_)).
+        // initialization, making iter.next() return None instead of Some(Err(_)).
         fs::write(temp_dir.path().join("sentinel"), "x").unwrap();
 
         let dir_fd = DirFd::open(temp_dir.path(), SymlinkBehavior::Follow).unwrap();
@@ -1555,7 +1563,7 @@ mod tests {
         // the destructor would attempt on the already-closed fd.
         match iter.next() {
             Some(Err(_)) => {} // expected: EBADF propagated as io::Error
-            other => panic!("expected Some(Err(_)) after fd close, got {:?}", other),
+            other => panic!("expected Some(Err(_)) after fd close, got {other:?}"),
         }
     }
 }

tests/by-util/test_rm.rs

@@ -1012,7 +1012,7 @@ fn test_recursive_interactive() {
 
 // When the user declines to remove a subdirectory in interactive mode, rm
 // should NOT report an error.  The parent directory is left behind (because it
-// is non-empty), but the process should exit 0 — matching GNU rm behaviour.
+// is non-empty), but the process should exit 0 — matching GNU rm behavior.
 #[cfg(not(windows))]
 #[test]
 fn test_recursive_interactive_decline_child_no_error() {