Add Rule Blocklist

Author: pointlessone

lib/eslint-patch.js

@@ -7,6 +7,7 @@ const ConfigFile = require("eslint/lib/config/config-file");
 
 const Config = require("eslint/lib/config");
 const ConfigUpgrader = require("./config_upgrader");
+const RuleBlocklist = require("./rule_blocklist");
 
 module.exports = function patch() {
   const skippedModules = [];
@@ -43,8 +44,11 @@ module.exports = function patch() {
   Config.prototype.getConfig = function(filePath) {
     const originalConfig = originalGetConfig.apply(this, [filePath]);
     const configUpgrader = new ConfigUpgrader();
+    const ruleBlocklist = new RuleBlocklist();
 
-    return configUpgrader.upgrade(originalConfig);
+    return ruleBlocklist.filter(
+      configUpgrader.upgrade(originalConfig)
+    );
   };
 
   return require('eslint');

lib/eslint.js

@@ -11,6 +11,7 @@ const checks = require("./checks");
 const validateConfig = require("./validate_config");
 const computeFingerprint = require("./compute_fingerprint");
 const ConfigUpgrader = require("./config_upgrader");
+const RuleBlocklist = require("./rule_blocklist");
 const findConfigs = require("./config_finder");
 
 const CLIEngine = eslint.CLIEngine;
@@ -235,7 +236,8 @@ function run(console, runOptions) {
     let configs = findConfigs(options.configFile, analysisFiles);
 
     let report = [
-      ConfigUpgrader.upgradeInstructions(configs, process.cwd())
+      ConfigUpgrader.upgradeInstructions(configs, process.cwd()),
+      RuleBlocklist.report(configs)
     ].reduce(function(a, b) { return a.concat([""]).concat(b); });
 
     for (const line of report) {

lib/rule_blocklist.js

@@ -0,0 +1,86 @@
+"use strict";
+
+const Config = require("eslint/lib/config")
+  , merge = require("eslint/lib/config/config-ops").merge;
+
+const blocklistedRules = [
+  "import/no-unresolved",
+  "import/extensions",
+  "import/no-absolute-path"
+];
+
+function filterRules(rules) {
+  let report = [];
+
+  for (const name of blocklistedRules) {
+    if (Reflect.has(rules, name)) {
+      let config = rules[name];
+      if (config.constructor !== Array) {
+        config = [config];
+      }
+      let severity = config.shift();
+
+      if (severity !== 0 && !(typeof severity === "string" && severity.toLowerCase() === "off")) {
+        rules[name] = "off";
+        report.push(`* ${name}`);
+      }
+    }
+  }
+  return report;
+}
+
+class RuleBlocklist {
+  constructor() {
+    this._report = [];
+  }
+
+  filter(originalConfig) {
+    if (typeof originalConfig === "undefined" || originalConfig === null) {
+      return {};
+    }
+
+    let config = merge({}, originalConfig);
+
+    this._report = [];
+
+    if (Reflect.has(config, "rules")) {
+      let report = filterRules(config.rules);
+      this._report = this._report.concat(report);
+    }
+
+    return config;
+  }
+
+  get report() {
+    return [].concat(this._report);
+  }
+
+  static report(configs) {
+    const reports = configs.map(function(configFile) {
+      let report = [];
+
+      const blocklist = new RuleBlocklist();
+      const config = new Config({
+        configFile: configFile,
+        cwd: process.cwd()
+      });
+      blocklist.filter(config.useSpecificConfig);
+
+      if (report.length > 0 || blocklist.report.length > 0) {
+        report = report.concat(blocklist.report);
+      }
+
+      return report;
+    });
+
+    if (reports.length === 0) {
+      return [];
+    } else {
+      return [["Ignoring the following rules that rely on module resolution:"]]
+        .concat(reports)
+        .reduce(function(a, b) { return a.concat([""]).concat(b); });
+    }
+  }
+}
+
+module.exports = RuleBlocklist;

test/rule_blocklist_test.js

@@ -0,0 +1,71 @@
+const RuleBlocklist = require("../lib/rule_blocklist")
+  , expect = require("chai").expect
+  , fs = require("fs")
+  , path = require("path")
+  , stringify = require("json-stable-stringify")
+  , temp = require('temp');
+
+describe("ConfigUpgrader", function() {
+  describe(".report", function() {
+    it("returns blocklist report", function(done) {
+      temp.mkdir("code ", function(err, directory) {
+        if (err) { throw err; }
+
+        process.chdir(directory);
+
+        const configPath = path.join(directory, ".eslintrc");
+        fs.writeFile(configPath, '{"rules":{"import/no-unresolved":2}}', function(err) {
+          if (err) { throw err; }
+
+          let report = RuleBlocklist.report([directory + '/.eslintrc']);
+          expect(report).to.deep.eq([
+            "Ignoring the following rules that rely on module resolution:",
+            "",
+            "* import/no-unresolved"
+          ]);
+          done();
+        });
+      });
+    });
+  });
+
+
+  describe("#filter", function() {
+    it("doesn't fail with null config", function(done) {
+      let blocklist = new RuleBlocklist();
+      expect(function() {
+        blocklist.filter(null);
+      }).to.not.throw(TypeError);
+      done();
+    });
+
+    describe("rules", function() {
+      [
+        [
+          {rules: {"import/no-unresolved": [2, "opt1", "opt2"]}},
+          {rules: {"import/no-unresolved": "off"}}
+        ],
+        [
+          {rules: {"import/extensions": 2}},
+          {rules: {"import/extensions": "off"}}
+        ],
+        [
+          {rules: {"import/no-absolute-path": 1}},
+          {rules: {"import/no-absolute-path": "off"}}
+        ]
+      ].forEach(function(example){
+        let originalConfig = example[0];
+        let convertedConfig = example[1];
+
+        it(`filters out ${stringify(originalConfig)}`, function(done){
+          let blocklist = new RuleBlocklist();
+          let actualConfig = blocklist.filter(originalConfig);
+
+          expect(actualConfig).to.deep.eq(convertedConfig);
+          expect(blocklist.report).to.lengthOf(1);
+          done();
+        });
+      });
+    });
+  });
+});