safe-rm 1.0.8 → 3.0.0

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "safe-rm",
-  "version": "1.0.8",
+  "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"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "ava --timeout=10s --verbose",
+    "test:dev": "NODE_DEBUG=safe-rm npm run test",
+    "test:debug": "SAFE_RM_DEBUG=1 npm run test:dev",
+    "test:mock-linux": "SAFE_RM_DEBUG_LINUX=1 npm run test",
+    "test:mock-linux:debug": "SAFE_RM_DEBUG=1 SAFE_RM_DEBUG_LINUX=1 npm run test:dev",
+    "lint": "eslint .",
+    "fix": "eslint . --fix"
   },
   "repository": {
     "type": "git",
@@ -14,15 +20,32 @@
   },
   "keywords": [
     "safe-rm",
+    "cli",
     "rm",
     "linux",
     "alternative",
     "trash"
   ],
+  "ava": {
+    "files": [
+      "test/*.test.js"
+    ]
+  },
   "author": "kael",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/kaelzhang/shell-safe-rm/issues"
   },
-  "homepage": "https://github.com/kaelzhang/shell-safe-rm#readme"
+  "homepage": "https://github.com/kaelzhang/shell-safe-rm#readme",
+  "devDependencies": {
+    "@ostai/eslint-config": "^4.0.0",
+    "ava": "^6.2.0",
+    "delay": "^5.0.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-import": "^2.31.0",
+    "fs-extra": "^11.2.0",
+    "home": "^2.0.0",
+    "tmp": "^0.2.3",
+    "uuid": "^11.0.3"
+  }
 }

package/test/cases.js

@@ -0,0 +1,275 @@
+const path = require('path')
+const {v4: uuid} = require('uuid')
+const delay = require('delay')
+
+const {
+  generateContextMethods,
+  assertEmptySuccess,
+  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,
+  {
+    type,
+    // test_trash_dir,
+    command = SAFE_RM_PATH,
+    env = {}
+  } = {}
+) => {
+  // Setup before each test
+  test.beforeEach(generateContextMethods(command, env))
+
+  test(`removes a single file`, async t => {
+    const {
+      createFile,
+      runRm,
+      pathExists,
+      lsFileInTrash
+    } = t.context
+
+    const filepath = await createFile()
+    const result = await runRm([filepath])
+
+    t.is(result.code, 0, 'exit code should be 0')
+    t.false(await pathExists(filepath), 'file should be removed')
+
+    if (should_skip_test_trash_dir(type)) {
+      return
+    }
+
+    const files = await lsFileInTrash(filepath)
+
+    t.is(files.length, 1, 'should be one in the trash')
+    t.is(
+      path.basename(files[0]),
+      path.basename(filepath),
+      'file name should match'
+    )
+  })
+
+  const EXTs = [
+    '',
+    '.jpg'
+  ]
+
+  EXTs.forEach(ext => {
+    const extra = ext
+      ? ` with ext "${ext}"`
+      : ''
+
+    test(`removes multiple files of the same name${extra}`, async t => {
+      const {
+        createFile,
+        runRm,
+        pathExists,
+        lsFileInTrash
+      } = t.context
+
+      const filename = uuid()
+      const full_name = filename + ext
+
+      const now = Date.now()
+      const to_next_second = 1000 - now % 1000
+      await delay(to_next_second)
+
+      const filepath1 = await createFile({name: full_name, content: '1'})
+      const result1 = await runRm([filepath1])
+
+      const filepath2 = await createFile({name: full_name, content: '2'})
+      const result2 = await runRm([filepath2])
+
+      const filepath3 = await createFile({name: full_name, content: '3'})
+      const result3 = await runRm([filepath3])
+
+      assertEmptySuccess(t, result1)
+      t.false(await pathExists(filepath1), 'file 1 should be removed')
+
+      assertEmptySuccess(t, result2)
+      t.false(await pathExists(filepath2), 'file 2 should be removed')
+
+      assertEmptySuccess(t, result3)
+      t.false(await pathExists(filepath3), 'file 3 should be removed')
+
+      if (should_skip_test_trash_dir(type)) {
+        return
+      }
+
+      const files = (await lsFileInTrash(full_name))
+      .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 [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)
+      } else {
+        // /path/to/foo[.jpg]
+        // /path/to/foo[.jpg].1
+        // /path/to/foo[.jpg].2
+        const nums = []
+        const bases = []
+        const re = /(\.(\d+))?$/
+
+        for (const file of files) {
+          const match = file.match(re)
+          const n = match[2]
+            ? parseInt(match[2], 10)
+            : 0
+
+          const f = file.slice(0, match.index)
+
+          nums.push(n)
+          bases.push(f)
+        }
+
+        t.true(bases.every(f => f.endsWith(ext)), 'should have the same ext')
+        t.is(nums[0], 0)
+        t.is(nums[1], 1)
+        t.is(nums[2], 2)
+      }
+    })
+  })
+
+  test(`removes a single file in trash permanently`, async t => {
+    const {
+      trash_path,
+      createFile,
+      runRm,
+      pathExists,
+      lsFileInTrash
+    } = t.context
+
+    const filepath = await createFile({name: path.join(trash_path, uuid())})
+    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')
+
+    if (should_skip_test_trash_dir(type)) {
+      return
+    }
+
+    const files = await lsFileInTrash(filepath)
+
+    t.is(files.length, 0, 'should be already removed')
+  })
+
+  test(`#22 exit code with -f option`, async t => {
+    const {
+      source_path,
+      runRm
+    } = t.context
+
+    const filepath = path.join(source_path, uuid())
+    const result = await runRm(['-f', filepath])
+
+    assertEmptySuccess(t, result, ', if rm -f a non-existing file')
+
+    const result_no_f = await runRm([filepath])
+
+    t.is(result_no_f.code, 1, 'exit code should be 1 without -f')
+    t.is(result_no_f.stdout, '', 'stdout should be empty')
+
+    t.true(
+      // The stderr of different rm distributions may vary:
+      // - Linux rm: "rm: cannot remove 'nonexistent.txt': No such file or directory"
+      // - Mac rm: "rm: nonexistent.txt: No such file or directory"
+      // So we just check if the stderr includes "No such file or directory"
+      result_no_f.stderr.includes('No such file or directory'), `stderr should include "No such file or directory": ${
+        result_no_f.stderr
+      }`)
+  })
+
+  test(`removes an empty directory: -d`, async t => {
+    const {
+      createDir,
+      runRm,
+      pathExists
+    } = t.context
+
+    const dirpath = await createDir()
+    const result1 = await runRm([dirpath])
+
+    t.is(result1.code, 1, 'exit code should be 1')
+    t.true(result1.stderr.includes('a directory'), 'stderr should include "a directory"')
+
+    const result2 = await runRm(['-d', dirpath])
+
+    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

@@ -0,0 +1,178 @@
+const path = require('path')
+const fs = require('fs').promises
+const {spawn} = require('child_process')
+const tmp = require('tmp')
+const fse = require('fs-extra')
+const {v4: uuid} = require('uuid')
+const log = require('util').debuglog('safe-rm')
+
+const TEST_DIR = path.join(tmp.dirSync().name, 'safe-rm-tests')
+
+const IS_MACOS = process.platform === 'darwin'
+  // For linux mock testing
+  && !process.env.SAFE_RM_DEBUG_LINUX
+
+const generateContextMethods = (
+  rm_command,
+  rm_command_env
+) => async t => {
+  const root_path = path.join(TEST_DIR, uuid())
+  t.context.root = await fse.ensureDir(root_path)
+
+  const source_path = t.context.source_path = path.join(root_path, 'source')
+  const trash = rm_command_env.SAFE_RM_TRASH
+    ? rm_command_env.SAFE_RM_TRASH
+    : path.join(root_path, 'trash')
+
+  t.context.trash_path = process.platform === 'darwin'
+    ? trash
+    : path.join(trash, 'files')
+
+  await Promise.all([
+    fse.ensureDir(source_path),
+    fse.ensureDir(t.context.trash_path)
+  ])
+
+  // Helper function to create a temporary directory
+  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 ({
+    name = uuid(),
+    content = 'test content',
+    under
+  } = {}) {
+    const filepath = path.resolve(under || t.context.source_path, name)
+    await fs.writeFile(filepath, content)
+
+    return filepath
+  }
+
+  // Helper function to run rm commands
+  function runRm (args, {
+    input = '',
+    command = rm_command,
+    env: arg_env = {}
+  } = {}) {
+    return new Promise(resolve => {
+      const env = {
+        // ...process.env,
+        ...{
+          SAFE_RM_TRASH: t.context.trash_path
+        },
+        ...rm_command_env,
+        ...arg_env
+      }
+
+      const child = spawn(command, args, {
+        env
+      })
+      let stdout = ''
+      let stderr = ''
+
+      child.stdout.on('data', data => {
+        stdout += data.toString()
+      })
+
+      child.stderr.on('data', data => {
+        stderr += data.toString()
+      })
+
+      if (input) {
+        if (!child.stdin) {
+          throw new Error('Child process does not support stdin')
+        }
+
+        child.stdin.write(input)
+        child.stdin.end()
+      }
+
+      child.on('close', code => {
+        const resolved = {
+          code,
+          stdout,
+          stderr
+        }
+
+        log(command, 'result:', resolved)
+
+        resolve(resolved)
+      })
+    })
+  }
+
+  // Helper function to check if path exists
+  async function pathExists (filepath) {
+    const realpath = path.resolve(t.context.source_path, filepath)
+
+    try {
+      await fs.access(realpath)
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+
+  async function lsFileInMacTrash (filepath) {
+    const {trash_path} = t.context
+
+    const files = await fs.readdir(trash_path)
+
+    const _filename = path.basename(filepath)
+    const ext = path.extname(_filename)
+    const filename = path.basename(_filename, ext)
+
+    const filtered = files.filter(
+      f => f.endsWith(ext) && f.startsWith(filename)
+    ).map(f => path.join(trash_path, f))
+
+    return filtered
+  }
+
+  async function lsFileInLinuxTrash (filepath) {
+    const {trash_path: _trash_path} = t.context
+    const trash_path = path.join(_trash_path, 'files')
+
+    const filename = path.basename(filepath)
+
+    const files = await fs.readdir(trash_path)
+
+    return files
+    .filter(f => f.startsWith(filename))
+    .map(f => path.join(trash_path, f))
+  }
+
+  async function lsFileInTrash (filepath) {
+    return IS_MACOS
+      ? lsFileInMacTrash(filepath)
+      : lsFileInLinuxTrash(filepath)
+  }
+
+  Object.assign(t.context, {
+    createDir,
+    createFile,
+    runRm,
+    pathExists,
+    lsFileInTrash
+  })
+}
+
+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}`)
+}
+
+module.exports = {
+  generateContextMethods,
+  assertEmptySuccess,
+  IS_MACOS
+}

package/test/rm.test.js

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

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

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

package/test/safe-rm.test.js

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

package/test/argument.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-n=1
-
-echo ${!n}

package/test/fold.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-
-n=-abcde
-
-split_echo(){
-    split=`echo $1 | fold -w1`
-
-    local s
-
-    for s in ${split[@]}
-    do
-        echo $s
-    done
-}
-
-split_echo $n
-
-echo $s
-
-cut_echo(){
-    echo "remove leading char ${1:1}"
-}
-
-cut_echo abcdefg
-
-
-match(){
-    if [[ ${1:0:1} =~ [aA] ]]; then
-        echo start with a
-    else
-        echo no
-    fi
-}
-
-match abc
-
-match Acbdfd
-match ddd
-

package/test/for.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-
-print(){
-    for path in $1/*
-    do
-        echo $path
-    done
-}
-
-
-print $1
-
-n=
-a=2
-
-[[ $n ]] && echo "n set" || {
-    echo "n not set"
-    a=1
-}
-
-echo $a

package/test/nested-switch.sh

@@ -1,72 +0,0 @@
-#!/bin/bash
-
-
-print(){
-    case $1 in
-        1[0-9][0-9]*)
-            echo 1
-            ;;
-
-        1[0-9]*)
-            echo 3
-            ;;
-
-        1)
-            echo 4
-            ;;
-
-        *)
-            echo 5
-            ;;
-    esac
-}
-
-print_2(){
-    case $1 in
-        1[0-9]+)
-            echo 1
-            ;;
-
-        1[0-9]*)
-            echo 2
-            ;;
-        *)
-            echo 3
-            ;;
-    esac
-}
-
-print_3(){
-    case $1 in
-        .|..)
-            echo 1
-            ;;
-
-        a)
-            echo 2
-            ;;
-
-        aa)
-            echo 3
-            ;;
-    esac
-}
-
-print 1234
-print 123
-print 12
-print 1
-
-echo ---------
-
-print_2 1234
-print_2 123
-print_2 12
-print_2 1
-
-echo ---------
-
-print_3 a
-print_3 aa
-print_3 ..
-print_3 .