- Switch const to let except with require/importFrom and all-…

…cap constants

lib/rules/missing-assertion.js

@@ -3,11 +3,11 @@
 module.exports = function(context) {
   return {
     ExpressionStatement(node) {
-      const {expression} = node;
+      let {expression} = node;
       if (expression.type !== 'CallExpression')
         return;
 
-      const {callee} = expression;
+      let {callee} = expression;
       if (callee.type === 'Identifier' && callee.name === 'expect') {
         context.report({
           node,

lib/rules/no-inner-compare.js

@@ -16,20 +16,20 @@ const HINTS = {
 module.exports = function(context) {
   return {
     ExpressionStatement(node) {
-      const {expression} = node;
+      let {expression} = node;
       if (expression.type !== 'MemberExpression' && expression.type !== 'CallExpression')
         return;
 
-      const expect = findExpectCall(expression);
+      let expect = findExpectCall(expression);
       if (!expect)
         return;
 
-      const args = expect.arguments;
-      const [firstArgument] = args;
+      let args = expect.arguments;
+      let [firstArgument] = args;
       if (!firstArgument || firstArgument.type !== 'BinaryExpression')
         return;
 
-      const hint = HINTS[firstArgument.operator];
+      let hint = HINTS[firstArgument.operator];
       if (!hint)
         return;
 

lib/rules/terminating-properties.js

@@ -14,33 +14,33 @@ const PROPERTY_TERMINATORS = [
 ];
 
 module.exports = function(context) {
-  const options = context.options[0] || {};
-  const additionalTerminators = options.properties || [];
-  const validTerminators = [...PROPERTY_TERMINATORS, ...additionalTerminators];
+  let options = context.options[0] || {};
+  let additionalTerminators = options.properties || [];
+  let validTerminators = [...PROPERTY_TERMINATORS, ...additionalTerminators];
 
   return {
     ExpressionStatement(node) {
-      const {expression} = node;
+      let {expression} = node;
       if (expression.type !== 'CallExpression')
         return;
 
-      const {callee} = expression;
+      let {callee} = expression;
       if (callee.type !== 'MemberExpression')
         return;
 
-      const {property} = callee;
+      let {property} = callee;
       if (property.type !== 'Identifier' || !validTerminators.includes(property.name))
         return;
 
-      const expectCall = findExpectCall(callee.object);
+      let expectCall = findExpectCall(callee.object);
       if (!expectCall)
         return;
 
-      const source = context.getSourceCode();
+      let source = context.getSourceCode();
 
-      const calleeText = source.getText(callee);
-      const expectText = source.getText(expectCall);
-      const assertionText = calleeText.substr(expectText.length + 1);
+      let calleeText = source.getText(callee);
+      let expectText = source.getText(expectCall);
+      let assertionText = calleeText.substr(expectText.length + 1);
 
       context.report({
         node: property,

tests/index.js

@@ -7,7 +7,7 @@ const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
 
-const rules = fs.readdirSync(path.resolve(__dirname, '../lib/rules/'))
+let rules = fs.readdirSync(path.resolve(__dirname, '../lib/rules/'))
   .map((f) => {
     return path.basename(f, '.js');
   });

tests/lib/rules/missing-assertions.js

@@ -3,7 +3,7 @@
 const rule = require('../../../lib/rules/missing-assertion');
 const {RuleTester} = require('eslint');
 
-const ruleTester = new RuleTester();
+let ruleTester = new RuleTester();
 ruleTester.run('missing-assertion', rule, {
   valid: [{
     code: [

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

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

tests/lib/rules/terminating-properties.js

@@ -3,7 +3,7 @@
 const rule = require('../../../lib/rules/terminating-properties');
 const {RuleTester} = require('eslint');
 
-const ruleTester = new RuleTester();
+let ruleTester = new RuleTester();
 ruleTester.run('terminating-properties', rule, {
   valid: [{
     code: [

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

@@ -7,16 +7,16 @@ const findExpectCall = require('../../../lib/util/find-expect-call');
 
 describe('find-expect-call util', function () {
   it('Finds expect statements which are considered member expressions', function () {
-    const code = 'expect(true).to.be.ok;';
-    const ast = espree.parse(code);
-    const result = findExpectCall(ast.body[0].expression);
+    let code = 'expect(true).to.be.ok;';
+    let ast = espree.parse(code);
+    let result = findExpectCall(ast.body[0].expression);
     expect(result).to.be.an('object');
   });
 
   it('Finds expect statements which are considered recursive call expressions', function () {
-    const code = 'expect(true).to.equal(true);';
-    const ast = espree.parse(code);
-    const result = findExpectCall(ast.body[0].expression);
+    let code = 'expect(true).to.equal(true);';
+    let ast = espree.parse(code);
+    let result = findExpectCall(ast.body[0].expression);
     expect(result).to.be.an('object');
   });
 });