Merge remote-tracking branch 'origin/master' into fix-ts

Author: ricardogobbosouza

README.md

@@ -159,7 +159,7 @@ Accepts a function that will have one argument: an array of eslint messages (obj
 
 Lint only changed files, skip lint on start.
 
-#### `threads`
+### `threads`
 
 - Type: `Boolean | Number`
 - Default: `false`

declarations/getESLint.d.ts

@@ -11,16 +11,25 @@
  */
 export function loadESLint(options: Options): Linter;
 /**
+ * @param {string|undefined} key
  * @param {number} poolSize
  * @param {Options} options
  * @returns {Linter}
  */
-export function loadESLintThreaded(poolSize: number, options: Options): Linter;
+export function loadESLintThreaded(
+  key: string | undefined,
+  poolSize: number,
+  options: Options
+): Linter;
 /**
+ * @param {string|undefined} key
  * @param {Options} options
  * @returns {Linter}
  */
-export default function getESLint({ threads, ...options }: Options): Linter;
+export default function getESLint(
+  key: string | undefined,
+  { threads, ...options }: Options
+): Linter;
 export type ESLint = import('eslint').ESLint;
 export type LintResult = import('eslint').ESLint.LintResult;
 export type Options = import('./options').PluginOptions &

declarations/index.d.ts

@@ -17,6 +17,7 @@ declare class ESLintWebpackPlugin {
    * @returns {void}
    */
   apply(compiler: Compiler): void;
+  key: string | undefined;
   /**
    *
    * @param {Compiler} compiler

declarations/linter.d.ts

@@ -1,9 +1,11 @@
 /**
+ * @param {string|undefined} key
  * @param {Options} options
  * @param {Compilation} compilation
  * @returns {{lint: Linter, report: Reporter}}
  */
 export default function linter(
+  key: string | undefined,
   options: Options,
   compilation: Compilation
 ): {

src/getESLint.js

@@ -47,12 +47,13 @@ export function loadESLint(options) {
 }
 
 /**
+ * @param {string|undefined} key
  * @param {number} poolSize
  * @param {Options} options
  * @returns {Linter}
  */
-export function loadESLintThreaded(poolSize, options) {
-  const key = getCacheKey(options);
+export function loadESLintThreaded(key, poolSize, options) {
+  const cacheKey = getCacheKey(key, options);
   const { eslintPath = 'eslint' } = options;
   const source = require.resolve('./worker');
   const workerOptions = {
@@ -75,7 +76,7 @@ export function loadESLintThreaded(poolSize, options) {
       (worker && (await worker.lintFiles(files))) ||
       /* istanbul ignore next */ [],
     cleanup: async () => {
-      cache[key] = local;
+      cache[cacheKey] = local;
       context.lintFiles = (files) => local.lintFiles(files);
       if (worker) {
         worker.end();
@@ -88,10 +89,11 @@ export function loadESLintThreaded(poolSize, options) {
 }
 
 /**
+ * @param {string|undefined} key
  * @param {Options} options
  * @returns {Linter}
  */
-export default function getESLint({ threads, ...options }) {
+export default function getESLint(key, { threads, ...options }) {
   const max =
     typeof threads !== 'number'
       ? threads
@@ -100,18 +102,19 @@ export default function getESLint({ threads, ...options }) {
       : /* istanbul ignore next */
         threads;
 
-  const key = getCacheKey({ threads, ...options });
-  if (!cache[key]) {
-    cache[key] =
-      max > 1 ? loadESLintThreaded(max, options) : loadESLint(options);
+  const cacheKey = getCacheKey(key, { threads, ...options });
+  if (!cache[cacheKey]) {
+    cache[cacheKey] =
+      max > 1 ? loadESLintThreaded(key, max, options) : loadESLint(options);
   }
-  return cache[key];
+  return cache[cacheKey];
 }
 
 /**
+ * @param {string|undefined} key
  * @param {Options} options
  * @returns {string}
  */
-function getCacheKey(options) {
-  return JSON.stringify(options, jsonStringifyReplacerSortKeys);
+function getCacheKey(key, options) {
+  return JSON.stringify({ key, options }, jsonStringifyReplacerSortKeys);
 }

src/index.js

@@ -13,6 +13,7 @@ import { parseFiles, parseFoldersToGlobs } from './utils';
 /** @typedef {import('./options').Options} Options */
 
 const ESLINT_PLUGIN = 'ESLintWebpackPlugin';
+let counter = 0;
 
 class ESLintWebpackPlugin {
   /**
@@ -28,6 +29,12 @@ class ESLintWebpackPlugin {
    * @returns {void}
    */
   apply(compiler) {
+    // Generate key for each compilation,
+    // this differentiates one from the other when being cached.
+    this.key = compiler.name || `${ESLINT_PLUGIN}_${(counter += 1)}`;
+
+    // If `lintDirtyModulesOnly` is disabled,
+    // execute the linter on the build
     if (!this.options.lintDirtyModulesOnly) {
       compiler.hooks.run.tapPromise(ESLINT_PLUGIN, this.run);
     }
@@ -36,7 +43,16 @@ class ESLintWebpackPlugin {
     // From my testing of compiler.watch() ... compiler.watching is always
     // undefined (webpack 4 doesn't define it either) I'm leaving it out
     // for now.
-    compiler.hooks.watchRun.tapPromise(ESLINT_PLUGIN, this.run);
+    let isFirstRun = this.options.lintDirtyModulesOnly;
+    compiler.hooks.watchRun.tapPromise(ESLINT_PLUGIN, (c) => {
+      if (isFirstRun) {
+        isFirstRun = false;
+
+        return Promise.resolve();
+      }
+
+      return this.run(c);
+    });
   }
 
   /**
@@ -74,7 +90,7 @@ class ESLintWebpackPlugin {
       let report;
 
       try {
-        ({ lint, report } = linter(options, compilation));
+        ({ lint, report } = linter(this.key, options, compilation));
       } catch (e) {
         compilation.errors.push(e);
         return;
@@ -83,7 +99,7 @@ class ESLintWebpackPlugin {
       // @ts-ignore
       const processModule = (module) => {
         if (module.resource) {
-          const file = module.resource.split('?')[0];
+          const [file] = module.resource.split('?');
 
           if (
             file &&

src/linter.js

@@ -21,11 +21,12 @@ import getESLint from './getESLint';
 const resultStorage = new WeakMap();
 
 /**
+ * @param {string|undefined} key
  * @param {Options} options
  * @param {Compilation} compilation
  * @returns {{lint: Linter, report: Reporter}}
  */
-export default function linter(options, compilation) {
+export default function linter(key, options, compilation) {
   /** @type {ESLint} */
   let eslint;
 
@@ -41,7 +42,7 @@ export default function linter(options, compilation) {
   const crossRunResultStorage = getResultStorage(compilation);
 
   try {
-    ({ eslint, lintFiles, cleanup } = getESLint(options));
+    ({ eslint, lintFiles, cleanup } = getESLint(key, options));
   } catch (e) {
     throw new ESLintError(e.message);
   }
@@ -177,29 +178,48 @@ function formatResults(formatter, results) {
  */
 function parseResults(options, results) {
   /** @type {LintResult[]} */
-  let errors = [];
+  const errors = [];
 
   /** @type {LintResult[]} */
-  let warnings = [];
-
-  if (options.emitError) {
-    errors = results.filter(
-      (file) => fileHasErrors(file) || fileHasWarnings(file)
-    );
-  } else if (options.emitWarning) {
-    warnings = results.filter(
-      (file) => fileHasErrors(file) || fileHasWarnings(file)
-    );
-  } else {
-    warnings = results.filter(
-      (file) => !fileHasErrors(file) && fileHasWarnings(file)
-    );
-    errors = results.filter(fileHasErrors);
-  }
+  const warnings = [];
+
+  results.forEach((file) => {
+    if (fileHasErrors(file)) {
+      const messages = file.messages.filter((message) => {
+        if (options.emitError === undefined) {
+          return true;
+        } else if (options.emitError) {
+          return message.severity === 2;
+        }
+        return false;
+      });
+
+      if (messages.length > 0) {
+        errors.push({
+          ...file,
+          messages,
+        });
+      }
+    }
 
-  if (options.quiet && warnings.length > 0) {
-    warnings = [];
-  }
+    if (fileHasWarnings(file)) {
+      const messages = file.messages.filter((message) => {
+        if (options.emitWarning === undefined) {
+          return true;
+        } else if (options.emitWarning) {
+          return message.severity === 1;
+        }
+        return false;
+      });
+
+      if (messages.length > 0) {
+        warnings.push({
+          ...file,
+          messages,
+        });
+      }
+    }
+  });
 
   return {
     errors,

src/options.js

@@ -49,6 +49,7 @@ export function getOptions(pluginOptions) {
   const options = {
     extensions: 'js',
     ...pluginOptions,
+    ...(pluginOptions.quiet ? { emitError: true, emitWarning: false } : {}),
   };
 
   // @ts-ignore

test/emit-error.test.js

@@ -0,0 +1,58 @@
+import pack from './utils/pack';
+
+describe('emit error', () => {
+  it('should not emit errors if emitError is false', (done) => {
+    const compiler = pack('error', { emitError: false });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasErrors()).toBe(false);
+      done();
+    });
+  });
+
+  it('should emit errors if emitError is undefined', (done) => {
+    const compiler = pack('error', {});
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasErrors()).toBe(true);
+      done();
+    });
+  });
+
+  it('should emit errors if emitError is true', (done) => {
+    const compiler = pack('error', { emitError: true });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasErrors()).toBe(true);
+      done();
+    });
+  });
+
+  it('should emit errors, but not warnings if emitError is true and emitWarning is false', (done) => {
+    const compiler = pack('full-of-problems', {
+      emitError: true,
+      emitWarning: false,
+    });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasWarnings()).toBe(false);
+      expect(stats.hasErrors()).toBe(true);
+      done();
+    });
+  });
+
+  it('should emit errors and warnings if emitError is true and emitWarning is undefined', (done) => {
+    const compiler = pack('full-of-problems', { emitError: true });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasWarnings()).toBe(true);
+      expect(stats.hasErrors()).toBe(true);
+      done();
+    });
+  });
+});

test/emit-warning.test.js

@@ -0,0 +1,58 @@
+import pack from './utils/pack';
+
+describe('emit warning', () => {
+  it('should not emit warnings if emitWarning is false', (done) => {
+    const compiler = pack('warn', { emitWarning: false });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasWarnings()).toBe(false);
+      done();
+    });
+  });
+
+  it('should emit warnings if emitWarning is undefined', (done) => {
+    const compiler = pack('warn', {});
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasWarnings()).toBe(true);
+      done();
+    });
+  });
+
+  it('should emit warnings if emitWarning is true', (done) => {
+    const compiler = pack('warn', { emitWarning: true });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasWarnings()).toBe(true);
+      done();
+    });
+  });
+
+  it('should emit warnings, but not warnings if emitWarning is true and emitError is false', (done) => {
+    const compiler = pack('full-of-problems', {
+      emitWarning: true,
+      emitError: false,
+    });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasWarnings()).toBe(true);
+      expect(stats.hasErrors()).toBe(false);
+      done();
+    });
+  });
+
+  it('should emit warnings and errors if emitWarning is true and emitError is undefined', (done) => {
+    const compiler = pack('full-of-problems', { emitWarning: true });
+
+    compiler.run((err, stats) => {
+      expect(err).toBeNull();
+      expect(stats.hasWarnings()).toBe(true);
+      expect(stats.hasErrors()).toBe(true);
+      done();
+    });
+  });
+});