- Refactoring: Use ES6 features (const, destructuring, arrow functi…

…ons, template literals, shorthand properties and methods, spread, includes)

- Refactoring: Consistent quotes (single)

.eslintrc.json

@@ -1,6 +1,7 @@
 {
   "extends": "eslint:recommended",
   "env": {
+    "es6": true,
     "mocha": true,
     "node": true
   },

lib/rules/missing-assertion.js

@@ -1,16 +1,16 @@
-"use strict";
+'use strict';
 
 module.exports = function(context) {
   return {
-    ExpressionStatement: function(node) {
-      var expression = node.expression;
+    ExpressionStatement(node) {
+      const {expression} = node;
       if (expression.type !== 'CallExpression')
         return;
 
-      var callee = expression.callee;
+      const {callee} = expression;
       if (callee.type === 'Identifier' && callee.name === 'expect') {
         context.report({
-          node: node,
+          node,
           message: 'expect(...) used without assertion'
         })
       }

lib/rules/no-inner-compare.js

@@ -1,8 +1,8 @@
-"use strict";
+'use strict';
 
-var findExpectCall = require('../util/find-expect-call');
+const findExpectCall = require('../util/find-expect-call');
 
-var HINTS = {
+const HINTS = {
   '==': 'to.equal()',
   '!=': 'to.not.equal()',
   '===': 'to.equal()',
@@ -15,27 +15,27 @@ var HINTS = {
 
 module.exports = function(context) {
   return {
-    ExpressionStatement: function(node) {
-      var expression = node.expression;
+    ExpressionStatement(node) {
+      const {expression} = node;
       if (expression.type !== 'MemberExpression')
         return;
 
-      var expect = findExpectCall(expression);
+      const expect = findExpectCall(expression);
       if (!expect)
         return;
 
-      var args = expect.arguments;
-      var firstArgument = args[0];
+      const args = expect.arguments;
+      const [firstArgument] = args;
       if (!firstArgument || firstArgument.type !== 'BinaryExpression')
         return;
 
-      var hint = HINTS[firstArgument.operator];
+      const hint = HINTS[firstArgument.operator];
       if (!hint)
         return;
 
       context.report({
         node: firstArgument,
-        message: 'operator "' + firstArgument.operator + '" used in expect(), use "' + hint + '" instead'
+        message: `operator "${firstArgument.operator}" used in expect(), use "${hint}" instead`
       })
     }
   };

lib/rules/terminating-properties.js

@@ -1,8 +1,8 @@
-"use strict";
+'use strict';
 
-var findExpectCall = require('../util/find-expect-call');
+const findExpectCall = require('../util/find-expect-call');
 
-var PROPERTY_TERMINATORS = [
+const PROPERTY_TERMINATORS = [
   'ok',
   'true',
   'false',
@@ -14,37 +14,37 @@ var PROPERTY_TERMINATORS = [
 ];
 
 module.exports = function(context) {
-  var options = context.options[0] || {};
-  var additionalTerminators = options.properties || [];
-  var validTerminators = PROPERTY_TERMINATORS.concat(additionalTerminators);
+  const options = context.options[0] || {};
+  const additionalTerminators = options.properties || [];
+  const validTerminators = [...PROPERTY_TERMINATORS, ...additionalTerminators];
 
   return {
-    ExpressionStatement: function(node) {
-      var expression = node.expression;
+    ExpressionStatement(node) {
+      const {expression} = node;
       if (expression.type !== 'CallExpression')
         return;
 
-      var callee = expression.callee;
+      const {callee} = expression;
       if (callee.type !== 'MemberExpression')
         return;
 
-      var property = callee.property;
-      if (property.type !== 'Identifier' || validTerminators.indexOf(property.name) === -1)
+      const {property} = callee;
+      if (property.type !== 'Identifier' || !validTerminators.includes(property.name))
         return;
 
-      var expectCall = findExpectCall(callee.object);
+      const expectCall = findExpectCall(callee.object);
       if (!expectCall)
         return;
 
-      var source = context.getSourceCode();
+      const source = context.getSourceCode();
 
-      var calleeText = source.getText(callee);
-      var expectText = source.getText(expectCall);
-      var assertionText = calleeText.substr(expectText.length + 1);
+      const calleeText = source.getText(callee);
+      const expectText = source.getText(expectCall);
+      const assertionText = calleeText.substr(expectText.length + 1);
 
       context.report({
         node: property,
-        message: '"' + assertionText + '" used as function'
+        message: `"${assertionText}" used as function`
       })
     }
   };

tests/index.js

@@ -1,14 +1,14 @@
 /* eslint-env mocha */
 'use strict';
 
-var plugin = require('..');
+const plugin = require('..');
 
-var assert = require('assert');
-var fs = require('fs');
-var path = require('path');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
 
-var rules = fs.readdirSync(path.resolve(__dirname, '../lib/rules/'))
-  .map(function(f) {
+const rules = fs.readdirSync(path.resolve(__dirname, '../lib/rules/'))
+  .map((f) => {
     return path.basename(f, '.js');
   });
 

tests/lib/rules/missing-assertions.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var rule = require('../../../lib/rules/missing-assertion');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/missing-assertion');
+const {RuleTester} = require('eslint');
 
-var ruleTester = new RuleTester();
+const ruleTester = new RuleTester();
 ruleTester.run('missing-assertion', rule, {
   valid: [{
     code: [

tests/lib/rules/no-inner-compare.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var rule = require('../../../lib/rules/no-inner-compare');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/no-inner-compare');
+const {RuleTester} = require('eslint');
 
-var ruleTester = new RuleTester();
+const ruleTester = new RuleTester();
 ruleTester.run('no-inner-compare', rule, {
   valid: [{
     code: 'expect(true).to.be.ok;'

tests/lib/rules/terminating-properties.js

@@ -1,9 +1,9 @@
 'use strict';
 
-var rule = require('../../../lib/rules/terminating-properties');
-var RuleTester = require('eslint').RuleTester;
+const rule = require('../../../lib/rules/terminating-properties');
+const {RuleTester} = require('eslint');
 
-var ruleTester = new RuleTester();
+const ruleTester = new RuleTester();
 ruleTester.run('terminating-properties', rule, {
   valid: [{
     code: [

tests/lib/util/find-expect-call.js

@@ -1,22 +1,22 @@
 'use strict';
 
-var importFrom = require('import-from');
-var expect = require('chai').expect;
-var espree = importFrom(require.resolve('eslint'), 'espree');
-var findExpectCall = require('../../../lib/util/find-expect-call');
+const importFrom = require('import-from');
+const {expect} = require('chai');
+const espree = importFrom(require.resolve('eslint'), 'espree');
+const findExpectCall = require('../../../lib/util/find-expect-call');
 
 describe('find-expect-call util', function () {
   it('Finds expect statements which are considered member expressions', function () {
-    var code = 'expect(true).to.be.ok;';
-    var ast = espree.parse(code);
-    var result = findExpectCall(ast.body[0].expression);
+    const code = 'expect(true).to.be.ok;';
+    const ast = espree.parse(code);
+    const result = findExpectCall(ast.body[0].expression);
     expect(result).to.be.an('object');
   });
 
   it('Finds expect statements which are considered recursive call expressions', function () {
-    var code = 'expect(true).to.equal(true);';
-    var ast = espree.parse(code);
-    var result = findExpectCall(ast.body[0].expression);
+    const code = 'expect(true).to.equal(true);';
+    const ast = espree.parse(code);
+    const result = findExpectCall(ast.body[0].expression);
     expect(result).to.be.an('object');
   });
 });