refactor: simplify dirty file linting

Refactor LintDirtyModulesPlugin to only handle dirty file filtering.
The refactor allows for easier testing without the need for mocks.
Rename LintDirtyModulesPlugin to DirtyFileWatcher to make the name more
descriptive of the new functionality.

Refactor the tests for the simplified DirtyFileWatcher.
Refactor the tests to use absolute paths because Webpack passes absolute paths
in the compiler.fileTimestamps map.

Refactor to only test system specific paths. The functionality of the requested
change (webpack#11) requires using real paths for some tests which causes issues with
testing both Windows and Unix paths on the same machine.
As the CI runs on Windows, Mac and Linux paths will be tested on all platforms.

Preparation for requested change in webpack#11.

Author: LKummer

src/LintDirtyModulesPlugin.js renamed to src/DirtyFileWatcher.js

@@ -1,41 +1,32 @@
 import { isMatch } from 'micromatch';
 
-import linter from './linter';
-
-export default class LintDirtyModulesPlugin {
-  constructor(compiler, options) {
-    this.compiler = compiler;
-    this.options = options;
+export default class DirtyFileWatcher {
+  constructor({ files = [] }) {
+    this.patterns = files;
     this.startTime = Date.now();
     this.prevTimestamps = {};
     this.isFirstRun = true;
   }
 
-  apply(compilation, callback) {
-    const fileTimestamps = compilation.fileTimestamps || new Map();
-
+  getDirtyFiles({ fileTimestamps = new Map() }) {
     if (this.isFirstRun) {
       this.isFirstRun = false;
       this.prevTimestamps = fileTimestamps;
-      callback();
-      return;
+      return [];
+    }
+    if (this.patterns.length <= 0 || fileTimestamps.length <= 0) {
+      return [];
     }
 
-    const dirtyOptions = { ...this.options };
-    const glob = dirtyOptions.files.join('|').replace(/\\/g, '/');
-    const changedFiles = this.getChangedFiles(fileTimestamps, glob);
+    const glob = this.patterns.join('|').replace(/\\/g, '/');
+    const changedFiles = this.filterChangedFiles(fileTimestamps, glob);
 
     this.prevTimestamps = fileTimestamps;
 
-    if (changedFiles.length) {
-      dirtyOptions.files = changedFiles;
-      linter(dirtyOptions, this.compiler, callback);
-    } else {
-      callback();
-    }
+    return changedFiles;
   }
 
-  getChangedFiles(fileTimestamps, glob) {
+  filterChangedFiles(fileTimestamps, glob) {
     const getTimestamps = (fileSystemInfoEntry) => {
       return fileSystemInfoEntry && fileSystemInfoEntry.timestamp
         ? fileSystemInfoEntry.timestamp

src/index.js

@@ -3,7 +3,7 @@ import { isAbsolute, join } from 'path';
 import arrify from 'arrify';
 
 import { getOptions } from './options';
-import LintDirtyModulesPlugin from './LintDirtyModulesPlugin';
+import DirtyFileWatcher from './DirtyFileWatcher';
 import linter from './linter';
 
 class ESLintWebpackPlugin {
@@ -22,20 +22,23 @@ class ESLintWebpackPlugin {
     const plugin = { name: this.constructor.name };
 
     if (options.lintDirtyModulesOnly) {
-      const lintDirty = new LintDirtyModulesPlugin(compiler, options);
+      const dirtyFileWatcher = new DirtyFileWatcher(options);
 
       /* istanbul ignore next */
-      compiler.hooks.watchRun.tapAsync(plugin, (compilation, callback) => {
-        lintDirty.apply(compilation, callback);
+      compiler.hooks.watchRun.tapPromise(plugin, async (runCompiler) => {
+        const files = dirtyFileWatcher.getDirtyFiles(runCompiler);
+        if (files.length > 0) {
+          await linter({ ...options, files }, runCompiler);
+        }
       });
     } else {
-      compiler.hooks.run.tapPromise(plugin, (compilation) => {
-        return linter(options, compilation);
+      compiler.hooks.run.tapPromise(plugin, (runCompiler) => {
+        return linter(options, runCompiler);
       });
 
       /* istanbul ignore next */
-      compiler.hooks.watchRun.tapPromise(plugin, (compilation) => {
-        return linter(options, compilation);
+      compiler.hooks.watchRun.tapPromise(plugin, (runCompiler) => {
+        return linter(options, runCompiler);
       });
     }
   }

test/LintDirtyModulesPlugin.test.js

@@ -0,0 +1,108 @@
+import { resolve } from 'path';
+
+import DirtyFileWatcher from '../src/DirtyFileWatcher';
+
+describe('dirty file watcher', () => {
+  const fixtures = resolve(__dirname, 'fixtures');
+
+  it('returns empty on initial run', () => {
+    const watcher = new DirtyFileWatcher({
+      files: ['**/*'],
+    });
+
+    const dirtyFiles = watcher.getDirtyFiles({
+      fileTimestamps: new Map([
+        ['/hello/world.js', { timestamp: Number.MAX_VALUE }],
+      ]),
+    });
+
+    expect(dirtyFiles).toHaveLength(0);
+  });
+
+  it('returns changed files', () => {
+    const watcher = new DirtyFileWatcher({
+      files: ['**/*'],
+    });
+
+    const insideFolder = resolve(fixtures, 'folder/unix.js');
+    const changed = resolve(fixtures, 'changed.js');
+    const unchagned = resolve(fixtures, 'unchanged.js');
+
+    watcher.getDirtyFiles({
+      fileTimestamps: new Map([
+        [insideFolder, { timestamp: 1 }],
+        [changed, { timestamp: 1 }],
+        [unchagned, { timestamp: 1 }],
+      ]),
+    });
+    const dirtyFiles = watcher.getDirtyFiles({
+      fileTimestamps: new Map([
+        [insideFolder, { timestamp: 2 }],
+        [changed, { timestamp: 2 }],
+        [unchagned, { timestamp: 1 }],
+      ]),
+    });
+
+    expect(dirtyFiles).toHaveLength(2);
+    expect(dirtyFiles).toContain(insideFolder);
+    expect(dirtyFiles).toContain(changed);
+  });
+
+  it('returns new files', () => {
+    const watcher = new DirtyFileWatcher({
+      files: ['**/*'],
+    });
+
+    const created = resolve(fixtures, 'created.js');
+
+    watcher.getDirtyFiles({});
+    const dirtyFiles = watcher.getDirtyFiles({
+      fileTimestamps: new Map([[created, { timestamp: Number.MAX_VALUE }]]),
+    });
+
+    expect(dirtyFiles).toHaveLength(1);
+    expect(dirtyFiles).toContain(created);
+  });
+
+  it('returns file if it does not have a timestamp', () => {
+    const watcher = new DirtyFileWatcher({
+      files: ['**/*'],
+    });
+
+    const noTimestamp = resolve(fixtures, 'no-timestamp.js');
+
+    watcher.getDirtyFiles({});
+    const dirtyFiles = watcher.getDirtyFiles({
+      fileTimestamps: new Map([[noTimestamp]]),
+    });
+
+    expect(dirtyFiles).toHaveLength(1);
+    expect(dirtyFiles).toContain(noTimestamp);
+  });
+
+  it('returns no files when options.files is empty', () => {
+    const watcher = new DirtyFileWatcher({});
+
+    const changed = resolve(fixtures, 'changed.js');
+
+    watcher.getDirtyFiles({
+      fileTimestamps: new Map([[changed, 1]]),
+    });
+    const dirtyFiles = watcher.getDirtyFiles({
+      fileTimestamps: new Map([[changed, 2]]),
+    });
+
+    expect(dirtyFiles).toHaveLength(0);
+  });
+
+  it('does not throw when timestamps are unavailable', () => {
+    const watcher = new DirtyFileWatcher({
+      files: ['**/*'],
+    });
+
+    watcher.getDirtyFiles({});
+    const dirtyFiles = watcher.getDirtyFiles({});
+
+    expect(dirtyFiles).toHaveLength(0);
+  });
+});