safe-rm 3.1.4 → 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
@@ -498,6 +498,43 @@ get_absolute_path(){
 }
 
 
+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"/* ]]
+}
+
+
 # Returns
 # - 0: the target is protected
 # - 1: the target is not protected
@@ -559,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
 }
 
 
@@ -651,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
 
-    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 +736,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 +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=$?
@@ -739,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
 

package/package.json

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

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