eslint-find-rules - npm Package Compare versions

Comparing version 1.14.3 to 2.0.0

package.json

 {
   "name": "eslint-find-rules",
-  "version": "1.14.3",
+  "version": "2.0.0",
   "description": "Find built-in ESLint rules you don't have in your custom config.",
-  "main": "src/lib/rule-finder.js",
+  "main": "dist/lib/rule-finder.js",
   "scripts": {
     "cover": "nyc --reporter=lcov --reporter=text npm test",
+    "lint": "xo",
     "test": "mocha --recursive",
-    "lint": "eslint --ignore-pattern test/fixtures .",
     "update-contributors": "all-contributors generate",
@@ -14,9 +14,11 @@ "commit": "git-cz",
     "check-coverage": "nyc check-coverage --statements 100 --branches 100 --functions 100 --lines 100",
+    "prebuild": "rimraf dist",
+    "build": "babel src -d dist --presets es2015",
     "report-coverage": "cat ./coverage/lcov.info | node_modules/.bin/codecov",
     "semantic-release": "semantic-release pre && npm publish && semantic-release post",
-    "travis-after-all": "travis-after-all && npm run report-coverage && npm run semantic-release"
+    "travis-after-all": "travis-after-all && npm run report-coverage"
   },
   "bin": {
-    "eslint-find-rules": "src/bin/find.js",
-    "eslint-diff-rules": "src/bin/diff.js"
+    "eslint-find-rules": "dist/bin/find.js",
+    "eslint-diff-rules": "dist/bin/diff.js"
   },
@@ -41,7 +43,9 @@ "keywords": [],
     "all-contributors-cli": "3.0.6",
+    "babel-cli": "6.18.0",
+    "babel-core": "6.18.0",
+    "babel-preset-es2015": "6.18.0",
     "codecov": "1.0.1",
     "commitizen": "2.8.6",
     "cz-conventional-changelog": "1.2.0",
-    "eslint": "3.5.0",
-    "eslint-config-kentcdodds": "6.2.0",
+    "eslint": "3.12.0",
     "ghooks": "1.3.2",
@@ -53,24 +57,12 @@ "mocha": "^3.0.1",
     "proxyquire": "1.7.10",
+    "rimraf": "^2.6.0",
     "semantic-release": "4.3.5",
     "sinon": "^1.17.3",
     "travis-after-all": "^1.4.4",
-    "validate-commit-msg": "2.8.0"
+    "validate-commit-msg": "2.8.0",
+    "xo": "^0.17.0"
   },
   "peerDependencies": {
-    "eslint": "^2.0.0 || ^3.0.0"
+    "eslint": "^3.12.0"
   },
-  "eslintConfig": {
-    "extends": "kentcdodds",
-    "parserOptions": {
-      "ecmaVersion": 5
-    },
-    "env": {
-      "mocha": true
-    },
-    "rules": {
-      "no-var": 0,
-      "func-names": 0,
-      "object-shorthand": 0
-    }
-  },
   "nyc": {
@@ -97,3 +89,10 @@ "exclude": [
   },
-  "homepage": "https://github.com/sarbbottam/eslint-find-rules#readme"
-}
+  "homepage": "https://github.com/sarbbottam/eslint-find-rules#readme",
+  "xo": {
+    "envs": [
+      "mocha"
+    ],
+    "esnext": true,
+    "space": true
+  }
+}

README.md

@@ -16,3 +16,3 @@ # eslint-find-rules
 
-## Acknowledgement
+## Acknowledgment
 
@@ -19,0 +19,0 @@ This module is an extended version of [eslint-find-new-rules](https://github.com/kentcdodds/eslint-find-new-rules)

src/bin/diff.js

 #!/usr/bin/env node
 
-'use strict'
+'use strict';
 
-var path = require('path')
-var argv = require('yargs')
+const path = require('path');
+const argv = require('yargs')
   .boolean('verbose')
   .alias('v', 'verbose')
-  .argv
+  .argv;
 
-var cli = require('../lib/cli-util')
+const cli = require('../lib/cli-util');
 
-var getRuleFinder = require('../lib/rule-finder')
-var arrayDifference = require('../lib/array-diff')
-var objectDifference = require('../lib/object-diff')
-var getSortedRules = require('../lib/sort-rules')
-var flattenRulesDiff = require('../lib/flatten-rules-diff')
-var stringifyRuleConfig = require('../lib/stringify-rule-config')
+const getRuleFinder = require('../lib/rule-finder');
+const arrayDifference = require('../lib/array-diff');
+const objectDifference = require('../lib/object-diff');
+const getSortedRules = require('../lib/sort-rules');
+const flattenRulesDiff = require('../lib/flatten-rules-diff');
+const stringifyRuleConfig = require('../lib/stringify-rule-config');
 
-var files = [argv._[0], argv._[1]]
-var collectedRules = getFilesToCompare(files).map(compareConfigs)
+const files = [argv._[0], argv._[1]];
+const collectedRules = getFilesToCompare(files).map(compareConfigs);
 
-var rulesCount = collectedRules.reduce(
-  function getLength(prev, curr) {
-    return prev + (curr && curr.rules ? curr.rules.length : /* istanbul ignore next */ 0)
-  }, 0)
+const rulesCount = collectedRules.reduce(
+  (prev, curr) => {
+    return prev + (curr && curr.rules ? curr.rules.length : /* istanbul ignore next */ 0);
+  }, 0);
 
 /* istanbul ignore else */
 if (argv.verbose || rulesCount) {
-  cli.push('\ndiff rules\n' + rulesCount + ' rules differ\n')
+  cli.push('\ndiff rules\n' + rulesCount + ' rules differ\n');
 }
@@ -35,25 +35,25 @@
 if (rulesCount) {
-  collectedRules.forEach(function displayConfigs(diff) {
-    var rules = diff.rules
+  collectedRules.forEach(diff => {
+    let rules = diff.rules;
 
     /* istanbul ignore if */
-    if (!rules.length) {
-      return
+    if (rules.length < 1) {
+      return;
     }
 
     if (argv.verbose) {
-      rules = flattenRulesDiff(rules).map(stringifyRuleConfig)
-      rules.unshift([], diff.config1, diff.config2)
+      rules = flattenRulesDiff(rules).map(stringifyRuleConfig);
+      rules.unshift([], diff.config1, diff.config2);
     } else {
-      cli.push('\nin ' + diff.config1 + ' but not in ' + diff.config2 + ':\n')
+      cli.push('\nin ' + diff.config1 + ' but not in ' + diff.config2 + ':\n');
     }
 
-    cli.push(rules, argv.verbose ? 3 : 0)
-  })
+    cli.push(rules, argv.verbose ? 3 : 0);
+  });
 }
 
-cli.write()
+cli.write();
 
 function getFilesToCompare(allFiles) {
-  var filesToCompare = [allFiles]
+  const filesToCompare = [allFiles];
 
@@ -64,6 +64,6 @@ if (!argv.verbose) {
     // accross those files, but grouped
-    filesToCompare.push([].concat(allFiles).reverse())
+    filesToCompare.push([].concat(allFiles).reverse());
   }
 
-  return filesToCompare
+  return filesToCompare;
 }
@@ -78,4 +78,4 @@
       getRuleFinder(currentFiles[1])
-    ),
-  }
+    )
+  };
 }
@@ -90,3 +90,3 @@
       )
-    )
+    );
   }
@@ -99,3 +99,3 @@
     )
-  )
+  );
 }

src/bin/find.js

 #!/usr/bin/env node
 
-'use strict'
-
-var options = {
+'use strict';
+const options = {
   getCurrentRules: ['current', 'c'],
@@ -14,6 +13,6 @@ getPluginRules: ['plugin', 'p'],
   core: ['core'],
-  verbose: ['verbose', 'v'],
-}
+  verbose: ['verbose', 'v']
+};
 
-var argv = require('yargs')
+const argv = require('yargs')
   .boolean(Object.keys(options))
@@ -23,50 +22,47 @@ .alias(options)
   .default('core', true)
-  .argv
+  .argv;
 
-var getRuleURI = require('eslint-rule-documentation')
+const getRuleURI = require('eslint-rule-documentation');
+const getRuleFinder = require('../lib/rule-finder');
+const cli = require('../lib/cli-util');
 
-var cli = require('../lib/cli-util')
+const specifiedFile = argv._[0];
+const ruleFinder = getRuleFinder(specifiedFile, argv.core === false);
+const errorOut = argv.error && !argv.n;
+let processExitCode = argv.u && errorOut ? 1 : 0;
 
-var getRuleFinder = require('../lib/rule-finder')
-var specifiedFile = argv._[0]
-
-var ruleFinder = getRuleFinder(specifiedFile, argv.core === false)
-
-var errorOut = argv.error && !argv.n
-var processExitCode = argv.u && errorOut ? 1 : 0
-
 if (!argv.c && !argv.p && !argv.a && !argv.u) {
-  console.log('no option provided, please provide a valid option') // eslint-disable-line no-console
-  console.log('usage:') // eslint-disable-line no-console
-  console.log('eslint-find-rules [option] <file> [flag]') // eslint-disable-line no-console
-  process.exit(0)
+  console.log('no option provided, please provide a valid option'); // eslint-disable-line no-console
+  console.log('usage:'); // eslint-disable-line no-console
+  console.log('eslint-find-rules [option] <file> [flag]'); // eslint-disable-line no-console
+  process.exit(0);
 }
 
-Object.keys(options).forEach(function findRules(option) {
-  var rules
-  var ruleFinderMethod = ruleFinder[option]
+Object.keys(options).forEach(option => {
+  let rules;
+  const ruleFinderMethod = ruleFinder[option];
   if (argv[option] && ruleFinderMethod) {
-    rules = ruleFinderMethod()
-    argv.verbose && cli.push('\n' + options[option][0] + ' rules\n' + rules.length + ' rules found\n')
-    if (rules.length) {
+    rules = ruleFinderMethod();
+    if (argv.verbose) {
+      cli.push('\n' + options[option][0] + ' rules\n' + rules.length + ' rules found\n');
+    }
+    if (rules.length > 0) {
       if (argv.verbose) {
-        rules = rules.map(function(rule) {
-          return [rule, getRuleURI(rule).url]
-        }).reduce(function(all, single) {
-          return all.concat(single)
-        })
-        cli.push(rules, 2, false)
+        rules = rules
+          .map(rule => [rule, getRuleURI(rule).url])
+          .reduce((all, single) => all.concat(single));
+        cli.push(rules, 2, false);
       } else {
-        cli.push('\n' + options[option][0] + ' rules\n')
-        cli.push(rules)
+        cli.push('\n' + options[option][0] + ' rules\n');
+        cli.push(rules);
       }
-      cli.write()
+      cli.write();
     } else /* istanbul ignore else */ if (option === 'getUnusedRules') {
-      processExitCode = 0
+      processExitCode = 0;
     }
   }
-})
+});
 
 if (processExitCode) {
-  process.exit(processExitCode)
+  process.exit(processExitCode);
 }

src/lib/array-diff.js

 function difference(a, b) {
-  var hash = {}
-  var diff = {}
-
-  b.forEach(function createHash(item) {
-    hash[item] = true
-  })
-
-  a.forEach(function findDiff(item) {
-    if (!hash[item] && !diff[item]) {
-      diff[item] = true
-    }
-  })
-
-  return Object.keys(diff)
-
+  return a.filter(item => !b.includes(item)).sort((a, b) => a > b);
 }
 
-module.exports = difference
+module.exports = difference;

src/lib/cli-util.js

@@ -1,33 +0,31 @@
-var size = require('window-size')
-var availableWidth = size.width || /*istanbul ignore next */ 80
-var ui = require('cliui')({width: availableWidth})
+const size = require('window-size');
 
+const availableWidth = size.width || /* istanbul ignore next */ 80;
+const ui = require('cliui')({width: availableWidth});
+
 function push(output, columns, uniformColWidths) {
-  var _output = [].concat(output)
+  const _output = [].concat(output);
 
-  var padding = {top: 0, right: 2, bottom: 0, left: 0}
-  var maxWidth = [_output.reduce(
-    function getMaxWidth(previous, current) {
-      return Math.max(padding.left + current.length + padding.right, previous)
-    }, 0)]
+  const padding = {top: 0, right: 2, bottom: 0, left: 0};
+  const maxWidth = [_output.reduce((previous, current) => Math.max(padding.left + current.length + padding.right, previous), 0)];
 
-  var _columns = columns || Math.floor(availableWidth / maxWidth)
-  var cellMapper, widths
+  const _columns = columns || Math.floor(availableWidth / maxWidth);
+  let widths;
 
   if (uniformColWidths === false && _columns > 1) {
-    widths = []
-    _output.forEach(function(content, index) {
+    widths = [];
+    _output.forEach((content, index) => {
       widths[index % _columns] = Math.max(
         padding.left + content.length + padding.right,
         widths[index % _columns] || 0
-      )
-    })
+      );
+    });
   } else {
-    widths = [Math.floor(availableWidth / _columns)]
+    widths = [Math.floor(availableWidth / _columns)];
   }
 
-  cellMapper = getOutputCellMapper(widths, padding)
+  const cellMapper = getOutputCellMapper(widths, padding);
 
   while (_output.length) {
-    ui.div.apply(ui, _output.splice(0, _columns).map(cellMapper))
+    ui.div(..._output.splice(0, _columns).map(cellMapper));
   }
@@ -37,24 +35,24 @@ }
 function write(logger) {
-  var _logger = logger || console
-  var _log = _logger.log || /* istanbul ignore next */ console.log // eslint-disable-line no-console
-  _log(ui.toString())
+  const _logger = logger || console;
+  const _log = _logger.log || /* istanbul ignore next */ console.log; // eslint-disable-line no-console
+  _log(ui.toString());
 }
 
 function getOutputCellMapper(widths, padding) {
-  return function curriedOutputCellMapper(text, index) {
-    var _width = widths[index]
+  return (text, index) => {
+    let _width = widths[index];
     if (_width === undefined) {
-      _width = widths[0]
+      _width = widths[0];
     }
     return {
-      text: text,
+      text,
       width: _width,
-      padding: [padding.top, padding.right, padding.bottom, padding.left],
-    }
-  }
+      padding: [padding.top, padding.right, padding.bottom, padding.left]
+    };
+  };
 }
 
 module.exports = {
-  push: push,
-  write: write,
-}
+  push,
+  write
+};

src/lib/flatten-rules-diff.js

 function flattenRulesDiff(diff) {
   if (Array.isArray(diff)) {
-    return flattenRulesDiffArray(diff)
+    return flattenRulesDiffArray(diff);
   } else if (typeof diff === 'object') {
-    return flattenRulesDiffObject(diff)
+    return flattenRulesDiffObject(diff);
   }
 
-  return []
+  return [];
 }
 
 function flattenRulesDiffObject(diffObject) {
-  var flattened = []
+  const flattened = [];
 
-  Object.keys(diffObject).forEach(function flattenEachRuleDiff(ruleName) {
-    var ruleRow = [ruleName]
-    var diff = diffObject[ruleName]
+  Object.keys(diffObject).forEach(ruleName => {
+    const diff = diffObject[ruleName];
+    const ruleRow = [ruleName].concat(
+      Object.keys(diff).map(configName => diff[configName])
+    );
 
-    Object.keys(diff).forEach(function flattenEachChildProp(configName) {
-      ruleRow.push(diff[configName])
-    })
+    flattened.push(...ruleRow);
+  });
 
-    flattened.push.apply(flattened, ruleRow)
-  })
-
-  return flattened
+  return flattened;
 }
 
 function flattenRulesDiffArray(diffArray) {
-  var flattened = []
+  const flattened = [];
 
-  diffArray.forEach(function flattenEachDiff(diff) {
-    flattened.push.apply(flattened, flattenRulesDiff(diff))
-  })
+  diffArray.forEach(diff => {
+    flattened.push(...flattenRulesDiff(diff));
+  });
 
-  return flattened
+  return flattened;
 }
 
-module.exports = flattenRulesDiff
+module.exports = flattenRulesDiff;

src/lib/object-diff.js

@@ -1,27 +0,27 @@
-var assert = require('assert')
+const assert = require('assert');
 
 function difference(a, b) {
-  var diff = {}
+  const diff = {};
 
-  Object.keys(a).forEach(compare(diff, a, b))
-  Object.keys(b).forEach(compare(diff, a, b))
+  Object.keys(a).forEach(compare(diff, a, b));
+  Object.keys(b).forEach(compare(diff, a, b));
 
-  return diff
+  return diff;
 }
 
 function compare(diff, a, b) {
-  return function curried(n) {
+  return n => {
     if (!diff[n]) {
       try {
-        assert.deepEqual(a[n], b[n])
-      } catch (e) {
+        assert.deepEqual(a[n], b[n]);
+      } catch (err) {
         diff[n] = {
           config1: a[n],
-          config2: b[n],
-        }
+          config2: b[n]
+        };
       }
     }
-  }
+  };
 }
 
-module.exports = difference
+module.exports = difference;

src/lib/rule-finder.js

@@ -1,8 +0,7 @@
-var path = require('path')
-var fs = require('fs')
+const path = require('path');
 
-var eslint = require('eslint')
-var isAbsolute = require('path-is-absolute')
-var difference = require('./array-diff')
-var getSortedRules = require('./sort-rules')
+const eslint = require('eslint');
+const isAbsolute = require('path-is-absolute');
+const difference = require('./array-diff');
+const getSortedRules = require('./sort-rules');
 
@@ -12,120 +11,99 @@ function _getConfigFile(specifiedFile) {
     if (isAbsolute(specifiedFile)) {
-      return specifiedFile
-    } else {
-      return path.join(process.cwd(), specifiedFile)
+      return specifiedFile;
     }
-  } else {
-    // this is not being called with an arg. Use the package.json `main`
-    return require(path.join(process.cwd(), 'package.json')).main
+    return path.join(process.cwd(), specifiedFile); // eslint-disable-line import/no-dynamic-require
   }
+  // this is not being called with an arg. Use the package.json `main`
+  return require(path.join(process.cwd(), 'package.json')).main; // eslint-disable-line import/no-dynamic-require
 }
 
 function _getConfig(configFile) {
-  var cliEngine = new eslint.CLIEngine({
+  const cliEngine = new eslint.CLIEngine({
     // ignore any config applicable depending on the location on the filesystem
     useEslintrc: false,
     // point to the particular config
-    configFile: configFile, // eslint-disable-line object-shorthand
-  })
-  return cliEngine.getConfigForFile()
+    configFile
+  });
+  return cliEngine.getConfigForFile();
 }
 
 function _getCurrentRules(config) {
-  return Object.keys(config.rules)
+  return Object.keys(config.rules);
 }
 
 function _normalizePluginName(name) {
-  var scopedRegex = /(@[^/]+)\/(.+)/
-  var match = scopedRegex.exec(name)
+  const scopedRegex = /(@[^/]+)\/(.+)/;
+  const match = scopedRegex.exec(name);
 
   if (match) {
     return {
-      module: match[1] + '/' + 'eslint-plugin-' + match[2],
-      prefix: match[2],
-    }
+      module: `${match[1]}/eslint-plugin-${match[2]}`,
+      prefix: match[2]
+    };
   }
 
   return {
-    module: 'eslint-plugin-' + name,
-    prefix: name,
-  }
+    module: `eslint-plugin-${name}`,
+    prefix: name
+  };
 }
 
 function _getPluginRules(config) {
-  var pluginRules = []
-  var plugins = config.plugins
+  let pluginRules = [];
+  const plugins = config.plugins;
   if (plugins) {
-    plugins.forEach(function getPluginRule(plugin) {
-      var normalized = _normalizePluginName(plugin)
-      var pluginConfig = require(normalized.module)
+    plugins.forEach(plugin => {
+      const normalized = _normalizePluginName(plugin);
+      const pluginConfig = require(normalized.module);  // eslint-disable-line import/no-dynamic-require
 
-      var rules = pluginConfig.rules === undefined ? {} : pluginConfig.rules
+      const rules = pluginConfig.rules === undefined ? {} : pluginConfig.rules;
       pluginRules = pluginRules.concat(
-        Object.keys(rules).map(function normalizePluginRule(rule) {
-          return normalized.prefix + '/' + rule
+        Object.keys(rules).map(rule => {
+          return normalized.prefix + '/' + rule;
         })
-      )
-    })
+      );
+    });
   }
-  return pluginRules
+  return pluginRules;
 }
 
 function _getAllAvailableRules(pluginRules) {
-  var allRules = fs
-    .readdirSync('./node_modules/eslint/lib/rules')
-  var filteredAllRules = []
-  allRules.forEach(function filterAllRules(filename) {
-    if (filename.slice(-3) === '.js') {
-      filteredAllRules.push(filename.replace(/\.js$/, ''))
-    }
-  })
-
-  filteredAllRules = filteredAllRules.concat(pluginRules)
-
-  return filteredAllRules
+  return [
+    ...eslint.linter.getRules().keys(),
+    ...pluginRules
+  ];
 }
 
 function _isNotCore(rule) {
-  return rule.indexOf('/') !== '-1'
+  return rule.indexOf('/') !== '-1';
 }
 
 function RuleFinder(specifiedFile, noCore) {
-  var configFile = _getConfigFile(specifiedFile)
-  var config = _getConfig(configFile)
-  var currentRules = _getCurrentRules(config)
-  var pluginRules = _getPluginRules(config)
-  var allRules = noCore ? pluginRules : _getAllAvailableRules(pluginRules)
+  const configFile = _getConfigFile(specifiedFile);
+  const config = _getConfig(configFile);
+  let currentRules = _getCurrentRules(config);
+  const pluginRules = _getPluginRules(config);
+  const allRules = noCore ? pluginRules : _getAllAvailableRules(pluginRules);
   if (noCore) {
-    currentRules = currentRules.filter(_isNotCore)
+    currentRules = currentRules.filter(_isNotCore);
   }
-  var unusedRules = difference(allRules, currentRules) // eslint-disable-line vars-on-top
+  const unusedRules = difference(allRules, currentRules); // eslint-disable-line vars-on-top
 
   // get all the current rules instead of referring the extended files or documentation
-  this.getCurrentRules = function getCurrentRules() {
-    return getSortedRules(currentRules)
-  }
+  this.getCurrentRules = () => getSortedRules(currentRules);
 
   // get all the current rules' particular configuration
-  this.getCurrentRulesDetailed = function getCurrentRulesDetailed() {
-    return config.rules
-  }
+  this.getCurrentRulesDetailed = () => config.rules;
 
   // get all the plugin rules instead of referring the extended files or documentation
-  this.getPluginRules = function getPluginRules() {
-    return getSortedRules(pluginRules)
-  }
+  this.getPluginRules = () => getSortedRules(pluginRules);
 
   // get all the available rules instead of referring eslint and plugin packages or documentation
-  this.getAllAvailableRules = function getAllAvailableRules() {
-    return getSortedRules(allRules)
-  }
+  this.getAllAvailableRules = () => getSortedRules(allRules);
 
-  this.getUnusedRules = function getUnusedRules() {
-    return getSortedRules(unusedRules)
-  }
-
+  this.getUnusedRules = () => getSortedRules(unusedRules);
 }
 
-module.exports = function getRuleFinder(specifiedFile, noCore) {
-  return new RuleFinder(specifiedFile, noCore)
-}
+module.exports = function (specifiedFile, noCore) {
+  return new RuleFinder(specifiedFile, noCore);
+};

src/lib/sort-rules.js

@@ -1,29 +0,29 @@
-'use strict'
+'use strict';
 
 function getSortedRules(rules) {
-  return Array.isArray(rules) ? getSortedRulesArray(rules) : transformIntoSortedRulesArray(rules)
+  return Array.isArray(rules) ? getSortedRulesArray(rules) : transformIntoSortedRulesArray(rules);
 }
 
 function getSortedRulesArray(rules) {
-  return rules.sort(sortAlphabetically)
+  return rules.sort(sortAlphabetically);
 }
 
 function transformIntoSortedRulesArray(rules) {
-  var sortedRules = []
+  const sortedRules = [];
 
   Object.keys(rules)
     .sort(sortAlphabetically)
-    .forEach(function mapRules(ruleName) {
-      var rule = {}
-      rule[ruleName] = rules[ruleName]
-      sortedRules.push(rule)
-    })
+    .forEach(ruleName => {
+      const rule = {};
+      rule[ruleName] = rules[ruleName];
+      sortedRules.push(rule);
+    });
 
-  return sortedRules
+  return sortedRules;
 }
 
 function sortAlphabetically(a, b) {
-  return a > b ? 1 : -1
+  return a > b ? 1 : -1;
 }
 
-module.exports = getSortedRules
+module.exports = getSortedRules;

src/lib/stringify-rule-config.js

 function stringifyRuleConfig(rule) {
   if (typeof rule === 'string') {
-    return rule
+    return rule;
   } else if (typeof rule === 'undefined') {
-    return '-'
+    return '-';
   }
 
-  return JSON.stringify(rule)
+  return JSON.stringify(rule);
 }
 
-module.exports = stringifyRuleConfig
+module.exports = stringifyRuleConfig;

test/bin/diff.js

@@ -1,40 +0,39 @@
-var assert = require('assert')
-var proxyquire = require('proxyquire')
-var sinon = require('sinon')
+const assert = require('assert');
+const proxyquire = require('proxyquire');
+const sinon = require('sinon');
 
-var consoleLog = console.log // eslint-disable-line no-console
+const consoleLog = console.log; // eslint-disable-line no-console
 
-var stub = {
-  '../lib/rule-finder': function() {
+const stub = {
+  '../lib/rule-finder'() {
     return {
-      getCurrentRules: function noop() {},
-      getCurrentRulesDetailed: function noop() {},
-    }
+      getCurrentRules() {}, // noop
+      getCurrentRulesDetailed() {} // noop
+    };
   },
   '../lib/array-diff': sinon.stub().returns(['diff']),
-  '../lib/object-diff': sinon.stub().returns([{'test-rule': {config1: 'foo-config', config2: 'bar-config'}}]),
-}
+  '../lib/object-diff': sinon.stub().returns([{'test-rule': {config1: 'foo-config', config2: 'bar-config'}}])
+};
 
-describe('diff', function() {
-
-  beforeEach(function() {
-    process.argv = process.argv.slice(0, 2)
-    sinon.stub(console, 'log', function() {
+describe('diff', () => {
+  beforeEach(() => {
+    process.argv = process.argv.slice(0, 2);
+    sinon.stub(console, 'log', (...args) => {
       // print out everything but the test target's output
-      if (!arguments[0].match(/diff/)) {
-        consoleLog.apply(null, arguments)
+      if (!args[0].match(/diff/)) {
+        consoleLog(...args);
       }
-    })
-  })
+    });
+  });
 
-  afterEach(function() {
-    console.log.restore() // eslint-disable-line no-console
+  afterEach(() => {
+    console.log.restore(); // eslint-disable-line no-console
     // purge yargs cache
-    delete require.cache[require.resolve('yargs')]
-  })
+    delete require.cache[require.resolve('yargs')];
+  });
 
-  it('logs diff', function() {
-    process.argv[2] = './foo'
-    process.argv[3] = './bar'
-    proxyquire('../../src/bin/diff', stub)
+  it('logs diff', () => {
+    process.argv[2] = './foo';
+    process.argv[3] = './bar';
+    proxyquire('../../src/bin/diff', stub);
     assert.ok(
@@ -46,10 +45,10 @@ console.log.calledWith( // eslint-disable-line no-console
       )
-    )
-  })
+    );
+  });
 
-  it('logs diff verbosely', function() {
-    process.argv[2] = '--verbose'
-    process.argv[3] = './foo'
-    process.argv[4] = './bar'
-    proxyquire('../../src/bin/diff', stub)
+  it('logs diff verbosely', () => {
+    process.argv[2] = '--verbose';
+    process.argv[3] = './foo';
+    process.argv[4] = './bar';
+    proxyquire('../../src/bin/diff', stub);
     assert.ok(
@@ -61,4 +60,4 @@ console.log.calledWith( // eslint-disable-line no-console
       )
-    )
-  })
-})
+    );
+  });
+});

test/bin/find.js

@@ -1,151 +0,151 @@
-var assert = require('assert')
-var proxyquire = require('proxyquire')
-var sinon = require('sinon')
+const assert = require('assert');
+const proxyquire = require('proxyquire');
+const sinon = require('sinon');
 
-var consoleLog = console.log // eslint-disable-line no-console
-var processExit = process.exit
+const consoleLog = console.log; // eslint-disable-line no-console
+const processExit = process.exit;
 
-var getCurrentRules = sinon.stub().returns(['current', 'rules'])
-var getPluginRules = sinon.stub().returns(['plugin', 'rules'])
-var getAllAvailableRules = sinon.stub().returns(['all', 'available'])
-var getUnusedRules = sinon.stub().returns(['unused', 'rules'])
+const getCurrentRules = sinon.stub().returns(['current', 'rules']);
+const getPluginRules = sinon.stub().returns(['plugin', 'rules']);
+const getAllAvailableRules = sinon.stub().returns(['all', 'available']);
+const getUnusedRules = sinon.stub().returns(['unused', 'rules']);
 
-var stub
+let stub;
 
-describe('bin', function() {
-  beforeEach(function() {
+describe('bin', () => {
+  beforeEach(() => {
     stub = {
-      '../lib/rule-finder': function() {
+      '../lib/rule-finder'() {
         return {
-          getCurrentRules: getCurrentRules,
-          getPluginRules: getPluginRules,
-          getAllAvailableRules: getAllAvailableRules,
-          getUnusedRules: getUnusedRules,
-        }
-      },
-    }
+          getCurrentRules,
+          getPluginRules,
+          getAllAvailableRules,
+          getUnusedRules
+        };
+      }
+    };
 
-    console.log = function() { // eslint-disable-line no-console
-      if (arguments[0].match(/(current|plugin|all\-available|unused|rules found)/)) {
-        return
+    console.log = (...args) => { // eslint-disable-line no-console
+      if (args[0].match(/(current|plugin|all-available|unused|rules found)/)) {
+        return;
       }
-      consoleLog.apply(null, arguments)
-    }
-    process.exit = function noop() {}
-    process.argv = process.argv.slice(0, 2)
-  })
+      consoleLog(...args);
+    };
+    process.exit = function () {}; // noop
+    process.argv = process.argv.slice(0, 2);
+  });
 
-  afterEach(function() {
-    console.log = consoleLog // eslint-disable-line no-console
-    process.exit = processExit
+  afterEach(() => {
+    console.log = consoleLog; // eslint-disable-line no-console
+    process.exit = processExit;
     // purge yargs cache
-    delete require.cache[require.resolve('yargs')]
-  })
+    delete require.cache[require.resolve('yargs')];
+  });
 
-  it('no option', function() {
-    var callCount = 0
-    console.log = function() { // eslint-disable-line no-console
-      callCount += 1
-      if (arguments[0].match(
-        /(no option provided, please provide a valid option|usage:|eslint-find-rules \[option\] <file> \[flag\])/)
+  it('no option', () => {
+    let callCount = 0;
+    console.log = (...args) => { // eslint-disable-line no-console
+      callCount += 1;
+      if (args[0].match(
+        /(no option provided, please provide a valid option|usage:|eslint-find-rules \[option] <file> \[flag])/)
       ) {
-        return
+        return;
       }
-      consoleLog.apply(null, arguments)
-    }
-    proxyquire('../../src/bin/find', stub)
-    assert.equal(callCount, 3) // eslint-disable-line no-console
-  })
+      consoleLog(...args);
+    };
+    proxyquire('../../src/bin/find', stub);
+    assert.equal(callCount, 3); // eslint-disable-line no-console
+  });
 
-  it('option -c|--current', function() {
-    process.argv[2] = '-c'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getCurrentRules.called)
-  })
+  it('option -c|--current', () => {
+    process.argv[2] = '-c';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getCurrentRules.called);
+  });
 
-  it('option -p|--plugin', function() {
-    process.argv[2] = '-p'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getPluginRules.called)
-  })
+  it('option -p|--plugin', () => {
+    process.argv[2] = '-p';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getPluginRules.called);
+  });
 
-  it('option -a|--all-available', function() {
-    process.argv[2] = '-a'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getAllAvailableRules.called)
-    process.argv[2] = '--all-available'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getAllAvailableRules.called)
-  })
+  it('option -a|--all-available', () => {
+    process.argv[2] = '-a';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getAllAvailableRules.called);
+    process.argv[2] = '--all-available';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getAllAvailableRules.called);
+  });
 
-  it('option -u|--unused', function() {
-    process.exit = function(status) {
-      assert.equal(status, 1)
-    }
-    process.argv[2] = '-u'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getUnusedRules.called)
-  })
+  it('option -u|--unused', () => {
+    process.exit = status => {
+      assert.equal(status, 1);
+    };
+    process.argv[2] = '-u';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getUnusedRules.called);
+  });
 
-  it('options -u|--unused and no unused rules found', function() {
-    getUnusedRules.returns([])
-    process.exit = function(status) {
-      assert.equal(status, 0)
-    }
-    process.argv[2] = '-u'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getUnusedRules.called)
-  })
+  it('options -u|--unused and no unused rules found', () => {
+    getUnusedRules.returns([]);
+    process.exit = status => {
+      assert.equal(status, 0);
+    };
+    process.argv[2] = '-u';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getUnusedRules.called);
+  });
 
-  it('option -u|--unused along with -n|--no-error', function() {
-    process.exit = function(status) {
-      assert.equal(status, 0)
-    }
-    process.argv[2] = '-u'
-    process.argv[3] = '-n'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getUnusedRules.called)
-    process.argv[2] = '-u'
-    process.argv[3] = '--no-error'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getUnusedRules.called)
-  })
+  it('option -u|--unused along with -n|--no-error', () => {
+    process.exit = status => {
+      assert.equal(status, 0);
+    };
+    process.argv[2] = '-u';
+    process.argv[3] = '-n';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getUnusedRules.called);
+    process.argv[2] = '-u';
+    process.argv[3] = '--no-error';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getUnusedRules.called);
+  });
 
-  it('logs verbosely', function() {
-    process.argv[2] = '-c'
-    process.argv[3] = '-v'
-    proxyquire('../../src/bin/find', stub)
-    assert.ok(getCurrentRules.called)
-  })
+  it('logs verbosely', () => {
+    process.argv[2] = '-c';
+    process.argv[3] = '-v';
+    proxyquire('../../src/bin/find', stub);
+    assert.ok(getCurrentRules.called);
+  });
 
-  it('logs core rules', function() {
+  it('logs core rules', () => {
     stub = {
-      '../lib/rule-finder': function(specifiedFile, noCore) {
+      '../lib/rule-finder'(specifiedFile, noCore) {
         return {
-          getCurrentRules: function() {
-            assert(!noCore)
-            return ['current', 'rules']
-          },
-        }
-      },
-    }
-    process.argv[2] = '-c'
-    proxyquire('../../src/bin/find', stub)
-  })
+          getCurrentRules() {
+            assert(!noCore);
+            return ['current', 'rules'];
+          }
+        };
+      }
+    };
+    process.argv[2] = '-c';
+    proxyquire('../../src/bin/find', stub);
+  });
 
-  it('does not log core rules', function() {
+  it('does not log core rules', () => {
     stub = {
-      '../lib/rule-finder': function(specifiedFile, noCore) {
+      '../lib/rule-finder'(specifiedFile, noCore) {
         return {
-          getCurrentRules: function() {
-            assert(noCore)
-            return ['current', 'rules']
-          },
-        }
-      },
-    }
-    process.argv[2] = '-c'
-    process.argv[3] = '--no-core'
-    proxyquire('../../src/bin/find', stub)
-  })
-})
+          getCurrentRules() {
+            assert(noCore);
+            return ['current', 'rules'];
+          }
+        };
+      }
+    };
+    process.argv[2] = '-c';
+    process.argv[3] = '--no-core';
+    proxyquire('../../src/bin/find', stub);
+  });
+});

test/lib/array-diff.js

@@ -1,24 +0,23 @@
-var assert = require('assert')
-var difference = require('../../src/lib/array-diff')
+const assert = require('assert');
+const difference = require('../../src/lib/array-diff');
 
-describe('array difference', function() {
-  it('should return difference', function() {
+describe('array difference', () => {
+  it('should return difference', () => {
     assert.deepEqual(
       difference(['a', 'b', 'c'], ['x', 'y', 'z']),
       ['a', 'b', 'c']
-    )
+    );
     assert.deepEqual(
       difference(['a', 'b', 'c'], ['a', 'y', 'z']),
       ['b', 'c']
-    )
+    );
     assert.deepEqual(
       difference(['a', 'b', 'c'], ['a', 'b', 'z']),
       ['c']
-    )
-
+    );
     assert.deepEqual(
       difference(['a', 'b', 'c'], ['a', 'b', 'c']),
       []
-    )
-  })
-})
+    );
+  });
+});

test/lib/cli-util.js

@@ -1,29 +0,28 @@
-var assert = require('assert')
-var proxyquire = require('proxyquire')
-var sinon = require('sinon')
+const assert = require('assert');
+const proxyquire = require('proxyquire');
+const sinon = require('sinon');
 
-var moduleStub = {
-  'window-size': {width: 80},
-}
+const moduleStub = {
+  'window-size': {width: 80}
+};
 
-var loggerStub = {
-  log: function noop() {},
-}
+const loggerStub = {
+  log() {} // noop
+};
 
-describe('cli-util', function() {
+describe('cli-util', () => {
+  before(() => {
+    sinon.stub(loggerStub, 'log');
+  });
 
-  before(function() {
-    sinon.stub(loggerStub, 'log')
-  })
+  after(() => {
+    loggerStub.log.restore();
+  });
 
-  after(function() {
-    loggerStub.log.restore()
-  })
+  it('prints out single lines', () => {
+    const cli = proxyquire('../../src/lib/cli-util', moduleStub);
 
-  it('prints out single lines', function() {
-    var cli = proxyquire('../../src/lib/cli-util', moduleStub)
+    cli.push('A single line');
+    cli.write(loggerStub);
 
-    cli.push('A single line')
-    cli.write(loggerStub)
-
     assert.ok(
@@ -33,7 +32,7 @@ loggerStub.log.calledWith(
       )
-    )
-  })
+    );
+  });
 
-  it('prints out multiple columns', function() {
-    var cli = proxyquire('../../src/lib/cli-util', moduleStub)
+  it('prints out multiple columns', () => {
+    const cli = proxyquire('../../src/lib/cli-util', moduleStub);
 
@@ -45,5 +44,5 @@ cli.push([
       'Everything in a single cell',
-      'Everything in a single cell',
-    ])
-    cli.write(loggerStub)
+      'Everything in a single cell'
+    ]);
+    cli.write(loggerStub);
 
@@ -54,7 +53,7 @@ assert.ok(
       )
-    )
-  })
+    );
+  });
 
-  it('prints out with an exact amount of columns', function() {
-    var cli = proxyquire('../../src/lib/cli-util', moduleStub)
+  it('prints out with an exact amount of columns', () => {
+    const cli = proxyquire('../../src/lib/cli-util', moduleStub);
 
@@ -66,5 +65,5 @@ cli.push([
       'This in the second row',
-      'This in the second row',
-    ], 3)
-    cli.write(loggerStub)
+      'This in the second row'
+    ], 3);
+    cli.write(loggerStub);
 
@@ -77,5 +76,4 @@ assert.ok(
       )
-    )
-  })
-
-})
+    );
+  });
+});

test/lib/flatten-rules-diff.js

@@ -1,38 +0,38 @@
-var assert = require('assert')
-var flattenRulesDiff = require('../../src/lib/flatten-rules-diff')
+const assert = require('assert');
+const flattenRulesDiff = require('../../src/lib/flatten-rules-diff');
 
-describe('flatten rules diff', function() {
-  it('should return flat array from diff-object with single rule', function() {
+describe('flatten rules diff', () => {
+  it('should return flat array from diff-object with single rule', () => {
     assert.deepEqual(
       flattenRulesDiff({'foo-rule': {config1: [2, 'foo'], config2: [2, 'bar']}}),
       ['foo-rule', [2, 'foo'], [2, 'bar']]
-    )
-  })
+    );
+  });
 
-  it('should return flat array from diff-object with multiple rules', function() {
+  it('should return flat array from diff-object with multiple rules', () => {
     assert.deepEqual(
       flattenRulesDiff({
         'foo-rule': {config1: [2, 'foo'], config2: [2, 'bar']},
-        'bar-rule': {config1: undefined, config2: [1, 'bar']},
+        'bar-rule': {config1: undefined, config2: [1, 'bar']}
       }),
       ['foo-rule', [2, 'foo'], [2, 'bar'], 'bar-rule', undefined, [1, 'bar']]
-    )
-  })
+    );
+  });
 
-  it('should return flat array from an array of diff-objects', function() {
+  it('should return flat array from an array of diff-objects', () => {
     assert.deepEqual(
       flattenRulesDiff([
         {'foo-rule': {config1: [2, 'foo'], config2: [2, 'bar']}},
-        {'bar-rule': {config1: undefined, config2: [1, 'bar']}},
+        {'bar-rule': {config1: undefined, config2: [1, 'bar']}}
       ]),
       ['foo-rule', [2, 'foo'], [2, 'bar'], 'bar-rule', undefined, [1, 'bar']]
-    )
-  })
+    );
+  });
 
-  it('should return empty array on anything else', function() {
+  it('should return empty array on anything else', () => {
     assert.deepEqual(
       flattenRulesDiff(undefined),
       []
-    )
-  })
-})
+    );
+  });
+});

test/lib/object-diff.js

@@ -1,14 +0,14 @@
-var assert = require('assert')
-var difference = require('../../src/lib/object-diff')
+const assert = require('assert');
+const difference = require('../../src/lib/object-diff');
 
-describe('object difference', function() {
-  it('should return difference', function() {
+describe('object difference', () => {
+  it('should return difference', () => {
     assert.deepEqual(
       difference({'foo-rule': [2, 'foo']}, {'foo-rule': [2, 'bar']}),
       {'foo-rule': {config1: [2, 'foo'], config2: [2, 'bar']}}
-    )
+    );
     assert.deepEqual(
       difference({'foo-rule': [2, 'foo', 'bar']}, {'foo-rule': 2}),
       {'foo-rule': {config1: [2, 'foo', 'bar'], config2: 2}}
-    )
+    );
     assert.deepEqual(
@@ -18,11 +18,10 @@ difference({'foo-rule': [0, 'foo']}, {'bar-rule': [1, 'bar']}),
         'foo-rule': {config1: [0, 'foo'], config2: undefined},
-        'bar-rule': {config1: undefined, config2: [1, 'bar']},
+        'bar-rule': {config1: undefined, config2: [1, 'bar']}
       }
-    )
-
+    );
     assert.deepEqual(
       difference({'foo-rule': [1, 'foo', 'bar']}, {'foo-rule': [1, 'foo', 'bar']}),
       {}
-    )
-  })
-})
+    );
+  });
+});

test/lib/rule-finder.js

@@ -1,12 +0,17 @@
-var path = require('path')
-var assert = require('assert')
-var proxyquire = require('proxyquire')
+const path = require('path');
+const assert = require('assert');
+const proxyquire = require('proxyquire');
 
-var processCwd = process.cwd
+const processCwd = process.cwd;
 
-var getRuleFinder = proxyquire('../../src/lib/rule-finder', {
-  fs: {
-    readdirSync: function() {
-      return ['.eslintrc.yml', 'foo-rule.js', 'bar-rule.js', 'baz-rule.js']
-    },
+const getRuleFinder = proxyquire('../../src/lib/rule-finder', {
+  eslint: {
+    linter: {
+      getRules() {
+        return new Map()
+          .set('foo-rule', {})
+          .set('bar-rule', {})
+          .set('baz-rule', {});
+      }
+    }
   },
@@ -17,6 +22,6 @@ 'eslint-plugin-plugin': {
       'bar-rule': true,
-      'baz-rule': true,
+      'baz-rule': true
     },
     '@noCallThru': true,
-    '@global': true,
+    '@global': true
   },
@@ -26,3 +31,3 @@ 'eslint-plugin-no-rules': {
     '@noCallThru': true,
-    '@global': true,
+    '@global': true
   },
@@ -32,75 +37,69 @@ '@scope/eslint-plugin-scoped-plugin': {
       'foo-rule': true,
-      'bar-rule': true,
+      'bar-rule': true
     },
     '@noCallThru': true,
-    '@global': true,
-  },
-})
+    '@global': true
+  }
+});
 
-var noSpecifiedFile = path.resolve(process.cwd(), './test/fixtures/no-path')
-var specifiedFileRelative = './test/fixtures/eslint.json'
-var specifiedFileAbsolute = path.join(process.cwd(), specifiedFileRelative)
-var noRulesFile = path.join(process.cwd(), './test/fixtures/eslint-with-plugin-with-no-rules.json')
+const noSpecifiedFile = path.resolve(process.cwd(), './test/fixtures/no-path');
+const specifiedFileRelative = './test/fixtures/eslint.json';
+const specifiedFileAbsolute = path.join(process.cwd(), specifiedFileRelative);
+const noRulesFile = path.join(process.cwd(), './test/fixtures/eslint-with-plugin-with-no-rules.json');
 
-describe('rule-finder', function() {
-  afterEach(function() {
-    process.cwd = processCwd
-  })
+describe('rule-finder', () => {
+  afterEach(() => {
+    process.cwd = processCwd;
+  });
 
-  it('no specifiedFile is passed to the constructor', function() {
-    var ruleFinder
-    process.cwd = function() {
-      return noSpecifiedFile
-    }
-    ruleFinder = getRuleFinder()
-    assert.deepEqual(ruleFinder.getUnusedRules(), ['bar-rule', 'baz-rule'])
-  })
+  it('no specifiedFile is passed to the constructor', () => {
+    process.cwd = function () {
+      return noSpecifiedFile;
+    };
+    const ruleFinder = getRuleFinder();
+    assert.deepEqual(ruleFinder.getUnusedRules(), ['bar-rule', 'baz-rule']);
+  });
 
-  it('no specifiedFile - current rules', function() {
-    var ruleFinder
-    process.cwd = function() {
-      return noSpecifiedFile
-    }
-    ruleFinder = getRuleFinder()
-    assert.deepEqual(ruleFinder.getCurrentRules(), ['foo-rule'])
-  })
+  it('no specifiedFile - current rules', () => {
+    process.cwd = function () {
+      return noSpecifiedFile;
+    };
+    const ruleFinder = getRuleFinder();
+    assert.deepEqual(ruleFinder.getCurrentRules(), ['foo-rule']);
+  });
 
-  it('no specifiedFile - current rule config', function() {
-    var ruleFinder
-    process.cwd = function() {
-      return noSpecifiedFile
-    }
-    ruleFinder = getRuleFinder()
-    assert.deepEqual(ruleFinder.getCurrentRulesDetailed(), {'foo-rule': [2]})
-  })
+  it('no specifiedFile - current rule config', () => {
+    process.cwd = function () {
+      return noSpecifiedFile;
+    };
+    const ruleFinder = getRuleFinder();
+    assert.deepEqual(ruleFinder.getCurrentRulesDetailed(), {'foo-rule': [2]});
+  });
 
-  it('no specifiedFile - plugin rules', function() {
-    var ruleFinder
-    process.cwd = function() {
-      return noSpecifiedFile
-    }
-    ruleFinder = getRuleFinder()
-    assert.deepEqual(ruleFinder.getPluginRules(), [])
-  })
+  it('no specifiedFile - plugin rules', () => {
+    process.cwd = function () {
+      return noSpecifiedFile;
+    };
+    const ruleFinder = getRuleFinder();
+    assert.deepEqual(ruleFinder.getPluginRules(), []);
+  });
 
-  it('no specifiedFile - all available rules', function() {
-    var ruleFinder
-    process.cwd = function() {
-      return noSpecifiedFile
-    }
-    ruleFinder = getRuleFinder()
-    assert.deepEqual(ruleFinder.getAllAvailableRules(), ['bar-rule', 'baz-rule', 'foo-rule'])
-  })
+  it('no specifiedFile - all available rules', () => {
+    process.cwd = function () {
+      return noSpecifiedFile;
+    };
+    const ruleFinder = getRuleFinder();
+    assert.deepEqual(ruleFinder.getAllAvailableRules(), ['bar-rule', 'baz-rule', 'foo-rule']);
+  });
 
-  it('no specifiedFile - all available rules without core', function() {
-    var ruleFinder
-    process.cwd = function() {
-      return noSpecifiedFile
-    }
-    ruleFinder = getRuleFinder(null, true)
-    assert.deepEqual(ruleFinder.getAllAvailableRules(), [])
-  })
+  it('no specifiedFile - all available rules without core', () => {
+    process.cwd = function () {
+      return noSpecifiedFile;
+    };
+    const ruleFinder = getRuleFinder(null, true);
+    assert.deepEqual(ruleFinder.getAllAvailableRules(), []);
+  });
 
-  it('specifiedFile (relative path) is passed to the constructor', function() {
-    var ruleFinder = getRuleFinder(specifiedFileRelative)
+  it('specifiedFile (relative path) is passed to the constructor', () => {
+    const ruleFinder = getRuleFinder(specifiedFileRelative);
     assert.deepEqual(ruleFinder.getUnusedRules(), [
@@ -111,22 +110,22 @@ 'baz-rule',
       'plugin/foo-rule',
-      'scoped-plugin/bar-rule',
-    ])
-  })
+      'scoped-plugin/bar-rule'
+    ]);
+  });
 
-  it('specifiedFile (relative path) - current rules', function() {
-    var ruleFinder = getRuleFinder(specifiedFileRelative)
-    assert.deepEqual(ruleFinder.getCurrentRules(), ['bar-rule', 'foo-rule', 'scoped-plugin/foo-rule'])
-  })
+  it('specifiedFile (relative path) - current rules', () => {
+    const ruleFinder = getRuleFinder(specifiedFileRelative);
+    assert.deepEqual(ruleFinder.getCurrentRules(), ['bar-rule', 'foo-rule', 'scoped-plugin/foo-rule']);
+  });
 
-  it('specifiedFile (relative path) - current rule config', function() {
-    var ruleFinder = getRuleFinder(specifiedFileRelative)
+  it('specifiedFile (relative path) - current rule config', () => {
+    const ruleFinder = getRuleFinder(specifiedFileRelative);
     assert.deepEqual(ruleFinder.getCurrentRulesDetailed(), {
       'bar-rule': [2],
       'foo-rule': [2],
-      'scoped-plugin/foo-rule': [2],
-    })
-  })
+      'scoped-plugin/foo-rule': [2]
+    });
+  });
 
-  it('specifiedFile (relative path) - plugin rules', function() {
-    var ruleFinder = getRuleFinder(specifiedFileRelative)
+  it('specifiedFile (relative path) - plugin rules', () => {
+    const ruleFinder = getRuleFinder(specifiedFileRelative);
     assert.deepEqual(ruleFinder.getPluginRules(), [
@@ -137,8 +136,8 @@ 'plugin/bar-rule',
       'scoped-plugin/bar-rule',
-      'scoped-plugin/foo-rule',
-    ])
-  })
+      'scoped-plugin/foo-rule'
+    ]);
+  });
 
-  it('specifiedFile (relative path) - all available rules', function() {
-    var ruleFinder = getRuleFinder(specifiedFileRelative)
+  it('specifiedFile (relative path) - all available rules', () => {
+    const ruleFinder = getRuleFinder(specifiedFileRelative);
     assert.deepEqual(
@@ -154,9 +153,9 @@ ruleFinder.getAllAvailableRules(),
         'scoped-plugin/bar-rule',
-        'scoped-plugin/foo-rule',
+        'scoped-plugin/foo-rule'
       ]
-    )
-  })
+    );
+  });
 
-  it('specifiedFile (relative path) - all available rules without core', function() {
-    var ruleFinder = getRuleFinder(specifiedFileRelative, true)
+  it('specifiedFile (relative path) - all available rules without core', () => {
+    const ruleFinder = getRuleFinder(specifiedFileRelative, true);
     assert.deepEqual(
@@ -169,9 +168,9 @@ ruleFinder.getAllAvailableRules(),
         'scoped-plugin/bar-rule',
-        'scoped-plugin/foo-rule',
+        'scoped-plugin/foo-rule'
       ]
-    )
-  })
+    );
+  });
 
-  it('specifiedFile (absolute path) is passed to the constructor', function() {
-    var ruleFinder = getRuleFinder(specifiedFileAbsolute)
+  it('specifiedFile (absolute path) is passed to the constructor', () => {
+    const ruleFinder = getRuleFinder(specifiedFileAbsolute);
     assert.deepEqual(ruleFinder.getUnusedRules(), [
@@ -182,22 +181,22 @@ 'baz-rule',
       'plugin/foo-rule',
-      'scoped-plugin/bar-rule',
-    ])
-  })
+      'scoped-plugin/bar-rule'
+    ]);
+  });
 
-  it('specifiedFile (absolute path) - current rules', function() {
-    var ruleFinder = getRuleFinder(specifiedFileAbsolute)
-    assert.deepEqual(ruleFinder.getCurrentRules(), ['bar-rule', 'foo-rule', 'scoped-plugin/foo-rule'])
-  })
+  it('specifiedFile (absolute path) - current rules', () => {
+    const ruleFinder = getRuleFinder(specifiedFileAbsolute);
+    assert.deepEqual(ruleFinder.getCurrentRules(), ['bar-rule', 'foo-rule', 'scoped-plugin/foo-rule']);
+  });
 
-  it('specifiedFile (absolute path) - current rule config', function() {
-    var ruleFinder = getRuleFinder(specifiedFileAbsolute)
+  it('specifiedFile (absolute path) - current rule config', () => {
+    const ruleFinder = getRuleFinder(specifiedFileAbsolute);
     assert.deepEqual(ruleFinder.getCurrentRulesDetailed(), {
       'foo-rule': [2],
       'bar-rule': [2],
-      'scoped-plugin/foo-rule': [2],
-    })
-  })
+      'scoped-plugin/foo-rule': [2]
+    });
+  });
 
-  it('specifiedFile (absolute path) - plugin rules', function() {
-    var ruleFinder = getRuleFinder(specifiedFileAbsolute)
+  it('specifiedFile (absolute path) - plugin rules', () => {
+    const ruleFinder = getRuleFinder(specifiedFileAbsolute);
     assert.deepEqual(ruleFinder.getPluginRules(), [
@@ -208,8 +207,8 @@ 'plugin/bar-rule',
       'scoped-plugin/bar-rule',
-      'scoped-plugin/foo-rule',
-    ])
-  })
+      'scoped-plugin/foo-rule'
+    ]);
+  });
 
-  it('specifiedFile (absolute path) - all available rules', function() {
-    var ruleFinder = getRuleFinder(specifiedFileAbsolute)
+  it('specifiedFile (absolute path) - all available rules', () => {
+    const ruleFinder = getRuleFinder(specifiedFileAbsolute);
     assert.deepEqual(
@@ -225,15 +224,15 @@ ruleFinder.getAllAvailableRules(),
         'scoped-plugin/bar-rule',
-        'scoped-plugin/foo-rule',
+        'scoped-plugin/foo-rule'
       ]
-    )
-  })
+    );
+  });
 
-  it('specifiedFile (absolute path) without rules - plugin rules', function() {
-    var ruleFinder = getRuleFinder(noRulesFile)
+  it('specifiedFile (absolute path) without rules - plugin rules', () => {
+    const ruleFinder = getRuleFinder(noRulesFile);
     assert.deepEqual(ruleFinder.getPluginRules(), [
       'plugin/bar-rule',
       'plugin/baz-rule',
-      'plugin/foo-rule',
-    ])
-  })
-})
+      'plugin/foo-rule'
+    ]);
+  });
+});

test/lib/sort-rules.js

@@ -1,30 +0,30 @@
-var assert = require('assert')
-var sortRules = require('../../src/lib/sort-rules')
+const assert = require('assert');
+const sortRules = require('../../src/lib/sort-rules');
 
-describe('sort-rules', function() {
-  it('should return sorted rules', function() {
+describe('sort-rules', () => {
+  it('should return sorted rules', () => {
     assert.deepEqual(
       sortRules(['a', 'b', 'c']),
       ['a', 'b', 'c']
-    )
+    );
     assert.deepEqual(
       sortRules(['c', 'b', 'a']),
       ['a', 'b', 'c']
-    )
+    );
     assert.deepEqual(
       sortRules(['aa', 'a', 'ab', 'b', 'c']),
       ['a', 'aa', 'ab', 'b', 'c']
-    )
-  })
+    );
+  });
 
-  it('should return sorted rule configs', function() {
+  it('should return sorted rule configs', () => {
     assert.deepEqual(
       sortRules({'bar-rule': {config1: '1', config2: '2'}, 'baz-rule': {config1: '3', config2: '4'}}),
       [{'bar-rule': {config1: '1', config2: '2'}}, {'baz-rule': {config1: '3', config2: '4'}}]
-    )
+    );
     assert.deepEqual(
       sortRules({'foo-rule': {config1: '1', config2: '2'}, 'bar-rule': {config1: '3', config2: '4'}}),
       [{'bar-rule': {config1: '3', config2: '4'}}, {'foo-rule': {config1: '1', config2: '2'}}]
-    )
-  })
-})
+    );
+  });
+});

test/lib/stringify-rule-config.js

@@ -1,25 +0,25 @@
-var assert = require('assert')
-var stringifyRuleConfig = require('../../src/lib/stringify-rule-config')
+const assert = require('assert');
+const stringifyRuleConfig = require('../../src/lib/stringify-rule-config');
 
-describe('stringify rule config', function() {
-  it('should return a string', function() {
+describe('stringify rule config', () => {
+  it('should return a string', () => {
     assert.equal(
       stringifyRuleConfig('A simple string'),
       'A simple string'
-    )
-  })
+    );
+  });
 
-  it('should return \'-\' for "undefined"', function() {
+  it('should return \'-\' for "undefined"', () => {
     assert.equal(
       stringifyRuleConfig(undefined),
       '-'
-    )
-  })
+    );
+  });
 
-  it('should return a JSON.stringify\'ed result for any object', function() {
+  it('should return a JSON.stringify\'ed result for any object', () => {
     assert.deepEqual(
       stringifyRuleConfig([2, 'foo', {bar: true}]),
       JSON.stringify([2, 'foo', {bar: true}])
-    )
-  })
-})
+    );
+  });
+});

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Improved metrics

Number of low supply chain risk alerts

2

decreased by-33.33%

Worsened metrics

Total package byte prevSize

45437

decreased by-1.87%

Dev dependency count

20

increased by25%

Lines of code

968

decreased by-3.39%

Number of medium supply chain risk alerts

2

increased byInfinity%

No dependency changes