safe-rm 3.2.0 → 3.3.0

package/.github/workflows/nodejs.yml

@@ -23,5 +23,6 @@ jobs:
         npm install
         npm run build --if-present
         npm run test:dev
+        npm run test:mock-linux
       env:
         CI: true

package/README.md

@@ -173,8 +173,7 @@ Targets outside the configured scope will be skipped and reported as unsafe.
 For example:
 
 ```sh
-export SAFE_RM_SCOPE="$HOME"
-safe-rm -rf /
+SAFE_RM_SCOPE="$HOME" safe-rm -rf /
 # rm: target '/' skipped, unsafe directory scope
 ```
 
@@ -186,6 +185,27 @@ SAFE_RM_SCOPE=. safe-rm -rf ../
 # rm: target '../' skipped, unsafe directory scope
 ```
 
+### Honor Options After Operands (`rm dir -rf`)
+
+GNU `rm` (most Linux distros) accepts options anywhere on the command line, so `rm dir -rf` works like `rm -rf dir`. BSD `rm` (MacOS) does not — it stops parsing options at the first operand and would treat `-rf` as a filename.
+
+By default, `safe-rm` mirrors the host's real `rm`:
+
+- On Linux: options after operands are parsed as flags (GNU style).
+- On MacOS: options after operands are treated as filenames (BSD style).
+
+To override the auto-detection (e.g. on Alpine/BusyBox where `rm` does not permute):
+
+```sh
+# Force GNU-style permutation
+export SAFE_RM_OPTIONS_ANYWHERE=yes
+
+# Force BSD-style strict ordering
+export SAFE_RM_OPTIONS_ANYWHERE=no
+```
+
+`--` always terminates option parsing in either mode.
+
 ### Protect Files And Directories From Deleting
 
 If you want to protect some certain files or directories from deleting by mistake, you could create a `.gitignore` file under the `"~/.safe-rm/"` directory, you could write [.gitignore rules](https://git-scm.com/docs/gitignore) inside the file.

package/bin/rm.sh

@@ -90,6 +90,25 @@ else
 fi
 
 
+# Whether to honor options after the first operand (`rm dir -rf`).
+# Defaults to auto: enabled on Linux, disabled on MacOS. yes|no to override.
+case ${SAFE_RM_OPTIONS_ANYWHERE:0:1} in
+  [yY])
+    OPTIONS_ANYWHERE=1
+    ;;
+  [nN])
+    OPTIONS_ANYWHERE=
+    ;;
+  *)
+    if [[ "$OS_TYPE" == "Linux" ]]; then
+      OPTIONS_ANYWHERE=1
+    else
+      OPTIONS_ANYWHERE=
+    fi
+    ;;
+esac
+
+
 # The target trash directory to dispose files and directories,
 #   defaults to the system trash directory
 SAFE_RM_TRASH=${SAFE_RM_TRASH:="$DEFAULT_TRASH"}
@@ -270,7 +289,7 @@ while [[ -n $1 ]]; do
     # -> args: [], files: ['-']
     *)
       push_file "$1"; debug "$LINENO: file $1"
-      ARG_END=1
+      [[ -z "$OPTIONS_ANYWHERE" ]] && ARG_END=1
       ;;
     esac
   fi

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safe-rm",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "A much safer replacement of bash rm with nearly full functionalities and options of the rm command!",
   "bin": {
     "safe-rm": "./bin/rm.sh"

package/test/cases.js

@@ -975,4 +975,78 @@ fi
     t.is(result.code, 0, 'exit code should be 0')
     t.false(await pathExists(filepath), 'file should be removed')
   })
+
+  // Flag-after-operand parsing: align with the host's real `rm`.
+  // GNU rm (Linux) permutes options; BSD rm (MacOS) does not.
+  !is_rm(type) && !is_as(type) && !IS_MACOS && test(`Linux: flags after operand parse as options`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const dirpath = await createDir()
+    await createFile({under: dirpath})
+
+    const result = await runRm([dirpath, '-rf'])
+
+    assertEmptySuccess(t, result)
+    t.false(await pathExists(dirpath), 'directory should be removed')
+  })
+
+  !is_rm(type) && !is_as(type) && IS_MACOS && test(`MacOS: flags after operand are treated as filenames`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const dirpath = await createDir()
+    await createFile({under: dirpath})
+
+    const result = await runRm([dirpath, '-rf'])
+
+    t.is(result.code, 1, 'exit code should be 1')
+    t.true(await pathExists(dirpath), 'directory should remain')
+  })
+
+  !is_rm(type) && !is_as(type) && IS_MACOS && test(`SAFE_RM_OPTIONS_ANYWHERE=yes enables permutation on MacOS`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const dirpath = await createDir()
+    await createFile({under: dirpath})
+
+    const result = await runRm([dirpath, '-rf'], {
+      env: {SAFE_RM_OPTIONS_ANYWHERE: 'yes'}
+    })
+
+    assertEmptySuccess(t, result)
+    t.false(await pathExists(dirpath), 'directory should be removed')
+  })
+
+  !is_rm(type) && !is_as(type) && !IS_MACOS && test(`SAFE_RM_OPTIONS_ANYWHERE=no disables permutation on Linux`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const dirpath = await createDir()
+    await createFile({under: dirpath})
+
+    const result = await runRm([dirpath, '-rf'], {
+      env: {SAFE_RM_OPTIONS_ANYWHERE: 'no'}
+    })
+
+    t.is(result.code, 1, 'exit code should be 1')
+    t.true(await pathExists(dirpath), 'directory should remain')
+  })
 }