safe-rm 3.1.3 → 3.1.5

package/bin/rm.sh

@@ -330,7 +330,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!"
@@ -455,7 +455,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
@@ -490,7 +490,48 @@ do_trash(){
 
 
 get_absolute_path(){
-  echo $(cd "$(dirname "$1")" && pwd)/$(basename "$1")
+  local dir
+  local base
+  dir=$(cd "$(dirname -- "$1")" && pwd)
+  base=$(basename -- "$1")
+  printf '%s/%s\n' "$dir" "$base"
+}
+
+
+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"/* ]]
 }
 
 
@@ -555,16 +596,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
 }
 
 
@@ -601,7 +648,7 @@ check_target_to_move(){
 mac_trash(){
   check_target_to_move "$1"
   local move=$_to_move
-  local base=$(basename "$move")
+  local base=$(basename -- "$move")
 
   # foo.jpg => "foo" + ".jpg"
   # foo => "foo" + ""
@@ -623,7 +670,7 @@ mac_trash(){
   [[ "$OPT_VERBOSE" == 1 ]] && list_files "$1"
 
   debug "$LINENO: mv $move to $trash_path"
-  mv "$move" "$trash_path"
+  mv -- "$move" "$trash_path"
   local status=$?
 
   [[ "$_traveled" == 1 ]] && cd "$__DIRNAME" &> /dev/null
@@ -647,16 +694,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
+
+    for file in "${list[@]}"; do
+      name=$(basename -- "$file")
+
+      if [[ "$name" != "$base".* ]]; then
+        continue
+      fi
+
+      suffix=${name#"$base".}
 
-    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
+      if [[ ! "$suffix" =~ ^[0-9]+$ ]]; then
+        continue
       fi
-    done < <(find "$trash" -maxdepth 1)
+
+      # 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 ))
 
@@ -670,9 +736,15 @@ 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")
+  local base=$(basename -- "$move")
 
   base=$(check_linux_trash_base "$base")
 
@@ -682,7 +754,7 @@ linux_trash(){
 
   # Move the target into the trash
   debug "$LINENO: mv $move to $trash_path"
-  mv "$move" "$trash_path"
+  mv -- "$move" "$trash_path"
   local move_status=$?
 
   if [[ $move_status -ne 0 ]]; then
@@ -696,7 +768,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=$?
@@ -735,7 +807,7 @@ list_files(){
 debug "$LINENO: ${#FILE_NAME[@]} files or directory to process: ${FILE_NAME[@]}"
 
 # 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
 
@@ -763,28 +835,20 @@ for file in "${FILE_NAME[@]}"; do
   fi
 
   # the same check also apply on /. /..
-  if [[ $(basename "$file") == "." || $(basename "$file") == ".." ]]; then
+  if [[ $(basename -- "$file") == "." || $(basename -- "$file") == ".." ]]; then
     error "$COMMAND: \".\" and \"..\" may not be removed"
     EXIT_CODE=1
     continue
   fi
 
-  # deal with wildcard and also, redirect error output
-  ls_result=$(ls -d "$file" 2> /dev/null)
+  if [[ -e "$file" || -L "$file" ]]; then
+    remove "$file"
+    status=$?
+    debug "$LINENO: remove returned status: $status"
 
-  # debug
-  debug "$LINENO: ls_result: $ls_result"
-
-  if [[ -n "$ls_result" ]]; then
-    for file in "$ls_result"; do
-      remove "$file"
-      status=$?
-      debug "$LINENO: remove returned status: $status"
-
-      if [[ ! $status == 0 ]]; then
-        EXIT_CODE=1
-      fi
-    done
+    if [[ ! $status == 0 ]]; then
+      EXIT_CODE=1
+    fi
   elif [[ -z "$OPT_FORCE" ]]; then
     error "$COMMAND: $file: No such file or directory" >&2
     EXIT_CODE=1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safe-rm",
-  "version": "3.1.3",
+  "version": "3.1.5",
   "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,276 @@ 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) && !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,
@@ -447,4 +712,124 @@ fi
     t.false(await pathExists(link), 'symlink should be removed')
     t.true(await pathExists(target), 'target file should remain')
   })
+
+  !is_as(type) && test(`removes a dangling symlink`, async t => {
+    const {
+      source_path,
+      runRm
+    } = t.context
+
+    const missingTarget = path.join(source_path, 'missing-target')
+    const link = path.join(source_path, 'dangling_sym')
+    await fs.symlink(missingTarget, link)
+
+    const before = await fs.lstat(link)
+    t.true(before.isSymbolicLink(), 'should create symlink before remove')
+
+    const result = await runRm([link])
+
+    t.is(result.code, 0, 'exit code should be 0')
+    await t.throwsAsync(async () => fs.lstat(link), {
+      code: 'ENOENT'
+    })
+  })
+
+  !is_as(type) && test(`-r should not dereference a directory symlink`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const realDir = await createDir({
+      name: 'real-dir'
+    })
+
+    const keep = await createFile({
+      name: 'keep',
+      under: realDir
+    })
+
+    const link = path.join(path.dirname(realDir), 'real-dir-sym')
+    await fs.symlink(realDir, link)
+
+    const result = await runRm(['-r', link])
+
+    t.is(result.code, 0, 'exit code should be 0')
+    await t.throwsAsync(async () => fs.lstat(link), {
+      code: 'ENOENT'
+    })
+    t.true(await pathExists(realDir), 'target directory should remain')
+    t.true(await pathExists(keep), 'target content should remain')
+  })
+
+  !is_as(type) && test(`-ri should not dereference a directory symlink`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const realDir = await createDir({
+      name: 'real-dir-i'
+    })
+
+    const keep = await createFile({
+      name: 'keep-i',
+      under: realDir
+    })
+
+    const link = path.join(path.dirname(realDir), 'real-dir-sym-i')
+    await fs.symlink(realDir, link)
+
+    const result = await runRm(['-ri', link], {
+      input: ['y']
+    })
+
+    t.is(result.code, 0, 'exit code should be 0')
+    await t.throwsAsync(async () => fs.lstat(link), {
+      code: 'ENOENT'
+    })
+    t.true(await pathExists(realDir), 'target directory should remain')
+    t.true(await pathExists(keep), 'target content should remain')
+  })
+
+  !is_as(type) && test(`removes a file prefixed with "-" after --`, async t => {
+    const {
+      source_path,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const name = '-dash-file'
+    await createFile({name})
+
+    const result = await runRm(['--', name], {
+      cwd: source_path
+    })
+
+    t.is(result.code, 0, 'exit code should be 0')
+    t.false(await pathExists(name), 'file should be removed')
+  })
+
+  !is_as(type) && test(`removes a file with newline in filename`, async t => {
+    const {
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const filename = 'line1\nline2'
+    const filepath = await createFile({
+      name: filename
+    })
+
+    const result = await runRm([filepath])
+
+    t.is(result.code, 0, 'exit code should be 0')
+    t.false(await pathExists(filepath), 'file should be removed')
+  })
 }

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
@@ -60,7 +62,8 @@ const generateContextMethods = (
   function runRm (args, {
     input = [],
     command = rm_command,
-    env: arg_env = {}
+    env: arg_env = {},
+    cwd
   } = {}) {
     return new Promise((resolve, reject) => {
       const env = {
@@ -73,7 +76,8 @@ const generateContextMethods = (
       }
 
       const child = spawn(command, args, {
-        env
+        env,
+        cwd
       })
       let stdout = ''
       let stderr = ''
@@ -81,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
@@ -142,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