safe-rm 3.1.4 → 3.2.0

package/README.md

@@ -161,6 +161,31 @@ export SAFE_RM_TRASH=/path/to/trash
 export SAFE_RM_PERM_DEL_FILES_IN_TRASH=yes
 ```
 
+### Restrict Removals To A Safe Directory Scope
+
+```sh
+export SAFE_RM_SCOPE="$HOME"
+```
+
+When `SAFE_RM_SCOPE` is set, `safe-rm` only removes targets under that directory.
+Targets outside the configured scope will be skipped and reported as unsafe.
+
+For example:
+
+```sh
+export SAFE_RM_SCOPE="$HOME"
+safe-rm -rf /
+# rm: target '/' skipped, unsafe directory scope
+```
+
+You could also use a relative scope such as `.`:
+
+```sh
+SAFE_RM_SCOPE=. safe-rm -rf ./foo
+SAFE_RM_SCOPE=. safe-rm -rf ../
+# rm: target '../' skipped, unsafe directory scope
+```
+
 ### 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

@@ -20,10 +20,21 @@ fi
 # ```
 SAFE_RM_CONFIG=${SAFE_RM_CONFIG:="$SAFE_RM_CONFIG_ROOT/config"}
 
+SAFE_RM_SCOPE_ENV_DEFINED=
+SAFE_RM_SCOPE_ENV_VALUE=
+if [[ ${SAFE_RM_SCOPE+x} ]]; then
+  SAFE_RM_SCOPE_ENV_DEFINED=1
+  SAFE_RM_SCOPE_ENV_VALUE=$SAFE_RM_SCOPE
+fi
+
 if [[ -f "$SAFE_RM_CONFIG" ]]; then
   source "$SAFE_RM_CONFIG"
 fi
 
+if [[ -n "$SAFE_RM_SCOPE_ENV_DEFINED" ]]; then
+  SAFE_RM_SCOPE=$SAFE_RM_SCOPE_ENV_VALUE
+fi
+
 # Print debug info or not
 SAFE_RM_DEBUG=${SAFE_RM_DEBUG:=}
 
@@ -330,7 +341,7 @@ if [[ ! -e $SAFE_RM_TRASH ]]; then
   echo -n "(yes/no): "
 
   read answer
-  if [[ $answer == "yes" || ! -n $anwser ]]; then
+  if [[ $answer == "yes" || ! -n $answer ]]; then
     mkdir -p "$SAFE_RM_TRASH"
   else
     echo "Canceled!"
@@ -351,6 +362,8 @@ check_return_status(){
 remove(){
   local file=$1
 
+  ensure_safe_scope "$file" || return 1
+
   # if is dir
   if [[ -d "$file" && ! -L "$file" ]]; then
 
@@ -455,7 +468,7 @@ trash(){
   local target=$1
 
   if [[ -n $SAFE_RM_PERM_DEL_FILES_IN_TRASH ]]; then
-    if [[ "$target" == "$SAFE_RM_TRASH"* ]]; then
+    if is_in_trash "$target"; then
       # If the target is already in the trash, delete it permanently
       /bin/rm -rf "$target"
     else
@@ -492,9 +505,131 @@ do_trash(){
 get_absolute_path(){
   local dir
   local base
-  dir=$(cd "$(dirname -- "$1")" && pwd)
+  if [[ "$1" == "/" ]]; then
+    printf '/\n'
+    return
+  fi
+
+  dir=$(cd "$(dirname -- "$1")" && pwd) || return 1
   base=$(basename -- "$1")
-  printf '%s/%s\n' "$dir" "$base"
+
+  case "$base" in
+    .)
+      printf '%s\n' "$dir"
+      ;;
+
+    ..)
+      dir=$(cd "$dir/.." && pwd) || return 1
+      printf '%s\n' "$dir"
+      ;;
+
+    *)
+      printf '%s/%s\n' "$dir" "$base"
+      ;;
+  esac
+}
+
+
+expand_home_path(){
+  case $1 in
+    "~")
+      printf '%s\n' "$HOME"
+      ;;
+
+    "~/"*)
+      printf '%s/%s\n' "$HOME" "${1#~/}"
+      ;;
+
+    *)
+      printf '%s\n' "$1"
+      ;;
+  esac
+}
+
+
+resolve_directory_path(){
+  local path
+  path=$(expand_home_path "$1")
+
+  (
+    cd "$path" &> /dev/null || exit 1
+    pwd
+  )
+}
+
+
+encode_trashinfo_path(){
+  local path=$1
+  local out=
+  local i
+  local char
+  local hex
+  local LC_ALL=C
+
+  for ((i = 0; i < ${#path}; i += 1)); do
+    char=${path:i:1}
+
+    case "$char" in
+      [a-zA-Z0-9._~/-])
+        out="$out$char"
+        ;;
+      *)
+        hex=$(printf '%s' "$char" | od -An -tx1 | tr -d ' \n' | tr '[:lower:]' '[:upper:]')
+        out="$out%$hex"
+        ;;
+    esac
+  done
+
+  printf '%s\n' "$out"
+}
+
+
+is_in_trash(){
+  local target_abs
+  local trash_abs
+
+  target_abs=$(get_absolute_path "$1") || return 1
+  trash_abs=$(cd "$SAFE_RM_TRASH" && pwd) || return 1
+
+  [[ "$target_abs" == "$trash_abs" || "$target_abs" == "$trash_abs"/* ]]
+}
+
+
+SAFE_RM_SCOPE_ROOT=
+init_safe_rm_scope(){
+  if [[ -z "$SAFE_RM_SCOPE" ]]; then
+    return 0
+  fi
+
+  SAFE_RM_SCOPE_ROOT=$(resolve_directory_path "$SAFE_RM_SCOPE") || {
+    error "$COMMAND: invalid SAFE_RM_SCOPE '$SAFE_RM_SCOPE': not an existing directory"
+    return 1
+  }
+
+  debug "$LINENO: safe rm scope enabled: $SAFE_RM_SCOPE_ROOT"
+}
+
+
+is_in_scope(){
+  local target_abs
+
+  if [[ -z "$SAFE_RM_SCOPE_ROOT" ]]; then
+    return 0
+  fi
+
+  target_abs=$(get_absolute_path "$1") || return 1
+
+  [[ "$target_abs" == "$SAFE_RM_SCOPE_ROOT" || "$target_abs" == "$SAFE_RM_SCOPE_ROOT"/* ]]
+}
+
+
+ensure_safe_scope(){
+  if is_in_scope "$1"; then
+    return 0
+  fi
+
+  error "$COMMAND: target '$1' skipped, unsafe directory scope"
+  return 1
 }
 
 
@@ -559,16 +694,22 @@ check_mac_trash_path(){
   local ext=$2
   local full_path="$path$ext"
 
-  # if already in the trash
-  if [[ -e "$full_path" ]]; then
-    debug "$LINENO: $full_path already exists"
-
-    # renew $_short_time_ret
-    short_time
-    check_mac_trash_path "$path $_short_time_ret" "$ext"
-  else
+  if [[ ! -e "$full_path" ]]; then
     _mac_trash_path_ret=$full_path
+    return
   fi
+
+  debug "$LINENO: $full_path already exists"
+
+  short_time
+  full_path="$path $_short_time_ret$ext"
+
+  while [[ -e "$full_path" ]]; do
+    debug "$LINENO: $full_path already exists"
+    full_path="${full_path}X"
+  done
+
+  _mac_trash_path_ret=$full_path
 }
 
 
@@ -651,16 +792,35 @@ check_linux_trash_base(){
 
     local max_n=0
     local num=
+    local restore_nullglob=$(shopt -p nullglob)
+    local restore_dotglob=$(shopt -p dotglob)
+    shopt -s nullglob dotglob
+    local list=("$trash"/*)
+    eval "$restore_nullglob"
+    eval "$restore_dotglob"
+    local file
+    local name
+    local suffix
 
-    while IFS= read -r file; do
-      if [[ $file =~ ${base}\.([0-9]+)$ ]]; then
-          # Remove leading zeros and make sure the number is in base 10
-          num=$((10#${BASH_REMATCH[1]}))
-          if ((num > max_n)); then
-              max_n=$num
-          fi
+    for file in "${list[@]}"; do
+      name=$(basename -- "$file")
+
+      if [[ "$name" != "$base".* ]]; then
+        continue
       fi
-    done < <(find "$trash" -maxdepth 1)
+
+      suffix=${name#"$base".}
+
+      if [[ ! "$suffix" =~ ^[0-9]+$ ]]; then
+        continue
+      fi
+
+      # Remove leading zeros and make sure the number is in base 10
+      num=$((10#$suffix))
+      if ((num > max_n)); then
+        max_n=$num
+      fi
+    done
 
     (( max_n += 1 ))
 
@@ -674,6 +834,12 @@ check_linux_trash_base(){
 # trash a file or dir directly for linux
 # - move the target into
 linux_trash(){
+  local original_path
+  local trashinfo_path_value
+
+  original_path=$(get_absolute_path "$1") || return 1
+  trashinfo_path_value=$(encode_trashinfo_path "$original_path") || return 1
+
   check_target_to_move "$1"
   local move=$_to_move
   local base=$(basename -- "$move")
@@ -700,7 +866,7 @@ linux_trash(){
   local trash_time=$(date +%Y-%m-%dT%H:%M:%S)
   cat > "$info_path" <<EOF
 [Trash Info]
-Path=$move
+Path=$trashinfo_path_value
 DeletionDate=$trash_time
 EOF
   local info_status=$?
@@ -738,8 +904,10 @@ list_files(){
 # debug: get $FILE_NAME array length
 debug "$LINENO: ${#FILE_NAME[@]} files or directory to process: ${FILE_NAME[@]}"
 
+init_safe_rm_scope || do_exit $LINENO 1
+
 # test remove interactive_once: ask for 3 or more files or with recursive option
-if [[ (${#FILE_NAME[@]} > 2 || $OPT_RECURSIVE == 1) && $OPT_INTERACTIVE_ONCE == 1 ]]; then
+if [[ (${#FILE_NAME[@]} > 3 || $OPT_RECURSIVE == 1) && $OPT_INTERACTIVE_ONCE == 1 ]]; then
   echo -n "$COMMAND: remove all arguments? "
   read answer
 
@@ -753,6 +921,11 @@ fi
 for file in "${FILE_NAME[@]}"; do
   debug "$LINENO: result file $file"
 
+  if ! ensure_safe_scope "$file"; then
+    EXIT_CODE=1
+    continue
+  fi
+
   if [[ $file == "/" ]]; then
     error "it is dangerous to operate recursively on /"
     error "are you insane?"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safe-rm",
-  "version": "3.1.4",
+  "version": "3.2.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

@@ -20,6 +20,9 @@ const is_as = type => type === 'safe-rm-as'
 // We skip testing trash dir for vanilla rm
 const should_skip_test_trash_dir = type => is_rm(type) || is_as(type)
 
+const escapeRegExp = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+const encodeTrashInfoPath = value => value.split('/').map(encodeURIComponent).join('/')
+
 module.exports = (
   test,
   {
@@ -111,32 +114,24 @@ module.exports = (
       .sort((a, b) => a.length - b.length)
 
       if (IS_MACOS) {
-        // /path/to/foo[.jpg]
-        // /path/to/foo 12.58.23[.jpg]
-        // /path/to/foo 12.58.23 12.58.23[.jpg]
-        const [f1, f2, f3] = files
-
-        const [fb1, fb2, fb3] = [f1, f2, f3].map(
-          f => {
-            const base = path.basename(f)
-
-            return base.slice(0, base.length - ext.length)
-          }
+        const baseNames = files.map(file => path.basename(file))
+        const timestamped = baseNames.filter(base => base !== full_name)
+        const timestampedRe = new RegExp(
+          ext
+            ? `^${escapeRegExp(filename)} \\d{2}\\.\\d{2}\\.\\d{2}${escapeRegExp(ext)}X*$`
+            : `^${escapeRegExp(filename)} \\d{2}\\.\\d{2}\\.\\d{2}X*$`
         )
 
-        const [fbs1, fbs2, fbs3] = [fb1, fb2, fb3].map(f => f.split(' '))
-
-        const time = fbs2[1]
-
-        t.true(files.every(f => f.endsWith(ext)), 'should have the same ext')
-
-        t.is(fb1, filename)
-        t.is(fbs1[0], filename)
-        t.is(fbs2[0], filename)
-        t.is(fbs3[0], filename)
-
-        t.is(fbs3[1], time)
-        t.is(fbs3[2], time)
+        t.is(baseNames.filter(base => base === full_name).length, 1)
+        t.is(timestamped.length, 2)
+        t.true(
+          timestamped.every(base => timestampedRe.test(base)),
+          'timestamped duplicates should follow Finder naming'
+        )
+        t.true(
+          timestamped.some(base => ext ? base.endsWith(ext) : !base.endsWith('X')),
+          'should include a plain timestamped duplicate'
+        )
       } else {
         // /path/to/foo[.jpg]
         // /path/to/foo[.jpg].1
@@ -193,6 +188,419 @@ module.exports = (
     t.is(files.length, 0, 'should be already removed')
   })
 
+  !is_rm(type) && !is_as(type) && test(`permanent delete only applies to real trash descendants`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists,
+      lsFileInTrash
+    } = t.context
+
+    const sibling = await createDir({
+      name: `${path.basename(t.context.trash_path)}-other`,
+      under: path.dirname(t.context.trash_path)
+    })
+
+    const filepath = await createFile({
+      name: uuid(),
+      under: sibling
+    })
+
+    const result = await runRm([filepath], {
+      env: {
+        SAFE_RM_PERM_DEL_FILES_IN_TRASH: 'yes'
+      }
+    })
+
+    assertEmptySuccess(t, result)
+    t.false(await pathExists(filepath), 'file should be removed from the sibling dir')
+
+    const files = await lsFileInTrash(filepath)
+
+    t.is(files.length, 1, 'file should be moved into trash instead of being hard-deleted')
+  })
+
+  !is_rm(type) && !is_as(type) && !IS_MACOS && test(`linux duplicate naming treats regex chars literally`, async t => {
+    const {
+      trash_path,
+      createDir,
+      createFile,
+      runRm,
+      pathExists,
+      lsFileInTrash
+    } = t.context
+
+    const filename = 'a+b'
+    const trashFilesDir = await createDir({
+      name: 'files',
+      under: trash_path
+    })
+
+    const existing0 = await createFile({
+      name: filename,
+      under: trashFilesDir,
+      content: 'existing-0'
+    })
+
+    const existing1 = await createFile({
+      name: `${filename}.1`,
+      under: trashFilesDir,
+      content: 'existing-1'
+    })
+
+    const filepath = await createFile({
+      name: filename,
+      content: 'incoming'
+    })
+
+    const result = await runRm([filepath])
+
+    assertEmptySuccess(t, result)
+    t.false(await pathExists(filepath), 'source file should be removed')
+
+    const files = (await lsFileInTrash(filename))
+      .map(file => path.basename(file))
+      .sort()
+
+    t.deepEqual(files, [filename, `${filename}.1`, `${filename}.2`])
+    t.is(await fs.readFile(existing0, 'utf8'), 'existing-0')
+    t.is(await fs.readFile(existing1, 'utf8'), 'existing-1')
+  })
+
+  !is_rm(type) && !is_as(type) && !IS_MACOS && test(`linux .trashinfo stores an encoded absolute original path`, async t => {
+    const {
+      source_path,
+      trash_path,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const filename = 'space name'
+    const filepath = await createFile({
+      name: filename
+    })
+    const canonicalFilepath = await fs.realpath(filepath)
+
+    const result = await runRm([`./${filename}`], {
+      cwd: source_path
+    })
+
+    assertEmptySuccess(t, result)
+    t.false(await pathExists(filepath), 'source file should be removed')
+
+    const infoPath = path.join(trash_path, 'info', `${filename}.trashinfo`)
+    const info = await fs.readFile(infoPath, 'utf8')
+    const expectedPath = encodeTrashInfoPath(canonicalFilepath)
+
+    t.true(info.includes(`[Trash Info]`))
+    t.true(info.includes(`Path=${expectedPath}`))
+  })
+
+  !is_rm(type) && !is_as(type) && IS_MACOS && test(`mac fallback duplicate naming matches Finder without extension`, async t => {
+    const {
+      root,
+      createDir,
+      createFile,
+      runRm,
+      lsFileInTrash
+    } = t.context
+
+    const mockBin = await createDir({
+      name: 'mock-bin-noext',
+      under: root
+    })
+
+    const mockDate = await createFile({
+      name: 'date',
+      under: mockBin,
+      content: '#!/usr/bin/env bash\necho 12.34.56\n'
+    })
+
+    await fs.chmod(mockDate, 0o755)
+
+    const filename = `finder-noext-${uuid()}`
+
+    for (const content of ['1', '2', '3', '4']) {
+      const filepath = await createFile({
+        name: filename,
+        content
+      })
+
+      const result = await runRm([filepath], {
+        env: {
+          PATH: `${mockBin}:${process.env.PATH}`
+        }
+      })
+
+      assertEmptySuccess(t, result)
+    }
+
+    const files = (await lsFileInTrash(filename))
+      .map(file => path.basename(file))
+      .sort((a, b) => a.length - b.length)
+
+    t.deepEqual(files, [
+      filename,
+      `${filename} 12.34.56`,
+      `${filename} 12.34.56X`,
+      `${filename} 12.34.56XX`
+    ])
+  })
+
+  !is_rm(type) && !is_as(type) && IS_MACOS && test(`mac fallback duplicate naming matches Finder with extensions`, async t => {
+    const {
+      root,
+      createDir,
+      createFile,
+      runRm,
+      lsFileInTrash
+    } = t.context
+
+    const mockBin = await createDir({
+      name: 'mock-bin-ext',
+      under: root
+    })
+
+    const mockDate = await createFile({
+      name: 'date',
+      under: mockBin,
+      content: '#!/usr/bin/env bash\necho 12.34.56\n'
+    })
+
+    await fs.chmod(mockDate, 0o755)
+
+    const filename = `finder-ext-${uuid()}.jpg`
+
+    for (const content of ['1', '2', '3', '4']) {
+      const filepath = await createFile({
+        name: filename,
+        content
+      })
+
+      const result = await runRm([filepath], {
+        env: {
+          PATH: `${mockBin}:${process.env.PATH}`
+        }
+      })
+
+      assertEmptySuccess(t, result)
+    }
+
+    const files = (await lsFileInTrash(filename))
+      .map(file => path.basename(file))
+      .sort((a, b) => a.length - b.length)
+
+    const baseName = path.basename(filename, '.jpg')
+
+    t.deepEqual(files, [
+      filename,
+      `${baseName} 12.34.56.jpg`,
+      `${baseName} 12.34.56.jpgX`,
+      `${baseName} 12.34.56.jpgXX`
+    ])
+  })
+
+  !is_rm(type) && test(`scope "." allows removing targets under cwd only`, async t => {
+    const {
+      root,
+      source_path,
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const trash = await createDir({
+      name: 'scope-trash-dot',
+      under: root
+    })
+
+    const cwd = await createDir({
+      name: 'scope-cwd',
+      under: source_path
+    })
+
+    const inside = await createDir({
+      name: 'foo',
+      under: cwd
+    })
+
+    await createFile({
+      name: 'bar',
+      under: inside
+    })
+
+    const resultInside = await runRm(['-rf', 'foo'], {
+      cwd,
+      env: {
+        SAFE_RM_SCOPE: '.',
+        SAFE_RM_TRASH: trash
+      }
+    })
+
+    assertEmptySuccess(t, resultInside)
+    t.false(await pathExists(inside), 'in-scope target should be removed')
+
+    const resultOutside = await runRm(['-rf', '../'], {
+      cwd,
+      env: {
+        SAFE_RM_SCOPE: '.',
+        SAFE_RM_TRASH: trash
+      }
+    })
+
+    t.is(resultOutside.code, 1, 'out-of-scope target should fail')
+    t.true(resultOutside.stderr.includes('unsafe directory scope'))
+    t.true(await pathExists(source_path), 'parent directory should remain')
+  })
+
+  !is_rm(type) && test(`scope "~" expands HOME and blocks targets outside home`, async t => {
+    const {
+      root,
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const home = await createDir({
+      name: 'scope-home',
+      under: root
+    })
+
+    const trash = await createDir({
+      name: 'scope-trash-home',
+      under: root
+    })
+
+    const inside = await createFile({
+      name: 'inside-home',
+      under: home
+    })
+
+    const outside = await createFile({
+      name: 'outside-home'
+    })
+
+    const env = {
+      HOME: home,
+      SAFE_RM_SCOPE: '~',
+      SAFE_RM_TRASH: trash
+    }
+
+    const resultInside = await runRm([inside], {
+      env
+    })
+
+    assertEmptySuccess(t, resultInside)
+    t.false(await pathExists(inside), 'home-scoped target should be removed')
+
+    const resultOutside = await runRm([outside], {
+      env
+    })
+
+    t.is(resultOutside.code, 1, 'target outside home scope should fail')
+    t.true(resultOutside.stderr.includes('unsafe directory scope'))
+    t.true(await pathExists(outside), 'out-of-scope file should remain')
+  })
+
+  !is_rm(type) && test(`scope checks symlink path instead of symlink target`, async t => {
+    const {
+      root,
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const trash = await createDir({
+      name: 'scope-trash-link',
+      under: root
+    })
+
+    const cwd = await createDir({
+      name: 'scope-link-cwd',
+      under: root
+    })
+
+    const outsideTarget = await createFile({
+      name: 'scope-link-target'
+    })
+
+    const link = path.join(cwd, 'scope-link')
+    await fs.symlink(outsideTarget, link)
+
+    const result = await runRm(['scope-link'], {
+      cwd,
+      env: {
+        SAFE_RM_SCOPE: '.',
+        SAFE_RM_TRASH: trash
+      }
+    })
+
+    assertEmptySuccess(t, result)
+    t.false(await pathExists(link), 'symlink should be removed')
+    t.true(await pathExists(outsideTarget), 'symlink target should remain')
+  })
+
+  !is_rm(type) && !is_as(type) && test(`-I only prompts for more than three files`, async t => {
+    const {
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const files3 = await Promise.all(['a', 'b', 'c'].map(name => createFile({name})))
+    const result3 = await runRm(['-I', ...files3])
+
+    assertEmptySuccess(t, result3)
+    t.true(
+      (await Promise.all(files3.map(file => pathExists(file)))).every(exists => !exists),
+      'three files should be removed without a once-interactive prompt'
+    )
+
+    const files4 = await Promise.all(['d', 'e', 'f', 'g'].map(name => createFile({name})))
+    const result4 = await runRm(['-I', ...files4], {
+      input: ['n']
+    })
+
+    t.is(result4.code, 0, 'exit code should be 0 when declining the once-interactive prompt')
+    t.true(result4.stdout.includes('remove all arguments?'), 'stdout should contain the once-interactive prompt')
+    t.true(
+      (await Promise.all(files4.map(file => pathExists(file)))).every(Boolean),
+      'files should remain after declining the once-interactive prompt'
+    )
+  })
+
+  !is_rm(type) && !is_as(type) && IS_MACOS && test(`declining trash directory creation aborts removal`, async t => {
+    const {
+      root,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const filepath = await createFile({
+      name: 'needs-trash'
+    })
+
+    const trashPath = path.join(root, 'missing-trash')
+    const result = await runRm([filepath], {
+      input: ['no'],
+      env: {
+        SAFE_RM_TRASH: trashPath
+      }
+    })
+
+    t.is(result.code, 1, 'exit code should be 1 when declining trash creation')
+    t.true(result.stdout.includes(`Directory "${trashPath}" does not exist`))
+    t.true(result.stdout.includes('Canceled!'))
+    t.true(await pathExists(filepath), 'file should remain in place')
+    t.false(await pathExists(trashPath), 'trash directory should not be created')
+  })
+
   test(`#22 exit code with -f option`, async t => {
     const {
       source_path,

package/test/helper.js

@@ -12,6 +12,8 @@ const IS_MACOS = process.platform === 'darwin'
   // For linux mock testing
   && !process.env.SAFE_RM_DEBUG_LINUX
 
+const escapeRegExp = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
 const generateContextMethods = (
   rm_command,
   rm_command_env
@@ -83,7 +85,7 @@ const generateContextMethods = (
       child.stdout.on('data', data => {
         stdout += data.toString()
 
-        if (/\?\s*$/.test(stdout)) {
+        if (/[?:]\s*$/.test(stdout)) {
           if (!child.stdin) {
             reject(new Error('Child process does not support stdin'))
             return
@@ -144,9 +146,12 @@ const generateContextMethods = (
     const _filename = path.basename(filepath)
     const ext = path.extname(_filename)
     const filename = path.basename(_filename, ext)
+    const pattern = ext
+      ? new RegExp(`^${escapeRegExp(filename)}(?: \\d{2}\\.\\d{2}\\.\\d{2})?${escapeRegExp(ext)}X*$`)
+      : new RegExp(`^${escapeRegExp(filename)}(?: \\d{2}\\.\\d{2}\\.\\d{2}X*)?$`)
 
     const filtered = files.filter(
-      f => f.endsWith(ext) && f.startsWith(filename)
+      f => pattern.test(f)
     ).map(f => path.join(trash_path, f))
 
     return filtered