feat(mvMode): create mv mode

Author: jedwards1211

README.md

@@ -5,7 +5,7 @@
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 [![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
 
-## Turing-complete JS commandline JSON/text transformer
+## Turing-complete JS commandline JSON/text transformer and file renamer
 
 Can't remember how `sed` works.
 Can't remember how `cut` works.
@@ -75,6 +75,21 @@ Doe, John
 ]
 ```
 
+##### Rename .jsx files in the current directory to .js:
+```
+duh mv *.jsx 'file => file.replace(/\.jsx$/g, ".js")'
+```
+
+##### Rename all .jsx files in the current subtree to .js:
+```
+find . -name *.jsx | duh mv 'file => file.replace(/\.jsx$/g, ".js")'
+```
+
+##### Flatten music stored as artist/album/filename into a single directory:
+```
+duh mv */*/* 'file => { var [artist, album, file] = file.split(/\//g); return `${artist} - ${album} - ${file}` }'
+```
+
 ## Node version note
 
 The syntax that `duh` accepts for your function depends on the version of Node you're running.  If you're running a
@@ -88,6 +103,7 @@ You can use `lambduh` or just `duh`.
 
 You may have noticed above that you can apply a transformation to each line of a plain text file.
 This is pretty much the only magic built into the `duh` command:
+* If the first argument is `mv` (rather than a function), it runs in **move mode**.
 * If the first argument of your function is `lines` (ignoring case), it runs in **lines mode**.
 * Otherwise if the first argument of your function starts with `l` or `L`, it runs in **line mode**.
 * If the first argument of your function starts with `t` or `T`, it runs in **text mode**.
@@ -117,6 +133,19 @@ in order to `stdout`.  Otherwise, it calls `String` on it and writes that string
 Calls your function with the entire text from stdin in a single string, and writes what your function returns to
 `stdout`.
 
+### Move Mode
+
+Move mode renames each file (or directory) in the arguments by applying your provided function
+(which must be the last argument) to each filename.  If you don't provide any files in the arguments, or one of your
+ arguments is a single dash (`-`), it will also read from stdin, treating each line as a filename.
+
+By default it will print the old and new filenames and then ask
+for confirmation before actually moving them.
+
+#### Options
+* `-y`: move the files without asking you to confirm the new names.
+* `--dry-run`: just print out the old and new file names, then exit.
+
 ## Customization
 
 `lambduh` requires any `.lambduh.js` files in the working directory or its ancestors (from root to deepest), as well

lib/index.js

@@ -4,32 +4,43 @@
 
 require('./loadRcFiles')
 
-if (!process.argv[2]) {
-  console.error('Error: first argument must evaluate to a function') // eslint-disable-line no-console
-  process.exit(1)
-}
+function parseFn(code) {
+  if (!code || !code.trim()) {
+    console.error('Error: missing function argument')  // eslint-disable-line no-console
+    process.exit(1)
+  }
 
-var fn = eval(process.argv[2].trim())
-if (typeof fn !== 'function') {
-  console.error('Error: first argument must evaluate to a function') // eslint-disable-line no-console
-  process.exit(1)
+  var fn
+  try {
+    fn = eval(code)
+  } catch (error) {
+    // ignore
+  }
+  if (typeof fn !== 'function') {
+    console.error('Error: invalid function: ' + code) // eslint-disable-line no-console
+    process.exit(1)
+  }
+  return fn
 }
 
-switch (require('./pickInputMode')(process.argv[2].trim())) {
+switch (require('./pickInputMode')(process.argv[2])) {
 case 'lines':
-  require('./linesMode')(fn)
+  require('./linesMode')(parseFn(process.argv[2]))
   break
 case 'line':
-  require('./lineMode')(fn)
+  require('./lineMode')(parseFn(process.argv[2]))
   break
 case 'text':
-  require('./textMode')(fn)
+  require('./textMode')(parseFn(process.argv[2]))
   break
 case 'json':
-  require('./jsonMode')(fn)
+  require('./jsonMode')(parseFn(process.argv[2]))
+  break
+case 'mv':
+  require('./mvMode')(parseFn(process.argv[Math.max(3, process.argv.length - 1)]))
   break
 default:
-  process.stderr.write("Error: Can't determine input mode!")
+  console.error('See ' + require('../package.json').repository.url + ' for usage information.') // eslint-disable-line no-console
   process.exit(1)
 }
 

lib/mvMode.js

@@ -0,0 +1,65 @@
+'use strict'
+
+module.exports = function mvMode(fn) {
+  var files = process.argv.slice(3, process.argv.length - 1).filter(function (file) {
+    return !file.startsWith('-')
+  })
+
+  if (process.argv.indexOf('-') > 0 || !files.length) {
+    require('line-reader').eachLine(
+      process.stdin,
+      function (file) {
+        files.push(file)
+      },
+      function done(error) {
+        if (error) {
+          console.error(error.stack) // eslint-disable-line no-console
+          process.exit(1)
+        }
+        ready()
+      }
+    )
+  } else ready()
+
+  function ready() {
+    run(files, fn, {
+      dryRun: process.argv.indexOf('--dry-run') >= 0,
+      noConfirm: process.argv.indexOf('-y') >= 0,
+    })
+  }
+
+  function run(files, fn, options) {
+    var dryRun = options.dryRun
+    var noConfirm = options.noConfirm
+    var silent = options.silent
+
+    var fs = require('fs')
+
+    files.forEach(function (oldPath) {
+      try {
+        var newPath = fn(oldPath)
+      } catch (error) {
+        console.error(error.stack) // eslint-disable-line no-console
+        process.exit(1)
+      }
+      if (newPath === oldPath) return
+      if (!silent) console[dryRun ? 'log' : 'error'](oldPath + ' -> ' + newPath) // eslint-disable-line no-console
+      if (!dryRun && noConfirm) fs.renameSync(oldPath, newPath)
+    })
+
+    if (!dryRun && !noConfirm) {
+      var rl = require('readline').createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      })
+
+      rl.question('Apply renaming? (y/N)', function (answer) {
+        rl.close()
+        if (answer && answer[0].toLowerCase() === 'y') {
+          run(files, fn, {noConfirm: true, silent: true})
+        }
+      })
+    }
+  }
+}
+

lib/pickInputMode.js

@@ -1,6 +1,9 @@
 'use strict'
 
 module.exports = function pickMode(code) {
+  if (!code) return null
+  if (code === 'mv') return 'mv'
+
   var match = /^\s*(function(\s+\w+)?\s*\(\s*|\(\s*)?(\w+)/.exec(code.toLowerCase())
   var firstArg = match && match[3]
 

test/index.js

@@ -2,11 +2,8 @@ var spawn = require('child_process').spawn
 var expect = require('chai').expect
 var pickInputMode = require('../lib/pickInputMode')
 
-function testCase(input, fn, output, done) {
-  var child = spawn(process.argv[0], [
-    require.resolve('../lib'),
-    fn,
-  ])
+function testCase(input, args, output, done) {
+  var child = spawn(process.argv[0], [require.resolve('../lib')].concat(args))
   var outchunks = []
   var errchunks = []
   child.stdout.on('data', function (chunk) { outchunks.push(chunk) })
@@ -33,15 +30,7 @@ describe('lambduh', function () {
     testCase(
       'input',
       '2881234',
-      new Error("first argument must evaluate to a function"),
-      done
-    )
-  })
-  it("errors if it can't determine input mode", function (done) {
-    testCase(
-      'input',
-      '() => {}',
-      new Error("Can't determine input mode!"),
+      new Error("invalid function"),
       done
     )
   })
@@ -68,6 +57,9 @@ describe('lambduh', function () {
       expect(pickInputMode('function aksnd923ka_( t ) { return t.toUpperCase() }')).to.equal('text')
       expect(pickInputMode('function blaAARrgh__(j){ return j.toUpperCase() }')).to.equal('json')
     })
+    it('works for mv', function () {
+      expect(pickInputMode('mv')).to.equal('mv')
+    })
     it("returns null if it can't find first argument", function () {
       expect(pickInputMode('(')).to.equal(null)
     })
@@ -160,5 +152,39 @@ describe('lambduh', function () {
       )
     })
   })
+  describe('mvMode', function () {
+    it('works for valid input', function (done) {
+      testCase(
+        'foo\nbar\nBAZ',
+        ['mv', '--dry-run', 'qux', '-', 'blah blah', 'file => file.toUpperCase()'],
+        'qux -> QUX\nblah blah -> BLAH BLAH\nfoo -> FOO\nbar -> BAR\n',
+        done
+      )
+    })
+    it('reads from STDIN when no files are given in arguments', function (done) {
+      testCase(
+        'foo\nbar\nBAZ',
+        ['mv', '--dry-run', 'file => file.toUpperCase()'],
+        'foo -> FOO\nbar -> BAR\n',
+        done
+      )
+    })
+    it("doesn't read from STDIN when file arguments are given", function (done) {
+      testCase(
+        'qux',
+        ['mv', '--dry-run', 'foo', 'bar', 'file => file.toUpperCase()'],
+        'foo -> FOO\nbar -> BAR\n',
+        done
+      )
+    })
+    it('handles errors in function', function (done) {
+      testCase(
+        'foo\nbar\nBAZ',
+        ['mv', '--dry-run', '-', 'file => { throw new Error("TEST") }'],
+        new Error("TEST"),
+        done
+      )
+    })
+  })
 })