Do not raise error on unsupported plugins (#204)

* Fix #192

* Decouple docs from eslint patch

* Prevent error on not supported modules (plugins/extensions)
Given an .eslintrc.yml:
```yaml
env:
    es6: true
    node: true
parserOptions:
    sourceType: module
plugins:
    - node
    - not_supported
extends:
    - not_valid
    - 'plugin:invalidplugin/recommended'
    - 'eslint:recommended'
    - 'plugin:node/recommended'
rules:
    invalidplugin/rule: 1
    node/exports-style: [error, module.exports]
    indent: [error, 4]
    linebreak-style: [error, unix]
    quotes: [error, double]
    semi: [error, always]
    no-console: off
```
When `CODECLIMATE_DEBUG=true codeclimate analyze` runs
Then the output is like:
```
...
Module not supported: eslint-plugin-not_supported
Module not supported: eslint-plugin-invalidplugin
Module not supported: eslint-config-not_valid
...
Analyzing: app1.js
...

== app1.js (1 issue) ==
1: Definition for rule 'invalidplugin/rule' was not found [eslint]
```

Author: filipesperandio

bin/eslint.js

@@ -8,10 +8,11 @@ process.chdir(CODE_DIR);
 var stdout = console.log;
 console.log = console.error;
 
-var eslint = require('../lib/eslint-patch')(require('eslint'));
+
+var eslint = require('../lib/eslint-patch')();
 
 var CLIEngine = eslint.CLIEngine;
-var docs = eslint.docs;
+var docs = require('../lib/docs')();
 var fs = require("fs");
 var glob = require("glob");
 var options = { extensions: [".js"], ignore: true, reset: false, useEslintrc: true };

lib/docs.js

@@ -7,13 +7,14 @@
 var fs = require('fs')
   , path = require('path');
 
-//------------------------------------------------------------------------------
-// Privates
-//------------------------------------------------------------------------------
+function Docs() {
 
-var docs = Object.create(null);
+  var docs = Object.create(null);
+
+  function get(ruleId) {
+    return docs[ruleId];
+  }
 
-function load() {
   var docsDir = path.join(__dirname, '/docs/rules');
 
   fs.readdirSync(docsDir).forEach(function(file) {
@@ -22,19 +23,10 @@ function load() {
     // Remove the .md extension from the filename
     docs[file.slice(0, -3)] = content;
   });
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
 
-exports.get = function(ruleId) {
-  return docs[ruleId];
-};
-
-//------------------------------------------------------------------------------
-// Initialization
-//------------------------------------------------------------------------------
+  return {
+    get: get
+  };
+}
 
-// loads existing docs
-load();
+module.exports = Docs;

lib/empty-plugin.js

@@ -0,0 +1,6 @@
+module.exports = {
+  rules: {},
+  configs: {
+    recommended: {}
+  }
+};

lib/eslint-patch.js

@@ -1,33 +1,50 @@
-'use strict';
-var meld = require('meld');
-var docs = require('./docs');
-var Config = require("eslint/lib/config");
-var ConfigUpgrader = require('./config_upgrader');
-
-var supportedPlugins = ['react', 'babel'];
-
-module.exports = function patcher(eslint) {
-
-  meld.around(eslint.CLIEngine, 'loadPlugins', function(joinPoint) {
-    var pluginNames = joinPoint.args[0];
-    var filteredPluginNames = pluginNames.filter(function(pluginName) {
-      return supportedPlugins.indexOf(pluginName) >= 0;
-    });
-    return joinPoint.proceed(filteredPluginNames);
-  });
-
-  meld.around(eslint.CLIEngine, 'addPlugin', function() {
-    return;
-  });
-
-  // meld.around(eslint.CLIEngine.Config, 'loadPackage', function(joinPoint) {
-  //   var filePath = joinPoint.args[0];
-  //   if (filePath.match(/^eslint-config-airbnb.*/)) {
-  //     return joinPoint.proceed();
-  //   } else {
-  //     return {};
-  //   }
-  // });
+"use strict";
+
+const Plugins = require("eslint/lib/config/plugins");
+const ModuleResolver = require("eslint/lib/util/module-resolver");
+
+const ConfigFile = require("eslint/lib/config/config-file");
+
+const Config = require("eslint/lib/config");
+const ConfigUpgrader = require("./config_upgrader");
+
+module.exports = function patch() {
+
+  const skippedModules = [];
+  function warnModuleNotSupported(name) {
+      if(skippedModules.indexOf(name) < 0) {
+        skippedModules.push(name);
+        console.error(`Module not supported: ${name}`);
+      }
+  }
+
+  const resolve = ModuleResolver.prototype.resolve;
+  ModuleResolver.prototype.resolve = function(name, path) {
+    try {
+      return resolve.apply(this, [name, path]);
+    } catch(e) {
+      warnModuleNotSupported(name);
+      return `${__dirname}/empty-plugin.js`;
+    }
+  };
+
+  Plugins.loadAll = function(pluginNames) {
+    const loadedPlugins = Object.keys(Plugins.getAll());
+    if(loadedPlugins.length > 0) {
+      return;
+    }
+
+    for(const index in pluginNames) {
+      const name = pluginNames[index];
+      try {
+
+        Plugins.load(name);
+
+      } catch(e) {
+        warnModuleNotSupported(`eslint-plugin-${name}`);
+      }
+    }
+  };
 
   const originalGetConfig = Config.prototype.getConfig;
   Config.prototype.getConfig = function(filePath) {
@@ -37,7 +54,5 @@ module.exports = function patcher(eslint) {
     return configUpgrader.upgrade(originalConfig);
   };
 
-  eslint.docs = docs;
-
-  return eslint;
+  return require('eslint');
 };

package.json

@@ -59,8 +59,7 @@
     "eslint-plugin-vue": "^2.0.1",
     "eslint-plugin-xogroup": "^1.2.0",
     "glob": "^7.0.6",
-    "prettier": "^0.22.0",
-    "meld": "^1.3.2"
+    "prettier": "^0.22.0"
   },
   "devDependencies": {
     "chai": "^3.5.0",

test/eslint-patch_test.js

@@ -0,0 +1,86 @@
+const expect = require("chai").expect;
+const sinon = require("sinon");
+
+const Plugins = require("eslint/lib/config/plugins");
+const ModuleResolver = require("eslint/lib/util/module-resolver");
+const eslintPatch = require("../lib/eslint-patch");
+
+describe("eslint-patch", function() {
+  let loadAll;
+
+  before(function() {
+    loadAll = Plugins.loadAll;
+  });
+
+  after(function() {
+    Plugins.loadAll = loadAll;
+  });
+
+  it("intercepts plugins", function() {
+    eslintPatch();
+    expect(loadAll).to.not.equal(Plugins.loadAll, "Plugins.loadAll is not patched");
+  });
+
+  describe("Plugins.loadAll", function() {
+    before(function() {
+      eslintPatch();
+    });
+
+    it("delegates each plugin to be loaded", function () {
+      Plugins.getAll = sinon.stub().returns([]);
+      Plugins.load = sinon.spy();
+
+      Plugins.loadAll([ "jasmine", "mocha"  ]);
+
+      expect(Plugins.load.calledWith("jasmine")).to.be.true;
+      expect(Plugins.load.calledWith("mocha")).to.be.true;
+    });
+
+    it("only load plugins once", function () {
+      Plugins.getAll = sinon.stub().returns([ "node" ]);
+      Plugins.load = sinon.spy();
+
+      Plugins.loadAll([ "node" ]);
+
+      expect(Plugins.load.called).to.be.false;
+    });
+
+    it("does not raise exception for unsupported plugins", function() {
+      Plugins.getAll = sinon.stub().returns([]);
+      Plugins.load = sinon.stub().throws();
+
+      function loadPlugin() {
+        Plugins.loadAll([ "unsupported-plugin" ]);
+      }
+
+      expect(loadPlugin).to.not.throw();
+    });
+  });
+
+  describe("loading extends configuration", function() {
+    it("patches module resolver", function() {
+      const resolve = ModuleResolver.prototype.resolve;
+
+      eslintPatch();
+      expect(ModuleResolver.prototype.resolve).to.not.eql(resolve);
+    });
+
+    it("returns fake config for skipped modules", function() {
+      eslintPatch();
+      Plugins.loadAll(['invalidplugin']);
+      expect(new ModuleResolver().resolve('eslint-plugin-invalidplugin')).to.match(/.+empty-plugin.js/);
+    });
+
+    it("does not warn user repeatedly about not supported modules", function() {
+      console.error = sinon.spy();
+      eslintPatch();
+
+      for(var i=0; i<3; i++) {
+        new ModuleResolver().resolve('eslint-plugin-bogus');
+      }
+
+      expect(console.error.callCount).to.eql(1);
+    });
+  });
+
+});