| 'use strict'; |
| |
| var fs = require('fs'); |
| var sysPath = require('path'); |
| var readdirp = require('readdirp'); |
| var fsevents; |
| try { fsevents = require('fsevents'); } catch (error) { |
| if (process.env.CHOKIDAR_PRINT_FSEVENTS_REQUIRE_ERROR) console.error(error) |
| } |
| |
| // fsevents instance helper functions |
| |
| // object to hold per-process fsevents instances |
| // (may be shared across chokidar FSWatcher instances) |
| var FSEventsWatchers = Object.create(null); |
| |
| // Threshold of duplicate path prefixes at which to start |
| // consolidating going forward |
| var consolidateThreshhold = 10; |
| |
| // Private function: Instantiates the fsevents interface |
| |
| // * path - string, path to be watched |
| // * callback - function, called when fsevents is bound and ready |
| |
| // Returns new fsevents instance |
| function createFSEventsInstance(path, callback) { |
| return (new fsevents(path)).on('fsevent', callback).start(); |
| } |
| |
| // Private function: Instantiates the fsevents interface or binds listeners |
| // to an existing one covering the same file tree |
| |
| // * path - string, path to be watched |
| // * realPath - string, real path (in case of symlinks) |
| // * listener - function, called when fsevents emits events |
| // * rawEmitter - function, passes data to listeners of the 'raw' event |
| |
| // Returns close function |
| function setFSEventsListener(path, realPath, listener, rawEmitter) { |
| var watchPath = sysPath.extname(path) ? sysPath.dirname(path) : path; |
| var watchContainer; |
| var parentPath = sysPath.dirname(watchPath); |
| |
| // If we've accumulated a substantial number of paths that |
| // could have been consolidated by watching one directory |
| // above the current one, create a watcher on the parent |
| // path instead, so that we do consolidate going forward. |
| if (couldConsolidate(parentPath)) { |
| watchPath = parentPath; |
| } |
| |
| var resolvedPath = sysPath.resolve(path); |
| var hasSymlink = resolvedPath !== realPath; |
| function filteredListener(fullPath, flags, info) { |
| if (hasSymlink) fullPath = fullPath.replace(realPath, resolvedPath); |
| if ( |
| fullPath === resolvedPath || |
| !fullPath.indexOf(resolvedPath + sysPath.sep) |
| ) listener(fullPath, flags, info); |
| } |
| |
| // check if there is already a watcher on a parent path |
| // modifies `watchPath` to the parent path when it finds a match |
| function watchedParent() { |
| return Object.keys(FSEventsWatchers).some(function(watchedPath) { |
| // condition is met when indexOf returns 0 |
| if (!realPath.indexOf(sysPath.resolve(watchedPath) + sysPath.sep)) { |
| watchPath = watchedPath; |
| return true; |
| } |
| }); |
| } |
| |
| if (watchPath in FSEventsWatchers || watchedParent()) { |
| watchContainer = FSEventsWatchers[watchPath]; |
| watchContainer.listeners.push(filteredListener); |
| } else { |
| watchContainer = FSEventsWatchers[watchPath] = { |
| listeners: [filteredListener], |
| rawEmitters: [rawEmitter], |
| watcher: createFSEventsInstance(watchPath, function(fullPath, flags) { |
| var info = fsevents.getInfo(fullPath, flags); |
| watchContainer.listeners.forEach(function(listener) { |
| listener(fullPath, flags, info); |
| }); |
| watchContainer.rawEmitters.forEach(function(emitter) { |
| emitter(info.event, fullPath, info); |
| }); |
| }) |
| }; |
| } |
| var listenerIndex = watchContainer.listeners.length - 1; |
| |
| // removes this instance's listeners and closes the underlying fsevents |
| // instance if there are no more listeners left |
| return function close() { |
| delete watchContainer.listeners[listenerIndex]; |
| delete watchContainer.rawEmitters[listenerIndex]; |
| if (!Object.keys(watchContainer.listeners).length) { |
| watchContainer.watcher.stop(); |
| delete FSEventsWatchers[watchPath]; |
| } |
| }; |
| } |
| |
| // Decide whether or not we should start a new higher-level |
| // parent watcher |
| function couldConsolidate(path) { |
| var keys = Object.keys(FSEventsWatchers); |
| var count = 0; |
| |
| for (var i = 0, len = keys.length; i < len; ++i) { |
| var watchPath = keys[i]; |
| if (watchPath.indexOf(path) === 0) { |
| count++; |
| if (count >= consolidateThreshhold) { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| // returns boolean indicating whether fsevents can be used |
| function canUse() { |
| return fsevents && Object.keys(FSEventsWatchers).length < 128; |
| } |
| |
| // determines subdirectory traversal levels from root to path |
| function depth(path, root) { |
| var i = 0; |
| while (!path.indexOf(root) && (path = sysPath.dirname(path)) !== root) i++; |
| return i; |
| } |
| |
| // fake constructor for attaching fsevents-specific prototype methods that |
| // will be copied to FSWatcher's prototype |
| function FsEventsHandler() {} |
| |
| // Private method: Handle symlinks encountered during directory scan |
| |
| // * watchPath - string, file/dir path to be watched with fsevents |
| // * realPath - string, real path (in case of symlinks) |
| // * transform - function, path transformer |
| // * globFilter - function, path filter in case a glob pattern was provided |
| |
| // Returns close function for the watcher instance |
| FsEventsHandler.prototype._watchWithFsEvents = |
| function(watchPath, realPath, transform, globFilter) { |
| if (this._isIgnored(watchPath)) return; |
| var watchCallback = function(fullPath, flags, info) { |
| if ( |
| this.options.depth !== undefined && |
| depth(fullPath, realPath) > this.options.depth |
| ) return; |
| var path = transform(sysPath.join( |
| watchPath, sysPath.relative(watchPath, fullPath) |
| )); |
| if (globFilter && !globFilter(path)) return; |
| // ensure directories are tracked |
| var parent = sysPath.dirname(path); |
| var item = sysPath.basename(path); |
| var watchedDir = this._getWatchedDir( |
| info.type === 'directory' ? path : parent |
| ); |
| var checkIgnored = function(stats) { |
| if (this._isIgnored(path, stats)) { |
| this._ignoredPaths[path] = true; |
| if (stats && stats.isDirectory()) { |
| this._ignoredPaths[path + '/**/*'] = true; |
| } |
| return true; |
| } else { |
| delete this._ignoredPaths[path]; |
| delete this._ignoredPaths[path + '/**/*']; |
| } |
| }.bind(this); |
| |
| var handleEvent = function(event) { |
| if (checkIgnored()) return; |
| |
| if (event === 'unlink') { |
| // suppress unlink events on never before seen files |
| if (info.type === 'directory' || watchedDir.has(item)) { |
| this._remove(parent, item); |
| } |
| } else { |
| if (event === 'add') { |
| // track new directories |
| if (info.type === 'directory') this._getWatchedDir(path); |
| |
| if (info.type === 'symlink' && this.options.followSymlinks) { |
| // push symlinks back to the top of the stack to get handled |
| var curDepth = this.options.depth === undefined ? |
| undefined : depth(fullPath, realPath) + 1; |
| return this._addToFsEvents(path, false, true, curDepth); |
| } else { |
| // track new paths |
| // (other than symlinks being followed, which will be tracked soon) |
| this._getWatchedDir(parent).add(item); |
| } |
| } |
| var eventName = info.type === 'directory' ? event + 'Dir' : event; |
| this._emit(eventName, path); |
| if (eventName === 'addDir') this._addToFsEvents(path, false, true); |
| } |
| }.bind(this); |
| |
| function addOrChange() { |
| handleEvent(watchedDir.has(item) ? 'change' : 'add'); |
| } |
| function checkFd() { |
| fs.open(path, 'r', function(error, fd) { |
| if (error) { |
| error.code !== 'EACCES' ? |
| handleEvent('unlink') : addOrChange(); |
| } else { |
| fs.close(fd, function(err) { |
| err && err.code !== 'EACCES' ? |
| handleEvent('unlink') : addOrChange(); |
| }); |
| } |
| }); |
| } |
| // correct for wrong events emitted |
| var wrongEventFlags = [ |
| 69888, 70400, 71424, 72704, 73472, 131328, 131840, 262912 |
| ]; |
| if (wrongEventFlags.indexOf(flags) !== -1 || info.event === 'unknown') { |
| if (typeof this.options.ignored === 'function') { |
| fs.stat(path, function(error, stats) { |
| if (checkIgnored(stats)) return; |
| stats ? addOrChange() : handleEvent('unlink'); |
| }); |
| } else { |
| checkFd(); |
| } |
| } else { |
| switch (info.event) { |
| case 'created': |
| case 'modified': |
| return addOrChange(); |
| case 'deleted': |
| case 'moved': |
| return checkFd(); |
| } |
| } |
| }.bind(this); |
| |
| var closer = setFSEventsListener( |
| watchPath, |
| realPath, |
| watchCallback, |
| this.emit.bind(this, 'raw') |
| ); |
| |
| this._emitReady(); |
| return closer; |
| }; |
| |
| // Private method: Handle symlinks encountered during directory scan |
| |
| // * linkPath - string, path to symlink |
| // * fullPath - string, absolute path to the symlink |
| // * transform - function, pre-existing path transformer |
| // * curDepth - int, level of subdirectories traversed to where symlink is |
| |
| // Returns nothing |
| FsEventsHandler.prototype._handleFsEventsSymlink = |
| function(linkPath, fullPath, transform, curDepth) { |
| // don't follow the same symlink more than once |
| if (this._symlinkPaths[fullPath]) return; |
| else this._symlinkPaths[fullPath] = true; |
| |
| this._readyCount++; |
| |
| fs.realpath(linkPath, function(error, linkTarget) { |
| if (this._handleError(error) || this._isIgnored(linkTarget)) { |
| return this._emitReady(); |
| } |
| |
| this._readyCount++; |
| |
| // add the linkTarget for watching with a wrapper for transform |
| // that causes emitted paths to incorporate the link's path |
| this._addToFsEvents(linkTarget || linkPath, function(path) { |
| var dotSlash = '.' + sysPath.sep; |
| var aliasedPath = linkPath; |
| if (linkTarget && linkTarget !== dotSlash) { |
| aliasedPath = path.replace(linkTarget, linkPath); |
| } else if (path !== dotSlash) { |
| aliasedPath = sysPath.join(linkPath, path); |
| } |
| return transform(aliasedPath); |
| }, false, curDepth); |
| }.bind(this)); |
| }; |
| |
| // Private method: Handle added path with fsevents |
| |
| // * path - string, file/directory path or glob pattern |
| // * transform - function, converts working path to what the user expects |
| // * forceAdd - boolean, ensure add is emitted |
| // * priorDepth - int, level of subdirectories already traversed |
| |
| // Returns nothing |
| FsEventsHandler.prototype._addToFsEvents = |
| function(path, transform, forceAdd, priorDepth) { |
| |
| // applies transform if provided, otherwise returns same value |
| var processPath = typeof transform === 'function' ? |
| transform : function(val) { return val; }; |
| |
| var emitAdd = function(newPath, stats) { |
| var pp = processPath(newPath); |
| var isDir = stats.isDirectory(); |
| var dirObj = this._getWatchedDir(sysPath.dirname(pp)); |
| var base = sysPath.basename(pp); |
| |
| // ensure empty dirs get tracked |
| if (isDir) this._getWatchedDir(pp); |
| |
| if (dirObj.has(base)) return; |
| dirObj.add(base); |
| |
| if (!this.options.ignoreInitial || forceAdd === true) { |
| this._emit(isDir ? 'addDir' : 'add', pp, stats); |
| } |
| }.bind(this); |
| |
| var wh = this._getWatchHelpers(path); |
| |
| // evaluate what is at the path we're being asked to watch |
| fs[wh.statMethod](wh.watchPath, function(error, stats) { |
| if (this._handleError(error) || this._isIgnored(wh.watchPath, stats)) { |
| this._emitReady(); |
| return this._emitReady(); |
| } |
| |
| if (stats.isDirectory()) { |
| // emit addDir unless this is a glob parent |
| if (!wh.globFilter) emitAdd(processPath(path), stats); |
| |
| // don't recurse further if it would exceed depth setting |
| if (priorDepth && priorDepth > this.options.depth) return; |
| |
| // scan the contents of the dir |
| readdirp({ |
| root: wh.watchPath, |
| entryType: 'all', |
| fileFilter: wh.filterPath, |
| directoryFilter: wh.filterDir, |
| lstat: true, |
| depth: this.options.depth - (priorDepth || 0) |
| }).on('data', function(entry) { |
| // need to check filterPath on dirs b/c filterDir is less restrictive |
| if (entry.stat.isDirectory() && !wh.filterPath(entry)) return; |
| |
| var joinedPath = sysPath.join(wh.watchPath, entry.path); |
| var fullPath = entry.fullPath; |
| |
| if (wh.followSymlinks && entry.stat.isSymbolicLink()) { |
| // preserve the current depth here since it can't be derived from |
| // real paths past the symlink |
| var curDepth = this.options.depth === undefined ? |
| undefined : depth(joinedPath, sysPath.resolve(wh.watchPath)) + 1; |
| |
| this._handleFsEventsSymlink(joinedPath, fullPath, processPath, curDepth); |
| } else { |
| emitAdd(joinedPath, entry.stat); |
| } |
| }.bind(this)).on('error', function() { |
| // Ignore readdirp errors |
| }).on('end', this._emitReady); |
| } else { |
| emitAdd(wh.watchPath, stats); |
| this._emitReady(); |
| } |
| }.bind(this)); |
| |
| if (this.options.persistent && forceAdd !== true) { |
| var initWatch = function(error, realPath) { |
| if (this.closed) return; |
| var closer = this._watchWithFsEvents( |
| wh.watchPath, |
| sysPath.resolve(realPath || wh.watchPath), |
| processPath, |
| wh.globFilter |
| ); |
| if (closer) { |
| this._closers[path] = this._closers[path] || []; |
| this._closers[path].push(closer); |
| } |
| }.bind(this); |
| |
| if (typeof transform === 'function') { |
| // realpath has already been resolved |
| initWatch(); |
| } else { |
| fs.realpath(wh.watchPath, initWatch); |
| } |
| } |
| }; |
| |
| module.exports = FsEventsHandler; |
| module.exports.canUse = canUse; |