.github/full_changelog.md

@@ -1,3 +1,6 @@
+### Chokidar 3.4.1 (Jul 16, 2020)
+* Fixes a bug when after a watcher was closed, files were not watched properly on new watch.
+
 ### Chokidar 3.4.0 (Apr 26, 2020)
 * Support for directory-based symlinks.
 * Fix a case on macos when replacing a file with a dir of the same name

README.md

@@ -253,9 +253,9 @@ Available events: `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `ready`,
 `raw`, `error`.
 Additionally `all` is available which gets emitted with the underlying event
 name and path for every event other than `ready`, `raw`, and `error`.  `raw` is internal, use it carefully.
-* `.unwatch(path / paths)`: **async** Stop watching files, directories, or glob patterns.
+* `.unwatch(path / paths)`: Stop watching files, directories, or glob patterns.
 Takes an array of strings or just one string. Use with `await` to ensure bugs don't happen.
-* `.close()`: Removes all listeners from watched files. Asynchronous, returns Promise.
+* `.close()`: **async** Removes all listeners from watched files. Asynchronous, returns Promise.
 * `.getWatched()`: Returns an object representing all the paths on the file
 system being watched by this `FSWatcher` instance. The object's keys are all the
 directories (using absolute paths unless the `cwd` option was used), and the
@@ -295,6 +295,12 @@ For more detailed changelog, see [`full_changelog.md`](.github/full_changelog.md
 - **v1 (Apr 7, 2015):** Glob support, symlink support, tons of bugfixes. Node 0.8+ is supported
 - **v0.1 (Apr 20, 2012):** Initial release, extracted from [Brunch](https://github.com/brunch/brunch/blob/9847a065aea300da99bd0753f90354cde9de1261/src/helpers.coffee#L66)
 
+## Also
+
+Why was chokidar named this way? What's the meaning behind it?
+
+>Chowkidar is a transliteration of a Hindi word meaning 'watchman, gatekeeper', चौकीदार. This ultimately comes from Sanskrit _ चतुष्क_ (crossway, quadrangle, consisting-of-four).
+
 ## License
 
 MIT (c) Paul Miller (<https://paulmillr.com>), see [LICENSE](LICENSE) file.

index.js

@@ -876,16 +876,24 @@ _remove(directory, item, isDirectory) {
 }
 
 /**
- *
+ * Closes all watchers for a path
  * @param {Path} path
  */
 _closePath(path) {
+  this._closeFile(path)
+  const dir = sysPath.dirname(path);
+  this._getWatchedDir(dir).remove(sysPath.basename(path));
+}
+
+/**
+ * Closes only file-specific watchers
+ * @param {Path} path
+ */
+_closeFile(path) {
   const closers = this._closers.get(path);
   if (!closers) return;
   closers.forEach(closer => closer());
   this._closers.delete(path);
-  const dir = sysPath.dirname(path);
-  this._getWatchedDir(dir).remove(sysPath.basename(path));
 }
 
 /**

lib/constants.js

@@ -59,3 +59,4 @@ exports.IDENTITY_FN = val => val;
 
 exports.isWindows = platform === 'win32';
 exports.isMacos = platform === 'darwin';
+exports.isLinux = platform === 'linux';

lib/fsevents-handler.js

@@ -103,7 +103,7 @@ const createFSEventsInstance = (path, callback) => {
  * @param {Function} rawEmitter - passes data to listeners of the 'raw' event
  * @returns {Function} closer
  */
-function setFSEventsListener(path, realPath, listener, rawEmitter, fsw) {
+function setFSEventsListener(path, realPath, listener, rawEmitter) {
   let watchPath = sysPath.extname(path) ? sysPath.dirname(path) : path;
   const parentPath = sysPath.dirname(watchPath);
   let cont = FSEventsWatchers.get(watchPath);
@@ -146,7 +146,7 @@ function setFSEventsListener(path, realPath, listener, rawEmitter, fsw) {
       listeners: new Set([filteredListener]),
       rawEmitter,
       watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
-        if (fsw.closed) return;
+        if (!cont.listeners.size) return;
         const info = fsevents.getInfo(fullPath, flags);
         cont.listeners.forEach(list => {
           list(fullPath, flags, info);
@@ -353,8 +353,7 @@ _watchWithFsEvents(watchPath, realPath, transform, globFilter) {
     watchPath,
     realPath,
     watchCallback,
-    this.fsw._emitRaw,
-    this.fsw
+    this.fsw._emitRaw
   );
 
   this.fsw._emitReady();

lib/nodefs-handler.js

@@ -6,6 +6,7 @@ const { promisify } = require('util');
 const isBinaryPath = require('is-binary-path');
 const {
   isWindows,
+  isLinux,
   EMPTY_FN,
   EMPTY_STR,
   KEY_LISTENERS,
@@ -356,8 +357,7 @@ _handleFile(file, stats, initialAdd) {
   // if the file is already being watched, do nothing
   if (parent.has(basename)) return;
 
-  // kick off the watcher
-  const closer = this._watchWithNodeFs(file, async (path, newStats) => {
+  const listener = async (path, newStats) => {
     if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5)) return;
     if (!newStats || newStats.mtimeMs === 0) {
       try {
@@ -369,12 +369,18 @@ _handleFile(file, stats, initialAdd) {
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
           this.fsw._emit(EV_CHANGE, file, newStats);
         }
-        prevStats = newStats;
+        if (isLinux && prevStats.ino !== newStats.ino) {
+          this.fsw._closeFile(path)
+          prevStats = newStats;
+          this.fsw._addPathCloser(path, this._watchWithNodeFs(file, listener));
+        } else {
+          prevStats = newStats;
+        }
       } catch (error) {
         // Fix issues where mtime is null but file is still present
         this.fsw._remove(dirname, basename);
       }
-    // add is about to be emitted if file not already tracked in parent
+      // add is about to be emitted if file not already tracked in parent
     } else if (parent.has(basename)) {
       // Check that change event was not fired because of changed only accessTime.
       const at = newStats.atimeMs;
@@ -384,7 +390,9 @@ _handleFile(file, stats, initialAdd) {
       }
       prevStats = newStats;
     }
-  });
+  }
+  // kick off the watcher
+  const closer = this._watchWithNodeFs(file, listener);
 
   // emit an add event if we're supposed to
   if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "chokidar",
   "description": "A neat wrapper around node.js fs.watch / fs.watchFile / fsevents.",
-  "version": "3.4.0",
+  "version": "3.4.1",
   "homepage": "https://github.com/paulmillr/chokidar",
   "author": "Paul Miller (https://paulmillr.com)",
   "contributors": [
@@ -25,10 +25,10 @@
     "fsevents": "~2.1.2"
   },
   "devDependencies": {
-    "@types/node": "^13",
+    "@types/node": "^14",
     "chai": "^4.2",
     "dtslint": "^3.3.0",
-    "eslint": "^6.6.0",
+    "eslint": "^7.0.0",
     "mocha": "^7.0.0",
     "nyc": "^15.0.0",
     "rimraf": "^3.0.0",

test.js

@@ -600,6 +600,27 @@ const runTests = (baseopts) => {
       spy.should.have.always.been.calledWith(EV_ADD, testPath);
     });
 
+    it('should detect safe-edit', async () => {
+      const testPath = getFixturePath('change.txt');
+      const safePath = getFixturePath('tmp.txt');
+      await write(testPath, dateNow());
+      const watcher = chokidar_watch(testPath, options);
+      const spy = await aspy(watcher, EV_ALL);
+
+      await delay();
+      await write(safePath, dateNow());
+      await fs_rename(safePath, testPath);
+      await delay(100);
+      await write(safePath, dateNow());
+      await fs_rename(safePath, testPath);
+      await delay(100);
+      await write(safePath, dateNow());
+      await fs_rename(safePath, testPath);
+      await waitFor([spy]);
+      spy.withArgs(EV_CHANGE, testPath).should.have.been.calledThrice;
+    });
+
+
     // PR 682 is failing.
     describe.skip('Skipping gh-682: should detect unlink', () => {
       it('should detect unlink while watching a non-existent second file in another directory', async () => {
@@ -1007,6 +1028,7 @@ const runTests = (baseopts) => {
       const watcher = chokidar_watch(watchPaths, options);
       const spy = await aspy(watcher, EV_ALL);
 
+      await waitFor([spy.withArgs(EV_ADD_DIR)]);
       spy.should.have.been.calledWith(EV_ADD_DIR, getFixturePath('subdir'));
       spy.withArgs(EV_ADD_DIR).should.have.been.calledOnce;
       fs.mkdirSync(deepDir, PERM_ARR);
@@ -1962,6 +1984,31 @@ const runTests = (baseopts) => {
         })();
       });
     });
+    it('should not ignore further events on close with existing watchers', async () => {
+      return new Promise((resolve) => {
+        const watcher1 = chokidar_watch(currentDir);
+        const watcher2 = chokidar_watch(currentDir);
+        // The EV_ADD event should be called on the second watcher even if the first watcher is closed
+        watcher2.on(EV_ADD, () => {
+          watcher2.on(EV_ADD, (path) => {
+            if (path.endsWith('add.txt')) {
+              resolve();
+            }
+          })
+        });
+        (async () => {
+          await waitForWatcher(watcher1);
+          await waitForWatcher(watcher2);
+          // Watcher 1 is closed to ensure events only happen on watcher 2
+          await watcher1.close();
+          // Write a new file into the fixtures to test the EV_ADD event
+          await write(getFixturePath('add.txt'), 'hello');
+          // Ensures EV_ADD is called. Immediately removing the file causes it to be skipped
+          await delay(200);
+          await fs_unlink(getFixturePath('add.txt'));
+        })()
+      })
+    });
     it('should not prevent the process from exiting', async () => {
       const scriptFile = getFixturePath('script.js');
       const scriptContent = `