safe-rm 2.0.0 → 3.0.0

package/.eslintrc.js

@@ -4,5 +4,6 @@ module.exports = {
   extends: require.resolve('@ostai/eslint-config'),
   rules: {
     'prefer-object-spread': OFF,
+    'import/no-unresolved': OFF
   }
 }

package/{sample.safe-rm.conf → .safe-rm/config}

@@ -1,11 +1,11 @@
 #!/bin/bash
 
 # This is a sample configuration file for safe-rm.
-# By default, you could copy this file to ~/.safe-rm.conf
+# By default, you could copy this file to ~/.safe-rm/config
 
 #
 # If you want to use a trash directory other than the default system trash,
-#   uncomment the line after divider `-----*`
+#   uncomment the line after divider `-----`
 #   and set the path to the desired trash directory.
 # By default, safe-rm will use the system trash.
 # -----------------------------------------------
@@ -13,7 +13,7 @@
 
 #
 # If you want to permanently delete files that are already in the trash,
-#   uncomment the line after divider `-----*`
+#   uncomment the line after divider `-----`
 # It defaults to 'no'.
 # Pay attention that any value that starts with 'y' or 'Y' will be treated as 'yes'.
 # -----------------------------------------------
@@ -21,19 +21,15 @@
 
 #
 # If you want to disable the use of AppleScript for moving files to the trash,
-#   uncomment the line after divider `-----*`
+#   uncomment the line after divider `-----`
 # It defaults to 'yes'.
 # By setting it to 'no', the "put-back" feature will be disabled for MacOS.
 # -----------------------------------------------
 # export SAFE_RM_USE_APPLESCRIPT=no
 
 #
-# The following directories or files will be protected and cannot be removed.
+# If you want to change the configuration root directory of safe-rm, in order to
+#   - put the .gitignore file in a different directory other than `~/.safe-rm/`
+# Uncomment the line after divider `-----`
 # -----------------------------------------------
-# export SAFE_RM_PROTECTED_TARGETS=/path/to/protected1:/path/to/protected2
-
-
-# Everything inside the following directories, excluding those directories,
-#   will be protected and cannot be removed.
-# -----------------------------------------------
-# export SAFE_RM_PROTECTED_DIRECTORIES=/path/to/dir1:/path/to/dir2
+# export SAFE_RM_CONFIG_ROOT=/usr/local/etc/safe-rm

package/README.md

@@ -12,7 +12,7 @@
 
 [![Build Status](https://github.com/kaelzhang/shell-safe-rm/actions/workflows/nodejs.yml/badge.svg)](https://github.com/kaelzhang/shell-safe-rm/actions/workflows/nodejs.yml)
 
-[Safe-rm][safe-rm], a much safer replacement of [`rm`][rm] with **ALMOST FULL** features of the origin [`rm`][rm] command.
+[Safe-rm][safe-rm], a drop-in and much safer replacement of the unix [`rm`][rm] command with **ALMOST FULL** features of the original [`rm`][rm].
 
 The project was initially developed for Mac OS X, and then tested on Linux.
 
@@ -115,25 +115,85 @@ sudo sh uninstall.sh
 
 ## Configuration
 
-Since 2.0.0, you could create a configuration file named `.safe-rm.conf` in your HOME directory, to support
+Since 3.0.0, you could create a configuration file located at `~/.safe-rm/config` in your `$HOME` directory, to support
 - defining your custom trash directory
 - allowing `safe-rm` to permanently delete files and directories that are already in the trash
 - disallowing `safe-rm` to use [AppleScript][applescript]
 
-For the description of each config, you could refer to the sample file [here](./sample.safe-rm.conf)
+For the description of each config, you could refer to the sample file [here](./.safe-rm/config)
+
+```sh
+# You could
+cp -r ./.safe-rm ~/
+```
 
 If you want to use a custom configuration file
 
 ```sh
-alias="SAFE_RM_CONF=/path/to/safe-rm.conf /path/to/bin/rm.sh"
+alias="SAFE_RM_CONFIG=/path/to/safe-rm.conf /path/to/shell-safe-rm/bin/rm.sh"
 ```
 
 Or if it is installed by npm:
 
 ```sh
-alias="SAFE_RM_CONF=/path/to/safe-rm.conf safe-rm"
+alias="SAFE_RM_CONFIG=/path/to/safe-rm.conf safe-rm"
 ```
 
+### Disable `Put-back` Functionality on MacOS (MacOS only)
+
+In `~/.safe-rm/config`
+
+```sh
+export SAFE_RM_USE_APPLESCRIPT=no
+```
+
+### Change the Default Trach Bin Other Than System Default
+
+```sh
+export SAFE_RM_TRASH=/path/to/trash
+```
+
+### Permanent Delete Files or Directories that Are Already in the Trash
+
+```sh
+export SAFE_RM_PERM_DEL_FILES_IN_TRASH=yes
+```
+
+### 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.
+
+If a path is matched by the rules that defined in `~/.safe-rm/.gitignore`, the path will be protected and could not be deleted by `safe-rm`
+
+For example, in the `~/.safe-rm/.gitignore`
+
+```.gitignore
+/path/to/be/protected
+```
+
+And when executing
+
+```sh
+$ safe-rm /path/to/be/protected           # or
+$ safe-rm /path/to/be/protected/foo       # or
+$ safe-rm -rf /path/to/be/protected/bar
+
+# An error will occur
+```
+
+But pay attention that, by adding the protected pattern above, if we:
+
+```sh
+$ safe-rm -rf /path/to
+```
+
+To keep the performance of `safe-rm` and avoid conducting unnecessary file system traversing, this would not prevent `/path/to/be/protected/foo` from removing.
+
+Pay **ATTENTION** that:
+- Before adding protected rules, i.e. placing the `.gitignore` inside the `"~/.safe-rm/"` directory, it requires `git` to be installed in your environment
+- The protected rules file applies to the root directory (/), which This means that the patterns defined within it need to be relative to the root directory.
+- Avoid adding `/` in the protected rules file, or everything will be protected
+
 
 [applescript]: https://en.wikipedia.org/wiki/AppleScript
 [rm]: https://en.wikipedia.org/wiki/Rm_(Unix)

package/bin/rm.sh

@@ -3,18 +3,19 @@
 # Basic configuration
 # ------------------------------------------------------------------------------
 
-DEFAULT_SAFE_RM_CONF="$HOME/.safe-rm.conf"
+DEFAULT_SAFE_RM_CONFIG="$HOME/.safe-rm/config"
 
 # You could modify the location of the configuration file by using
 # ```sh
-# $ export SAFE_RM_CONF=/path/to/safe-rm.conf
+# $ export SAFE_RM_CONFIG=/path/to/safe-rm.conf
 # ```
-SAFE_RM_CONF=${SAFE_RM_CONF:="$DEFAULT_SAFE_RM_CONF"}
+SAFE_RM_CONFIG=${SAFE_RM_CONFIG:="$DEFAULT_SAFE_RM_CONFIG"}
 
-if [[ -f "$SAFE_RM_CONF" ]]; then
-  source "$SAFE_RM_CONF"
+if [[ -f "$SAFE_RM_CONFIG" ]]; then
+  source "$SAFE_RM_CONFIG"
 fi
 
+SAFE_RM_CONFIG_ROOT=${SAFE_RM_CONFIG_ROOT:="$HOME/.safe-rm"}
 
 # Print debug info or not
 SAFE_RM_DEBUG=${SAFE_RM_DEBUG:=}
@@ -78,7 +79,7 @@ SAFE_RM_TRASH=${SAFE_RM_TRASH:="$DEFAULT_TRASH"}
 
 if [[ "$OS_TYPE" == "MacOS" ]]; then
   if command -v osascript &> /dev/null; then
-    # `SAFE_RM_USE_APPLESCRIPT=no` in your SAFE_RM_CONF file
+    # `SAFE_RM_USE_APPLESCRIPT=no` in your SAFE_RM_CONFIG file
     #   to disable AppleScript
     if [[ "$SAFE_RM_USE_APPLESCRIPT" == "no" ]]; then
       debug "$LINENO: applescript disabled by conf"
@@ -110,6 +111,37 @@ else
   fi
 fi
 
+
+SAFE_RM_PROTECTED_RULES="${SAFE_RM_CONFIG_ROOT}/.gitignore"
+
+debug $SAFE_RM_PROTECTED_RULES
+
+# But if it is not a file
+if [[ -f "$SAFE_RM_PROTECTED_RULES" ]]; then
+  if command -v git &> /dev/null; then
+    debug "$LINENO: protected rules enabled: $SAFE_RM_PROTECTED_RULES"
+
+    if git -C "$SAFE_RM_CONFIG_ROOT" rev-parse --is-inside-work-tree &> /dev/null; then
+      :
+    else
+      error "[WARNING] safe-rm requires a git repository to use protected rules"
+      error "Initializing a git repository in \"$SAFE_RM_CONFIG_ROOT\" ..."
+
+      git -C "$SAFE_RM_CONFIG_ROOT" init -q
+
+      error "Success"
+    fi
+  else
+    error "[WARNING] safe-rm requires git installed to use protected rules"
+    error "  please install git"
+    error "  or remove the file \"$SAFE_RM_PROTECTED_RULES\""
+    SAFE_RM_PROTECTED_RULES=
+  fi
+else
+  SAFE_RM_PROTECTED_RULES=
+fi
+
+
 # ------------------------------------------------------------------------------
 
 # Simple basename: /bin/rm -> rm
@@ -145,6 +177,7 @@ if [[ "$#" == 0 ]]; then
   usage
 fi
 
+
 ARG_END=
 FILE_NAME=
 ARG=
@@ -299,6 +332,14 @@ if [[ ! -e $SAFE_RM_TRASH ]]; then
 fi
 
 
+check_return_status(){
+  local status=$?
+  if [[ $status -ne "0" ]]; then
+    debug "$LINENO: last command returned status $status"
+    EXIT_CODE=$status
+  fi
+}
+
 # try to remove a file or directory
 remove(){
   local file=$1
@@ -355,7 +396,7 @@ remove(){
       # The file
       # - is a symbolic link
       # - is a file
-      # - does not existx
+      # - does not exist
       trash "$file"
       debug "$LINENO: trash returned status $?"
     fi
@@ -405,18 +446,61 @@ trash(){
   else
     do_trash "$target"
   fi
+
+  check_return_status
 }
 
 
 do_trash(){
-  debug "$LINENO: trash $1"
+  local target=$1
+
+  debug "$LINENO: trash $target"
+
+  if is_protected "$target"; then
+    error "\"$target\" is protected by your configuration"
+    return 1
+  fi
 
   if [[ -n $SAFE_RM_USE_APPLESCRIPT ]]; then
-    applescript_trash "$1"
+    applescript_trash "$target"
   elif [[ "$OS_TYPE" == "MacOS" ]]; then
-    mac_trash "$1"
+    mac_trash "$target"
+  else
+    linux_trash "$target"
+  fi
+}
+
+
+get_absolute_path(){
+  echo $(cd "$(dirname "$1")" && pwd)/$(basename "$1")
+}
+
+
+# Returns
+# - 0: the target is protected
+# - 1: the target is not protected
+is_protected(){
+  if [[ ! -n $SAFE_RM_PROTECTED_RULES ]]; then
+    # If no protected rules are set, the target is not protected
+    return 1
+  fi
+
+  local target=$1
+  local abs_path=$(get_absolute_path "$target")
+
+  # /path/to/foo -> path/to/foo
+  local rel_path=${abs_path#/}
+
+  debug "$LINENO: check whether $rel_path is protected"
+
+  local ignored=$(git -C "$SAFE_RM_CONFIG_ROOT" check-ignore -v --no-index "$rel_path")
+
+  debug "$LINENO: git check-ignore result: $ignored"
+
+  if [[ -n "$ignored" ]]; then
+    return 0
   else
-    linux_trash "$1"
+    return 1
   fi
 }
 
@@ -523,6 +607,9 @@ mac_trash(){
 }
 
 
+# Check if the base name already exists in the trash
+# If it does, foo -> foo.1
+# If foo.1 exists, foo.1 -> foo.2
 check_linux_trash_base(){
   local base=$1
   local trash="$SAFE_RM_TRASH/files"

package/package.json

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

@@ -1,7 +1,6 @@
 const path = require('path')
 const {v4: uuid} = require('uuid')
 const delay = require('delay')
-const log = require('util').debuglog('safe-rm')
 
 const {
   generateContextMethods,
@@ -9,19 +8,30 @@ const {
   IS_MACOS
 } = require('./helper')
 
+const SAFE_RM_PATH = path.join(__dirname, '..', 'bin', 'rm.sh')
+
+const is_rm = type => type === 'rm'
+// const is_safe_rm = type => type === 'safe-rm'
+
+// Whether it is a test spec for AppleScript version of safe-rm
+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)
 
 module.exports = (
   test,
-  des_prefix,
-  test_trash_dir = true,
-  rm_command,
-  env = {}
+  {
+    type,
+    // test_trash_dir,
+    command = SAFE_RM_PATH,
+    env = {}
+  } = {}
 ) => {
-
   // Setup before each test
-  test.beforeEach(generateContextMethods(rm_command, env))
+  test.beforeEach(generateContextMethods(command, env))
 
-  test(`${des_prefix}: removes a single file`, async t => {
+  test(`removes a single file`, async t => {
     const {
       createFile,
       runRm,
@@ -35,7 +45,7 @@ module.exports = (
     t.is(result.code, 0, 'exit code should be 0')
     t.false(await pathExists(filepath), 'file should be removed')
 
-    if (!test_trash_dir) {
+    if (should_skip_test_trash_dir(type)) {
       return
     }
 
@@ -43,7 +53,8 @@ module.exports = (
 
     t.is(files.length, 1, 'should be one in the trash')
     t.is(
-      path.basename(files[0]), path.basename(filepath),
+      path.basename(files[0]),
+      path.basename(filepath),
       'file name should match'
     )
   })
@@ -58,7 +69,7 @@ module.exports = (
       ? ` with ext "${ext}"`
       : ''
 
-    test(`${des_prefix}: removes multiple files of the same name${extra}`, async t => {
+    test(`removes multiple files of the same name${extra}`, async t => {
       const {
         createFile,
         runRm,
@@ -73,13 +84,13 @@ module.exports = (
       const to_next_second = 1000 - now % 1000
       await delay(to_next_second)
 
-      const filepath1 = await createFile(full_name, '1')
+      const filepath1 = await createFile({name: full_name, content: '1'})
       const result1 = await runRm([filepath1])
 
-      const filepath2 = await createFile(full_name, '2')
+      const filepath2 = await createFile({name: full_name, content: '2'})
       const result2 = await runRm([filepath2])
 
-      const filepath3 = await createFile(full_name, '3')
+      const filepath3 = await createFile({name: full_name, content: '3'})
       const result3 = await runRm([filepath3])
 
       assertEmptySuccess(t, result1)
@@ -91,11 +102,10 @@ module.exports = (
       assertEmptySuccess(t, result3)
       t.false(await pathExists(filepath3), 'file 3 should be removed')
 
-      if (!test_trash_dir) {
+      if (should_skip_test_trash_dir(type)) {
         return
       }
 
-
       const files = (await lsFileInTrash(full_name))
       .sort((a, b) => a.length - b.length)
 
@@ -120,6 +130,7 @@ module.exports = (
         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)
 
@@ -136,7 +147,7 @@ module.exports = (
         for (const file of files) {
           const match = file.match(re)
           const n = match[2]
-            ? parseInt(match[2])
+            ? parseInt(match[2], 10)
             : 0
 
           const f = file.slice(0, match.index)
@@ -153,7 +164,7 @@ module.exports = (
     })
   })
 
-  test(`${des_prefix}: removes a single file in trash permanently`, async t => {
+  test(`removes a single file in trash permanently`, async t => {
     const {
       trash_path,
       createFile,
@@ -162,7 +173,7 @@ module.exports = (
       lsFileInTrash
     } = t.context
 
-    const filepath = await createFile(path.join(trash_path, uuid()))
+    const filepath = await createFile({name: path.join(trash_path, uuid())})
     const result = await runRm([filepath], {
       env: {
         SAFE_RM_PERM_DEL_FILES_IN_TRASH: 'yes'
@@ -172,7 +183,7 @@ module.exports = (
     assertEmptySuccess(t, result)
     t.false(await pathExists(filepath), 'file should be removed')
 
-    if (!test_trash_dir) {
+    if (should_skip_test_trash_dir(type)) {
       return
     }
 
@@ -181,13 +192,10 @@ module.exports = (
     t.is(files.length, 0, 'should be already removed')
   })
 
-  test(`${des_prefix}: #22 exit code with -f option`, async t => {
+  test(`#22 exit code with -f option`, async t => {
     const {
       source_path,
-      createFile,
-      runRm,
-      pathExists,
-      lsFileInTrash
+      runRm
     } = t.context
 
     const filepath = path.join(source_path, uuid())
@@ -210,7 +218,7 @@ module.exports = (
       }`)
   })
 
-  test(`${des_prefix}: removes an empty directory: -d`, async t => {
+  test(`removes an empty directory: -d`, async t => {
     const {
       createDir,
       runRm,
@@ -228,4 +236,40 @@ module.exports = (
     assertEmptySuccess(t, result2)
     t.false(await pathExists(dirpath), 'directory should be removed')
   })
+
+  // Only test for safe-rm
+  !is_rm(type) && test(`protected rules`, async t => {
+    const {
+      createDir,
+      createFile,
+      runRm,
+      pathExists
+    } = t.context
+
+    const config_root = await createDir({
+      name: '.safe-rm'
+    })
+
+    const dir = await createDir()
+    const filepath = await createFile({
+      under: dir
+    })
+
+    await createFile({
+      name: '.gitignore',
+      under: config_root,
+      content: `${dir}
+`
+    })
+
+    const result = await runRm([filepath], {
+      env: {
+        SAFE_RM_CONFIG_ROOT: config_root
+      }
+    })
+
+    t.is(result.code, 1, 'exit code should be 1')
+    t.true(result.stderr.includes('protected'), 'stderr should include "protected"')
+    t.true(await pathExists(filepath), 'file should not be removed')
+  })
 }

package/test/helper.js

@@ -6,7 +6,6 @@ const fse = require('fs-extra')
 const {v4: uuid} = require('uuid')
 const log = require('util').debuglog('safe-rm')
 
-const SAFE_RM_PATH = path.join(__dirname, '..', 'bin', 'rm.sh')
 const TEST_DIR = path.join(tmp.dirSync().name, 'safe-rm-tests')
 
 const IS_MACOS = process.platform === 'darwin'
@@ -14,8 +13,8 @@ const IS_MACOS = process.platform === 'darwin'
   && !process.env.SAFE_RM_DEBUG_LINUX
 
 const generateContextMethods = (
-  rm_command = SAFE_RM_PATH,
-  rm_command_env = {}
+  rm_command,
+  rm_command_env
 ) => async t => {
   const root_path = path.join(TEST_DIR, uuid())
   t.context.root = await fse.ensureDir(root_path)
@@ -25,26 +24,33 @@ const generateContextMethods = (
     ? rm_command_env.SAFE_RM_TRASH
     : path.join(root_path, 'trash')
 
-  const trash_path = t.context.trash_path = process.platform === 'darwin'
+  t.context.trash_path = process.platform === 'darwin'
     ? trash
     : path.join(trash, 'files')
 
   await Promise.all([
     fse.ensureDir(source_path),
-    fse.ensureDir(trash_path)
+    fse.ensureDir(t.context.trash_path)
   ])
 
   // Helper function to create a temporary directory
-  async function createDir (dirname = uuid()) {
-    const dirpath = path.resolve(t.context.source_path, dirname)
+  async function createDir ({
+    name = uuid(),
+    under
+  } = {}) {
+    const dirpath = path.resolve(under || t.context.source_path, name)
     await fse.ensureDir(dirpath)
 
     return dirpath
   }
 
   // Helper function to create a temporary file
-  async function createFile (filename = uuid(), content = 'test content') {
-    const filepath = path.resolve(t.context.source_path, filename)
+  async function createFile ({
+    name = uuid(),
+    content = 'test content',
+    under
+  } = {}) {
+    const filepath = path.resolve(under || t.context.source_path, name)
     await fs.writeFile(filepath, content)
 
     return filepath
@@ -58,7 +64,7 @@ const generateContextMethods = (
   } = {}) {
     return new Promise(resolve => {
       const env = {
-        ...process.env,
+        // ...process.env,
         ...{
           SAFE_RM_TRASH: t.context.trash_path
         },
@@ -115,7 +121,6 @@ const generateContextMethods = (
     }
   }
 
-
   async function lsFileInMacTrash (filepath) {
     const {trash_path} = t.context
 
@@ -161,9 +166,9 @@ const generateContextMethods = (
 }
 
 const assertEmptySuccess = (t, result, a = '', b = '', c = '') => {
-  t.is(result.code, 0, 'exit code should be 0' + a)
-  t.is(result.stdout, '', 'stdout should be empty' + b)
-  t.is(result.stderr, '', 'stderr should be empty' + c)
+  t.is(result.code, 0, `exit code should be 0${a}`)
+  t.is(result.stdout, '', `stdout should be empty${b}`)
+  t.is(result.stderr, '', `stderr should be empty${c}`)
 }
 
 module.exports = {

package/test/rm.test.js

@@ -1,5 +1,8 @@
 const test = require('ava')
 
-const factory = require('./cases')
+const run = require('./cases')
 
-factory(test, 'rm', false, '/bin/rm')
+run(test, {
+  type: 'rm',
+  command: '/bin/rm'
+})

package/test/safe-rm-as.test.js

@@ -1,8 +1,11 @@
 const test = require('ava')
 const home = require('home')
 
-const factory = require('./cases')
+const run = require('./cases')
 
-factory(test, 'safe-rm-as', false, undefined, {
-  SAFE_RM_TRASH: home.resolve('~/.Trash')
+run(test, {
+  type: 'safe-rm-as',
+  env: {
+    SAFE_RM_TRASH: home.resolve('~/.Trash')
+  }
 })

package/test/safe-rm.test.js

@@ -1,5 +1,7 @@
 const test = require('ava')
 
-const factory = require('./cases')
+const run = require('./cases')
 
-factory(test, 'safe-rm')
+run(test, {
+  type: 'safe-rm'
+})

package/test/code.js

@@ -1,56 +0,0 @@
-const test = require('ava')
-const {v4: uuid} = require('uuid')
-
-const {
-  generateContextMethods
-} = require('./helper')
-
-const RM_PATH = '/bin/rm'
-
-
-// Setup before each test
-test.beforeEach(generateContextMethods)
-
-// Cleanup after each test
-test.afterEach.always(async t => {
-  t.context.cleanup()
-})
-
-
-const CASES = [
-  [
-    // Directories
-    [],
-    // Files
-    [uuid()],
-    // args
-    []
-  ]
-]
-
-CASES.forEach((c, i) => {
-  test(`${i}: rm`, async t => {
-    const [dirs, files, _args, files_to_del = files] = typeof c === 'function'
-      ? c(t)
-      : c
-
-    const args = typeof _args === 'function'
-      ? _args(files_to_del)
-
-    const dirpaths = await Promise.all(dirs.map(t.context.dir))
-    const filepaths = await Promise.all(files.map(t.context.file))
-
-    const result = await runRm([...args, ...filepaths, ...dirpaths], {
-      command: RM_PATH
-    })
-
-    t.is(result.code, 0)
-
-    for (const filepath of filepaths) {
-      t.false(await pathExists(filepath))
-    }
-
-    for (const dirpath of dirpaths) {
-      t.false(await pathExists
-  })
-})