Diffusion SHRINE MedCo Fork (feature/i2b2-merge-to-develop) Browse

shrine-medco/shrine-webclient/src/main/html/node_modules/gaze/lib/gaze.js
f571d119036dfeature/i2b2-merge-to…

gaze.js
View Options

			/*
			* gaze
			* https://github.com/shama/gaze
			*
			* Copyright (c) 2013 Kyle Robinson Young
			* Licensed under the MIT license.
			*/

			'use strict';

			// libs
			var util = require('util');
			var EE = require('events').EventEmitter;
			var fs = require('fs');
			var path = require('path');
			var globule = require('globule');
			var helper = require('./helper');

			// shim setImmediate for node v0.8
			var setImmediate = require('timers').setImmediate;
			if (typeof setImmediate !== 'function') {
			setImmediate = process.nextTick;
			}

			// globals
			var delay = 10;

			// `Gaze` EventEmitter object to return in the callback
			function Gaze(patterns, opts, done) {
			var self = this;
			EE.call(self);

			// If second arg is the callback
			if (typeof opts === 'function') {
			done = opts;
			opts = {};
			}

			// Default options
			opts = opts \|\| {};
			opts.mark = true;
			opts.interval = opts.interval \|\| 100;
			opts.debounceDelay = opts.debounceDelay \|\| 500;
			opts.cwd = opts.cwd \|\| process.cwd();
			this.options = opts;

			// Default done callback
			done = done \|\| function() {};

			// Remember our watched dir:files
			this._watched = Object.create(null);

			// Store watchers
			this._watchers = Object.create(null);

			// Store watchFile listeners
			this._pollers = Object.create(null);

			// Store patterns
			this._patterns = [];

			// Cached events for debouncing
			this._cached = Object.create(null);

			// Set maxListeners
			if (this.options.maxListeners) {
			this.setMaxListeners(this.options.maxListeners);
			Gaze.super_.prototype.setMaxListeners(this.options.maxListeners);
			delete this.options.maxListeners;
			}

			// Initialize the watch on files
			if (patterns) {
			this.add(patterns, done);
			}

			// keep the process alive
			this._keepalive = setInterval(function() {}, 200);

			return this;
			}
			util.inherits(Gaze, EE);

			// Main entry point. Start watching and call done when setup
			module.exports = function gaze(patterns, opts, done) {
			return new Gaze(patterns, opts, done);
			};
			module.exports.Gaze = Gaze;

			// Override the emit function to emit `all` events
			// and debounce on duplicate events per file
			Gaze.prototype.emit = function() {
			var self = this;
			var args = arguments;

			var e = args[0];
			var filepath = args[1];
			var timeoutId;

			// If not added/deleted/changed/renamed then just emit the event
			if (e.slice(-2) !== 'ed') {
			Gaze.super_.prototype.emit.apply(self, args);
			return this;
			}

			// Detect rename event, if added and previous deleted is in the cache
			if (e === 'added') {
			Object.keys(this._cached).forEach(function(oldFile) {
			if (self._cached[oldFile].indexOf('deleted') !== -1) {
			args[0] = e = 'renamed';
			[].push.call(args, oldFile);
			delete self._cached[oldFile];
			return false;
			}
			});
			}

			// If cached doesnt exist, create a delay before running the next
			// then emit the event
			var cache = this._cached[filepath] \|\| [];
			if (cache.indexOf(e) === -1) {
			helper.objectPush(self._cached, filepath, e);
			clearTimeout(timeoutId);
			timeoutId = setTimeout(function() {
			delete self._cached[filepath];
			}, this.options.debounceDelay);
			// Emit the event and `all` event
			Gaze.super_.prototype.emit.apply(self, args);
			Gaze.super_.prototype.emit.apply(self, ['all', e].concat([].slice.call(args, 1)));
			}

			// Detect if new folder added to trigger for matching files within folder
			if (e === 'added') {
			if (helper.isDir(filepath)) {
			fs.readdirSync(filepath).map(function(file) {
			return path.join(filepath, file);
			}).filter(function(file) {
			return globule.isMatch(self._patterns, file, self.options);
			}).forEach(function(file) {
			self.emit('added', file);
			});
			}
			}

			return this;
			};

			// Close watchers
			Gaze.prototype.close = function(_reset) {
			var self = this;
			_reset = _reset === false ? false : true;
			Object.keys(self._watchers).forEach(function(file) {
			self._watchers[file].close();
			});
			self._watchers = Object.create(null);
			Object.keys(this._watched).forEach(function(dir) {
			self._unpollDir(dir);
			});
			if (_reset) {
			self._watched = Object.create(null);
			setTimeout(function() {
			self.emit('end');
			self.removeAllListeners();
			clearInterval(self._keepalive);
			}, delay + 100);
			}
			return self;
			};

			// Add file patterns to be watched
			Gaze.prototype.add = function(files, done) {
			if (typeof files === 'string') { files = [files]; }
			this._patterns = helper.unique.apply(null, [this._patterns, files]);
			files = globule.find(this._patterns, this.options);
			this._addToWatched(files);
			this.close(false);
			this._initWatched(done);
			};

			// Dont increment patterns and dont call done if nothing added
			Gaze.prototype._internalAdd = function(file, done) {
			var files = [];
			if (helper.isDir(file)) {
			files = [helper.markDir(file)].concat(globule.find(this._patterns, this.options));
			} else {
			if (globule.isMatch(this._patterns, file, this.options)) {
			files = [file];
			}
			}
			if (files.length > 0) {
			this._addToWatched(files);
			this.close(false);
			this._initWatched(done);
			}
			};

			// Remove file/dir from `watched`
			Gaze.prototype.remove = function(file) {
			var self = this;
			if (this._watched[file]) {
			// is dir, remove all files
			this._unpollDir(file);
			delete this._watched[file];
			} else {
			// is a file, find and remove
			Object.keys(this._watched).forEach(function(dir) {
			var index = self._watched[dir].indexOf(file);
			if (index !== -1) {
			self._unpollFile(file);
			self._watched[dir].splice(index, 1);
			return false;
			}
			});
			}
			if (this._watchers[file]) {
			this._watchers[file].close();
			}
			return this;
			};

			// Return watched files
			Gaze.prototype.watched = function() {
			return this._watched;
			};

			// Returns `watched` files with relative paths to process.cwd()
			Gaze.prototype.relative = function(dir, unixify) {
			var self = this;
			var relative = Object.create(null);
			var relDir, relFile, unixRelDir;
			var cwd = this.options.cwd \|\| process.cwd();
			if (dir === '') { dir = '.'; }
			dir = helper.markDir(dir);
			unixify = unixify \|\| false;
			Object.keys(this._watched).forEach(function(dir) {
			relDir = path.relative(cwd, dir) + path.sep;
			if (relDir === path.sep) { relDir = '.'; }
			unixRelDir = unixify ? helper.unixifyPathSep(relDir) : relDir;
			relative[unixRelDir] = self._watched[dir].map(function(file) {
			relFile = path.relative(path.join(cwd, relDir) \|\| '', file \|\| '');
			if (helper.isDir(file)) {
			relFile = helper.markDir(relFile);
			}
			if (unixify) {
			relFile = helper.unixifyPathSep(relFile);
			}
			return relFile;
			});
			});
			if (dir && unixify) {
			dir = helper.unixifyPathSep(dir);
			}
			return dir ? relative[dir] \|\| [] : relative;
			};

			// Adds files and dirs to watched
			Gaze.prototype._addToWatched = function(files) {
			for (var i = 0; i < files.length; i++) {
			var file = files[i];
			var filepath = path.resolve(this.options.cwd, file);

			var dirname = (helper.isDir(file)) ? filepath : path.dirname(filepath);
			dirname = helper.markDir(dirname);

			// If a new dir is added
			if (helper.isDir(file) && !(filepath in this._watched)) {
			helper.objectPush(this._watched, filepath, []);
			}

			if (file.slice(-1) === '/') { filepath += path.sep; }
			helper.objectPush(this._watched, path.dirname(filepath) + path.sep, filepath);

			// add folders into the mix
			var readdir = fs.readdirSync(dirname);
			for (var j = 0; j < readdir.length; j++) {
			var dirfile = path.join(dirname, readdir[j]);
			if (fs.lstatSync(dirfile).isDirectory()) {
			helper.objectPush(this._watched, dirname, dirfile + path.sep);
			}
			}
			}
			return this;
			};

			Gaze.prototype._watchDir = function(dir, done) {
			var self = this;
			var timeoutId;
			try {
			this._watchers[dir] = fs.watch(dir, function(event) {
			// race condition. Let's give the fs a little time to settle down. so we
			// don't fire events on non existent files.
			clearTimeout(timeoutId);
			timeoutId = setTimeout(function() {
			// race condition. Ensure that this directory is still being watched
			// before continuing.
			if ((dir in self._watchers) && fs.existsSync(dir)) {
			done(null, dir);
			}
			}, delay + 100);
			});
			} catch (err) {
			return this._handleError(err);
			}
			return this;
			};

			Gaze.prototype._unpollFile = function(file) {
			if (this._pollers[file]) {
			fs.unwatchFile(file, this._pollers[file] );
			delete this._pollers[file];
			}
			return this;
			};

			Gaze.prototype._unpollDir = function(dir) {
			this._unpollFile(dir);
			for (var i = 0; i < this._watched[dir].length; i++) {
			this._unpollFile(this._watched[dir][i]);
			}
			};

			Gaze.prototype._pollFile = function(file, done) {
			var opts = { persistent: true, interval: this.options.interval };
			if (!this._pollers[file]) {
			this._pollers[file] = function(curr, prev) {
			done(null, file);
			};
			try {
			fs.watchFile(file, opts, this._pollers[file]);
			} catch (err) {
			return this._handleError(err);
			}
			}
			return this;
			};

			// Initialize the actual watch on `watched` files
			Gaze.prototype._initWatched = function(done) {
			var self = this;
			var cwd = this.options.cwd \|\| process.cwd();
			var curWatched = Object.keys(self._watched);

			// if no matching files
			if (curWatched.length < 1) {
			// Defer to emitting to give a chance to attach event handlers.
			setImmediate(function () {
			self.emit('ready', self);
			if (done) { done.call(self, null, self); }
			self.emit('nomatch');
			});
			return;
			}

			helper.forEachSeries(curWatched, function(dir, next) {
			dir = dir \|\| '';
			var files = self._watched[dir];
			// Triggered when a watched dir has an event
			self._watchDir(dir, function(event, dirpath) {
			var relDir = cwd === dir ? '.' : path.relative(cwd, dir);
			relDir = relDir \|\| '';

			fs.readdir(dirpath, function(err, current) {
			if (err) { return self.emit('error', err); }
			if (!current) { return; }

			try {
			// append path.sep to directories so they match previous.
			current = current.map(function(curPath) {
			if (fs.existsSync(path.join(dir, curPath)) && fs.lstatSync(path.join(dir, curPath)).isDirectory()) {
			return curPath + path.sep;
			} else {
			return curPath;
			}
			});
			} catch (err) {
			// race condition-- sometimes the file no longer exists
			}

			// Get watched files for this dir
			var previous = self.relative(relDir);

			// If file was deleted
			previous.filter(function(file) {
			return current.indexOf(file) < 0;
			}).forEach(function(file) {
			if (!helper.isDir(file)) {
			var filepath = path.join(dir, file);
			self.remove(filepath);
			self.emit('deleted', filepath);
			}
			});

			// If file was added
			current.filter(function(file) {
			return previous.indexOf(file) < 0;
			}).forEach(function(file) {
			// Is it a matching pattern?
			var relFile = path.join(relDir, file);
			// Add to watch then emit event
			self._internalAdd(relFile, function() {
			self.emit('added', path.join(dir, file));
			});
			});

			});
			});

			// Watch for change/rename events on files
			files.forEach(function(file) {
			if (helper.isDir(file)) { return; }
			self._pollFile(file, function(err, filepath) {
			// Only emit changed if the file still exists
			// Prevents changed/deleted duplicate events
			if (fs.existsSync(filepath)) {
			self.emit('changed', filepath);
			}
			});
			});

			next();
			}, function() {

			// Return this instance of Gaze
			// delay before ready solves a lot of issues
			setTimeout(function() {
			self.emit('ready', self);
			if (done) { done.call(self, null, self); }
			}, delay + 100);

			});
			};

			// If an error, handle it here
			Gaze.prototype._handleError = function(err) {
			if (err.code === 'EMFILE') {
			return this.emit('error', new Error('EMFILE: Too many opened files.'));
			}
			return this.emit('error', err);
			};