style(project): apply eslint-hahow

Author: raccoon-lee

.eslintrc

@@ -0,0 +1,3 @@
+{
+  "extends": ["hahow"]
+}

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["esbenp.prettier-vscode", "dbaeumer.vscode-eslint"]
+}

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+  "editor.formatOnSave": true,
+  "jshint.enable": false,
+  "eslint.enable": true,
+  "eslint.autoFixOnSave": true,
+  "prettier.eslintIntegration": true,
+  "prettier.singleQuote": true
+}

lib/index.js

@@ -1,10 +1,12 @@
+'use strict'
+
 // Module Requirements
-var _ = require('lodash'),
-    fs = require('fs'),
-    through = require('through'),
-    proc = require('child_process'),
-    join = require('path').join,
-    PluginError = require('gulp-util').PluginError;
+const _ = require('lodash')
+const fs = require('fs')
+const through = require('through')
+const proc = require('child_process')
+const join = require('path').join
+const PluginError = require('gulp-util').PluginError
 
 /**
  * Returns a stream to use with Gulp which executes the passed files as Mocha
@@ -17,88 +19,111 @@ var _ = require('lodash'),
  */
 module.exports = function (ops, coverage) {
   // Default ops
-  ops = ops || {};
+  ops = ops || {}
   // Setup
-  var ist = ops.istanbul;
-  var output = ops.output;
+  let ist = ops.istanbul
+  let output = ops.output
   // Using istanbul? Use _mocha, otherwise use mocha in order to support full node options (e.g., --debug-brk)
-  var bin = ops.bin || join(require.resolve('mocha'), '..', 'bin', ist ? '_mocha' : 'mocha');
-  var env = _.extend(_.clone(process.env), ops.env || {});
-  var cwd = ops.cwd;
-  var execPath = ops.execPath || process.execPath;
-  ops = _.omit(ops, ['bin', 'env', 'istanbul', 'cwd', 'execPath']);
+  let bin =
+    ops.bin ||
+    join(require.resolve('mocha'), '..', 'bin', ist ? '_mocha' : 'mocha')
+  let env = _.extend(_.clone(process.env), ops.env || {})
+  let cwd = ops.cwd
+  let execPath = ops.execPath || process.execPath
+  ops = _.omit(ops, ['bin', 'env', 'istanbul', 'cwd', 'execPath'])
 
   // Create stream
-  var stream = through(function (file) {
-    this._files.push(file.path);
-  }, function () {
-    // make sure there are files to test
-    if (this._files.length === 0) {
-      this.emit('end');
-      return;
-    };
+  let stream = through(
+    function (file) {
+      this._files.push(file.path)
+    },
+    function () {
+      // make sure there are files to test
+      if (this._files.length === 0) {
+        this.emit('end')
+        return
+      }
 
-    // Save refernce to this (bindless context cheat)
-    var that = this;
+      // Save refernce to this (bindless context cheat)
+      let that = this
 
-    // Parse arguments
-    var args = parseArgs(ops);
-    // Using istanbul?
-    if (ist) {
-      args.unshift('--', bin);
-      // The non-standard location of istanbul's bin makes me a wee bit nervous. Find it by inspecting package.json.
-      bin = ist.bin || join(require.resolve('istanbul'), '..', require('istanbul/package.json').bin.istanbul);
-      // If the value for istanbul is literally true, just keep the arguments array. Otherwise, parse istanbul options.
-      args = ist === true ? args : parseArgs(_.omit(ist, ['bin'])).concat(args);
-      args.unshift('cover');
-    }
-    // Execute Mocha, stdin and stdout are inherited
-    this._child = proc.fork(bin, args.concat(this._files), {cwd: cwd, env: env, execPath: execPath, silent: !!output});
-    // If there's an error running the process. See http://nodejs.org/api/child_process.html#child_process_event_error
-    this._child.on('error', function (e) {
-      that.emit('error', new PluginError('gulp-spawn-mocha', e));
-      that.emit('end');
-    });
-    // When done...
-    this._child.on('close', function (code) {
-      // If code is not zero (falsy)
-      if (code) {
-        that.emit('error', new PluginError('gulp-spawn-mocha', 'Mocha exited with code ' + code));
+      // Parse arguments
+      let args = parseArgs(ops)
+      // Using istanbul?
+      if (ist) {
+        args.unshift('--', bin)
+        // The non-standard location of istanbul's bin makes me a wee bit nervous. Find it by inspecting package.json.
+        bin =
+          ist.bin ||
+          join(
+            require.resolve('istanbul'),
+            '..',
+            require('istanbul/package.json').bin.istanbul
+          )
+        // If the value for istanbul is literally true, just keep the arguments array. Otherwise, parse istanbul options.
+        args =
+          ist === true ? args : parseArgs(_.omit(ist, ['bin'])).concat(args)
+        args.unshift('cover')
+      }
+      // Execute Mocha, stdin and stdout are inherited
+      this._child = proc.fork(bin, args.concat(this._files), {
+        cwd,
+        env,
+        execPath,
+        silent: !!output
+      })
+      // If there's an error running the process. See http://nodejs.org/api/child_process.html#child_process_event_error
+      this._child.on('error', (e) => {
+        that.emit('error', new PluginError('gulp-spawn-mocha', e))
+        that.emit('end')
+      })
+      // When done...
+      this._child.on('close', (code) => {
+        // If code is not zero (falsy)
+        if (code) {
+          that.emit(
+            'error',
+            new PluginError(
+              'gulp-spawn-mocha',
+              `Mocha exited with code ${code}`
+            )
+          )
+        }
+        that.emit('end')
+      })
+      // Output to a file
+      if (output) {
+        let s = _.isString(output) ? fs.createWriteStream(output) : output
+        that._child.stdout.pipe(s)
+        that._child.stderr.pipe(s)
       }
-      that.emit('end');
-    });
-    // Output to a file
-    if (output) {
-      var s = _.isString(output) ? fs.createWriteStream(output) : output;
-      that._child.stdout.pipe(s);
-      that._child.stderr.pipe(s);
     }
-  });
+  )
 
   // Attach files array to stream
-  stream._files = [];
+  stream._files = []
   // Return stream
-  return stream;
-};
+  return stream
+}
 
 /**
  * Parses the arugments from a configuration object for passing to a mocha
  * executable.
  * @param  {Object} obj The object to parse from.
  * @return {Array}      An array of parsed arguments.
  */
-function parseArgs(obj) {
-  var args = [];
-  _.each(obj, function (val, key) {
+function parseArgs (obj) {
+  let args = []
+  _.each(obj, (val, key) => {
     if (_.isArray(val)) {
-      _.each(val, function (val) {
-        addArg(args, key, val);
-      });
+      _.each(val, (val) => {
+        addArg(args, key, val)
+      })
     } else {
-      addArg(args, key, val);
+      addArg(args, key, val)
     }
-  });
-  return args;
+  })
+  return args
 }
 
 /**
@@ -108,19 +133,19 @@ function parseArgs(obj) {
  * @param {String} val  Value of the argument. Returns without doing anything
  *     if falsy and not zero.
  */
-function addArg(args, name, val) {
+function addArg (args, name, val) {
   if (!val && val !== 0) {
-    return;
+    return
   }
-  var arg = name.length > 1 ? '--' + _.kebabCase(name) : '-' + name;
+  let arg = name.length > 1 ? `--${_.kebabCase(name)}` : `-${name}`
   // --max-old-space-size argument requires an `=`
   if (arg === '--max-old-space-size') {
-    args.push(arg + '=' + val);
-    return;
+    args.push(`${arg}=${val}`)
+    return
   } else {
-    args.push(arg);
+    args.push(arg)
   }
   if (_.isString(val) || _.isNumber(val)) {
-    args.push(val);
+    args.push(val)
   }
 }