CHANGELOG.md

@@ -3,6 +3,7 @@
 - Improved hybrid module with no need to look at the `.default`
   dangly bit.  `.default` preserved as a reference to `rimraf`
   for compatibility with anyone who came to rely on it in v4.0.
+- Accept and ignore `-rf` and `-fr` arguments to the bin.
 
 # v4.0
 
@@ -14,6 +15,8 @@
 - Drop support for Node.js below version 14
 - rewrite in TypeScript
 - ship CJS/ESM hybrid module
+- Error on ignore unknown arguments to the bin. (Previously they
+  were silently ignored.)
 
 # v3.0
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rimraf",
-  "version": "4.1.1",
+  "version": "4.1.2",
   "main": "./dist/cjs/src/index-cjs.js",
   "module": "./dist/mjs/index.js",
   "bin": "./dist/cjs/src/bin.js",

src/bin.ts

@@ -53,6 +53,9 @@ const main = async (...args: string[]) => {
     if (arg === '--') {
       dashdash = true
       continue
+    } else if (arg === '-rf' || arg === '-fr') {
+      // this never did anything, but people put it there I guess
+      continue
     } else if (arg === '-h' || arg === '--help') {
       console.log(help)
       return 0

src/index.ts

@@ -10,30 +10,26 @@ export interface RimrafOptions {
   maxBackoff?: number
 }
 
-/* c8 ignore start */
 const typeOrUndef = (val: any, t: string) =>
   typeof val === 'undefined' || typeof val === t
-/* c8 ignore stop */
 
 export const isRimrafOptions = (o: any): o is RimrafOptions =>
   !!o &&
   typeof o === 'object' &&
   typeOrUndef(o.preserveRoot, 'boolean') &&
-  typeOrUndef(o.preserveRoot, 'number') &&
+  typeOrUndef(o.tmp, 'string') &&
   typeOrUndef(o.maxRetries, 'number') &&
   typeOrUndef(o.retryDelay, 'number') &&
   typeOrUndef(o.backoff, 'number') &&
   typeOrUndef(o.maxBackoff, 'number')
 
-/* c8 ignore start */
 export const assertRimrafOptions: (o: any) => void = (
   o: any
 ): asserts o is RimrafOptions => {
   if (!isRimrafOptions(o)) {
     throw new Error('invalid rimraf options')
   }
 }
-/* c8 ignore stop */
 
 import { rimrafManual, rimrafManualSync } from './rimraf-manual.js'
 import { rimrafMoveRemove, rimrafMoveRemoveSync } from './rimraf-move-remove.js'

test/bin.js

@@ -51,6 +51,21 @@ t.test('basic arg parsing stuff', t => {
     ])
   })
 
+  t.test('unnecessary -rf', async t => {
+    t.equal(await bin('-rf', 'foo'), 0)
+    t.equal(await bin('-fr', 'foo'), 0)
+    t.equal(await bin('foo', '-rf'), 0)
+    t.equal(await bin('foo', '-fr'), 0)
+    t.same(LOGS, [])
+    t.same(ERRS, [])
+    t.same(CALLS, [
+      ['rimraf', ['foo'], {}],
+      ['rimraf', ['foo'], {}],
+      ['rimraf', ['foo'], {}],
+      ['rimraf', ['foo'], {}],
+    ])
+  })
+
   t.test('dashdash', async t => {
     t.equal(await bin('--', '-h'), 0)
     t.same(LOGS, [])
@@ -134,7 +149,14 @@ t.test('basic arg parsing stuff', t => {
     t.same(CALLS, [])
   })
 
-  const impls = ['rimraf', 'native', 'manual', 'posix', 'windows', 'move-remove']
+  const impls = [
+    'rimraf',
+    'native',
+    'manual',
+    'posix',
+    'windows',
+    'move-remove',
+  ]
   for (const impl of impls) {
     t.test(`--impl=${impl}`, async t => {
       t.equal(await bin('foo', `--impl=${impl}`), 0)

test/opt-arg.js

@@ -3,3 +3,78 @@ const optArg = require('../dist/cjs/src/opt-arg.js').default
 const opt = { a: 1 }
 t.equal(optArg(opt), opt, 'returns object if provided')
 t.same(optArg(), {}, 'returns new object otherwise')
+
+t.throws(() => optArg(true))
+t.throws(() => optArg(null))
+t.throws(() => optArg('hello'))
+t.throws(() => optArg({ maxRetries: 'banana' }))
+
+t.test('every kind of invalid option value', t => {
+  // skip them when it's undefined, and skip the case
+  // where they're all undefined, otherwise try every
+  // possible combination of the values here.
+  const badBool = [undefined, 1, null, 'x', {}]
+  const badNum = [undefined, true, false, null, 'x', '1', {}]
+  const badStr = [undefined, { toString: () => 'hi' }, /hi/, Symbol.for('hi')]
+  for (const preserveRoot of badBool) {
+    for (const tmp of badStr) {
+      for (const maxRetries of badNum) {
+        for (const retryDelay of badNum) {
+          for (const backoff of badNum) {
+            for (const maxBackoff of badNum) {
+              if (
+                preserveRoot === undefined &&
+                maxRetries === undefined &&
+                retryDelay === undefined &&
+                backoff === undefined &&
+                maxBackoff === undefined
+              ) {
+                continue
+              }
+              t.throws(() =>
+                optArg({
+                  preserveRoot,
+                  maxRetries,
+                  retryDelay,
+                  backoff,
+                  maxBackoff,
+                })
+              )
+            }
+          }
+        }
+      }
+    }
+  }
+  t.end()
+})
+
+t.test('test every allowed combination', t => {
+  const goodBool = [undefined, true, false]
+  // note that a few of these actually aren't *valid*,
+  // but it's verifying what the initial opt checker does.
+  const goodNum = [undefined, 1, Math.pow(2, 32), -1]
+  const goodStr = [undefined, 'hi']
+  for (const preserveRoot of goodBool) {
+    for (const tmp of goodStr) {
+      for (const maxRetries of goodNum) {
+        for (const retryDelay of goodNum) {
+          for (const backoff of goodNum) {
+            for (const maxBackoff of goodNum) {
+              t.ok(
+                optArg({
+                  preserveRoot,
+                  maxRetries,
+                  retryDelay,
+                  backoff,
+                  maxBackoff,
+                })
+              )
+            }
+          }
+        }
+      }
+    }
+  }
+  t.end()
+})