node_modules/gaze/lib/gaze.js

/*
 * 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 fileset = require('fileset');
var minimatch = require('minimatch');

// globals
var delay = 10;

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

  // 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 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);
  }

  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;

// Node v0.6 compat
fs.existsSync = fs.existsSync || path.existsSync;
path.sep = path.sep || path.normalize('/');

/**
 * Lo-Dash 1.0.1 <http://lodash.com/>
 * Copyright 2012-2013 The Dojo Foundation <http://dojofoundation.org/>
 * Based on Underscore.js 1.4.4 <http://underscorejs.org/>
 * Copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
 * Available under MIT license <http://lodash.com/license>
 */
function unique() { var array = Array.prototype.concat.apply(Array.prototype, arguments); var result = []; for (var i = 0; i < array.length; i++) { if (result.indexOf(array[i]) === -1) { result.push(array[i]); } } return result; }

/**
 * Copyright (c) 2010 Caolan McMahon
 * Available under MIT license <https://raw.github.com/caolan/async/master/LICENSE>
 */
function forEachSeries(arr, iterator, callback) {
  if (!arr.length) { return callback(); }
  var completed = 0;
  var iterate = function() {
    iterator(arr[completed], function (err) {
      if (err) {
        callback(err);
        callback = function() {};
      } else {
        completed += 1;
        if (completed === arr.length) {
          callback(null);
        } else {
          iterate();
        }
      }
    });
  };
  iterate();
}

// other helpers

// Returns boolean whether filepath is dir terminated
function _isDir(dir) {
  if (typeof dir !== 'string') { return false; }
  return (dir.slice(-(path.sep.length)) === path.sep);
}

// Create a `key:[]` if doesnt exist on `obj` then push or concat the `val`
function _objectPush(obj, key, val) {
  if (obj[key] == null) { obj[key] = []; }
  if (Array.isArray(val)) { obj[key] = obj[key].concat(val); }
  else if (val) { obj[key].push(val); }
  return obj[key] = unique(obj[key]);
}

// Ensures the dir is marked with path.sep
function _markDir(dir) {
  if (typeof dir === 'string' &&
    dir.slice(-(path.sep.length)) !== path.sep &&
    dir !== '.') {
    dir += path.sep;
  }
  return dir;
}

// Changes path.sep to unix ones for testing
function _unixifyPathSep(filepath) {
  return (process.platform === 'win32') ? String(filepath).replace(/\\/g, '/') : filepath;
}

// Override the emit function to emit `all` events
// and debounce on duplicate events per file
Gaze.prototype.emit = function() {
  var _this = 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(_this, 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 (_this._cached[oldFile].indexOf('deleted') !== -1) {
        args[0] = e = 'renamed';
        [].push.call(args, oldFile);
        delete _this._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) {
    _objectPush(_this._cached, filepath, e);
    clearTimeout(timeoutId);
    timeoutId = setTimeout(function() {
      delete _this._cached[filepath];
    }, this.options.debounceDelay);
    // Emit the event and `all` event
    Gaze.super_.prototype.emit.apply(_this, args);
    Gaze.super_.prototype.emit.apply(_this, ['all', e].concat([].slice.call(args, 1)));
  }

  return this;
};

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

// Add file patterns to be watched
Gaze.prototype.add = function(files, done) {
  var _this = this;
  if (typeof files === 'string') {
    files = [files];
  }
  this._patterns = unique.apply(null, [this._patterns, files]);

  var include = [], exclude = [];
  this._patterns.forEach(function(p) {
    if (p.slice(0, 1) === '!') {
      exclude.push(p.slice(1));
    } else {
      include.push(p);
    }
  });

  fileset(include, exclude, _this.options, function(err, files) {
    if (err) {
      _this.emit('error', err);
      return done(err);
    }
    _this._addToWatched(files);
    _this.close(false);
    _this._initWatched(done);
  });
};

// Remove file/dir from `watched`
Gaze.prototype.remove = function(file) {
  var _this = this;
  if (this._watched[file]) {
    // is dir, remove all files
    fs.unwatchFile(file);
    this._watched[file].forEach(fs.unwatchFile);
    delete this._watched[file];
  } else {
    // is a file, find and remove
    Object.keys(this._watched).forEach(function(dir) {
      var index = _this._watched[dir].indexOf(file);
      if (index !== -1) {
        fs.unwatchFile(file);
        _this._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 _this = this;
  var relative = Object.create(null);
  var relDir, relFile, unixRelDir;
  var cwd = this.options.cwd || process.cwd();
  if (dir === '') { dir = '.'; }
  dir = _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 ? _unixifyPathSep(relDir) : relDir;
    relative[unixRelDir] = _this._watched[dir].map(function(file) {
      relFile = path.relative(path.join(cwd, relDir), file);
      if (_isDir(file)) {
        relFile = _markDir(relFile);
      }
      if (unixify) {
        relFile = _unixifyPathSep(relFile);
      }
      return relFile;
    });
  });
  if (dir && unixify) {
    dir = _unixifyPathSep(dir);
  }
  return dir ? relative[dir] || [] : relative;
};

// Adds files and dirs to watched
Gaze.prototype._addToWatched = function(files) {
  var _this = this;
  files.forEach(function(file) {
    var filepath = path.resolve(_this.options.cwd, file);
    if (file.slice(-1) === '/') { filepath += path.sep; }
    _objectPush(_this._watched, path.dirname(filepath) + path.sep, filepath);
  });
  return this;
};

// Returns true if the file matches this._patterns
Gaze.prototype._isMatch = function(file) {
  var include = [], exclude = [];
  this._patterns.forEach(function(p) {
    if (p.slice(0, 1) === '!') {
      exclude.push(p.slice(1));
    } else {
      include.push(p);
    }
  });
  var matched = false, i = 0;
  for (i = 0; i < include.length; i++) {
    if (minimatch(file, include[i])) {
      matched = true;
      break;
    }
  }
  for (i = 0; i < exclude.length; i++) {
    if (minimatch(file, exclude[i])) {
      matched = false;
      break;
    }
  }
  return matched;
};

Gaze.prototype._watchDir = function(dir, done) {
  var _this = this;
  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.
      setTimeout(function() {
        if (fs.existsSync(dir)) {
          done(null, dir);
        }
      }, delay + 100);
    });
  } catch (err) {
    return this._handleError(err);
  }
  return this;
};

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

// Initialize the actual watch on `watched` files
Gaze.prototype._initWatched = function(done) {
  var _this = this;
  var cwd = this.options.cwd || process.cwd();
  var curWatched = Object.keys(_this._watched);
  forEachSeries(curWatched, function(dir, next) {
    var files = _this._watched[dir];
    // Triggered when a watched dir has an event
    _this._watchDir(dir, function(event, dirpath) {
      var relDir = cwd === dir ? '.' : path.relative(cwd, dir);

      fs.readdir(dirpath, function(err, current) {
        if (err) { return _this.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.statSync(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 = _this.relative(relDir);

        // If file was deleted
        previous.filter(function(file) {
          return current.indexOf(file) < 0;
        }).forEach(function(file) {
          if (!_isDir(file)) {
            var filepath = path.join(dir, file);
            _this.remove(filepath);
            _this.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);
          // TODO: this can be optimized more
          // we shouldnt need isMatch() and could just use add()
          if (_this._isMatch(relFile)) {
            // Add to watch then emit event
            _this.add(relFile, function() {
              _this.emit('added', path.join(dir, file));
            });
          }
        });

      });
    });

    // Watch for change/rename events on files
    files.forEach(function(file) {
      if (_isDir(file)) { return; }
      _this._pollFile(file, function(err, filepath) {
        // Only emit changed if the file still exists
        // Prevents changed/deleted duplicate events
        // TODO: This ignores changed events on folders, maybe support this?
        //       When a file is added, a folder changed event emits first
        if (fs.existsSync(filepath)) {
          _this.emit('changed', filepath);
        }
      });
    });

    next();
  }, function() {

    // Return this instance of Gaze
    // delay before ready solves a lot of issues
    setTimeout(function() {
      _this.emit('ready', _this);
      done.call(_this, null, _this);
    }, 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);
};