fs-util/lib/fs-util.js

// Generated by CoffeeScript 1.4.0
(function() {
  var DirWatcher, EventEmitter, FileWatcher, Watcher, cp, cp_r, find, fs, ls, mkdir_p, os, path, rm_rf, touch, util,
    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

  path = require('path');

  fs = require('fs');

  exports.touch = touch = function(filepath, encoding) {
    var dir_to;
    if (encoding == null) {
      encoding = 'utf-8';
    }
    dir_to = path.dirname(touch);
    return fs.writeFileSync(filepath, '', encoding);
  };

  exports.rm_rf = rm_rf = function(folderpath, root) {
    var file, files, stats, _i, _len;
    if (root == null) {
      root = true;
    }
    files = fs.readdirSync(path.resolve(folderpath));
    for (_i = 0, _len = files.length; _i < _len; _i++) {
      file = files[_i];
      file = path.resolve("" + folderpath + "/" + file);
      stats = fs.statSync(file);
      if (stats.isDirectory()) {
        rm_rf(file, false);
        fs.rmdirSync(file);
      } else {
        fs.unlinkSync(file);
      }
    }
    if (root) {
      return fs.rmdirSync(folderpath);
    }
  };

  exports.mkdir_p = mkdir_p = function(fullpath, mode) {
    var exists, folder, folderpath, folders, index, _i, _len;
    if (mode == null) {
      mode = '0755';
    }
    fullpath = path.resolve(fullpath);
    folders = fullpath.split(path.sep);
    if (folders[0] === '') {
      folders[0] = '/';
    }
    for (index = _i = 0, _len = folders.length; _i < _len; index = ++_i) {
      folder = folders[index];
      folderpath = path.join.apply(null, folders.slice(0, index + 1));
      exists = fs.existsSync(folderpath);
      if (exists && index === folders.length - 1) {
        throw new Error(error("Folder exists: " + folder.red));
        return false;
      } else if (!exists) {
        fs.mkdirSync(folderpath, mode);
      }
    }
    return true;
  };

  exports.cp = cp = function(from, to) {
    if (!fs.statSync(from).isDirectory()) {
      return fs.writeFileSync(to, fs.readFileSync(from));
    }
  };

  exports.cp_r = cp_r = function(from, to) {
    var dir_to, file_from, file_to, files, _i, _len, _ref, _results;
    from = path.resolve(from);
    to = path.resolve(to);
    if ((from.slice(-1)) === '/') {
      from = from.slice(0, -1);
    }
    if ((to.slice(-1)) === '/') {
      to = to.slice(0, -1);
    }
    _ref = (files = find(from, /.*/, false));
    _results = [];
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      file_from = _ref[_i];
      file_to = file_from.replace(from, to);
      dir_to = path.dirname(file_to);
      if (!fs.existsSync(dir_to)) {
        mkdir_p(dir_to);
      }
      _results.push(cp(file_from, file_to));
    }
    return _results;
  };

  exports.find = find = function(folderpath, pattern, include_dirs) {
    var file, filepath, files, found, found_under, _i, _len;
    if (include_dirs == null) {
      include_dirs = false;
    }
    found = [];
    files = fs.readdirSync(folderpath);
    for (_i = 0, _len = files.length; _i < _len; _i++) {
      file = files[_i];
      filepath = path.join(folderpath, file);
      if ((fs.statSync(filepath)).isDirectory()) {
        if (include_dirs && filepath.match(pattern)) {
          found = found.concat(filepath);
        }
        found_under = find(filepath, pattern, include_dirs);
        found = found.concat(found_under);
      } else {
        if (filepath.match(pattern)) {
          found.push(filepath);
        }
      }
    }
    return found;
  };

  exports.ls = ls = function(folderpath) {
    var file, filepath, files, found, _i, _len;
    found = [];
    files = fs.readdirSync(folderpath);
    for (_i = 0, _len = files.length; _i < _len; _i++) {
      file = files[_i];
      filepath = path.join(folderpath, file);
      if ((fs.statSync(filepath)).isDirectory()) {
        found.push(filepath);
      }
    }
    return found;
  };

  fs = require('fs');

  os = require('os');

  path = require('path');

  util = require('util');

  EventEmitter = require('events').EventEmitter;

  FileWatcher = (function() {

    function FileWatcher(watcher, location, parent, dispatch_created) {
      this.watcher = watcher;
      this.location = location;
      this.parent = parent;
      this.dispatch_created = dispatch_created != null ? dispatch_created : false;
      this.onchange = __bind(this.onchange, this);

      this.config();
      this.init();
      this.watch();
    }

    FileWatcher.prototype.config = function() {
      this.type = 'file';
      return this.curr = fs.statSync(this.location);
    };

    FileWatcher.prototype.init = function() {
      if (this.dispatch_created) {
        return this.watcher.emit('create', this);
      }
    };

    FileWatcher.prototype.watch = function() {
      var options;
      options = {
        persistent: this.watcher.persistent
      };
      this._ref = fs.watch(this.location, options, this.onchange);
      if (/^win/.test(os.platform())) {
        this._ref.on('error', function() {});
      }
      return this.watcher.emit('watch', this);
    };

    FileWatcher.prototype.unwatch = function() {
      this._ref.close();
      return this.watcher.emit('unwatch', this);
    };

    FileWatcher.prototype.onchange = function() {
      if (!fs.existsSync(this.location)) {
        this.prev = this.curr;
        this.curr = null;
        return;
      }
      this.prev = this.curr;
      this.curr = fs.statSync(this.location);
      if (this.curr.mtime > this.prev.mtime) {
        return this.watcher.emit('change', this);
      }
    };

    FileWatcher.prototype["delete"] = function() {
      this.unwatch();
      this.parent.tree[this.location] = null;
      delete this.parent.tree[this.location];
      return this.watcher.emit('delete', this);
    };

    return FileWatcher;

  })();

  DirWatcher = (function() {

    function DirWatcher(watcher, location, parent, dispatch_created) {
      this.watcher = watcher;
      this.location = location;
      this.parent = parent;
      this.dispatch_created = dispatch_created != null ? dispatch_created : false;
      this.onchange = __bind(this.onchange, this);

      this.config();
      this.init();
      this.watch();
    }

    DirWatcher.prototype.config = function() {
      this.type = 'dir';
      this.tree = {};
      return this.curr = fs.statSync(this.location);
    };

    DirWatcher.prototype.init = function() {
      var dir, file, fullpath, name, _i, _len, _ref;
      _ref = fs.readdirSync(this.location);
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        name = _ref[_i];
        fullpath = path.resolve("" + this.location + "/" + name);
        if (fs.statSync(fullpath).isDirectory()) {
          dir = new DirWatcher(this.watcher, fullpath, this, this.dispatch_created);
          this.tree[fullpath] = dir;
        } else if (fs.statSync(fullpath).isFile()) {
          if (this.watcher.pattern.test(fullpath)) {
            file = new FileWatcher(this.watcher, fullpath, this, this.dispatch_created);
            this.tree[fullpath] = file;
          }
        }
      }
      if (this.dispatch_created) {
        return this.watcher.emit('create', this);
      }
    };

    DirWatcher.prototype.watch = function() {
      var options;
      options = {
        persistent: this.watcher.persistent
      };
      this._ref = fs.watch(this.location, options, this.onchange);
      if (/^win/.test(os.platform())) {
        this._ref.on('error', function() {});
      }
      return this.watcher.emit('watch', this);
    };

    DirWatcher.prototype.unwatch = function(propagate) {
      var item, location, _ref;
      if (propagate) {
        _ref = this.tree;
        for (location in _ref) {
          item = _ref[location];
          item.unwatch(propagate);
        }
      }
      this._ref.close();
      return this.watcher.emit('unwatch', this);
    };

    DirWatcher.prototype.onchange = function() {
      var created, deleted, _i, _j, _len, _len1, _ref, _ref1, _results;
      if (!fs.existsSync(this.location)) {
        this.prev = this.curr;
        this.curr = null;
        if (this.location === this.watcher.root) {
          this["delete"]();
        }
        return;
      }
      this.prev = this.curr;
      this.curr = fs.statSync(this.location);
      ls = this.diff();
      _ref = ls.deleted;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        deleted = _ref[_i];
        deleted["delete"]();
      }
      _ref1 = ls.created;
      _results = [];
      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
        created = _ref1[_j];
        if (fs.statSync(created).isDirectory()) {
          _results.push(this.tree[created] = new DirWatcher(this.watcher, created, this, true));
        } else if (fs.statSync(created).isFile()) {
          _results.push(this.tree[created] = new FileWatcher(this.watcher, created, this, true));
        } else {
          _results.push(void 0);
        }
      }
      return _results;
    };

    DirWatcher.prototype.diff = function() {
      var curr, fullpath, isdir, k, name, prev, status, v, _i, _len, _ref;
      prev = this.tree;
      curr = {};
      _ref = fs.readdirSync(this.location);
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        name = _ref[_i];
        fullpath = path.resolve("" + this.location + "/" + name);
        isdir = (fs.statSync(fullpath)).isDirectory();
        if (isdir || this.watcher.pattern.test(fullpath)) {
          curr[fullpath] = fullpath;
        }
      }
      status = {
        deleted: [],
        created: []
      };
      for (k in curr) {
        v = curr[k];
        if (prev[k] == null) {
          status.created.push(v);
        }
      }
      for (k in prev) {
        v = prev[k];
        if (curr[k] == null) {
          status.deleted.push(v);
        }
      }
      return status;
    };

    DirWatcher.prototype["delete"] = function(dispatch_event) {
      var item, location, _ref;
      if (dispatch_event == null) {
        dispatch_event = true;
      }
      _ref = this.tree;
      for (location in _ref) {
        item = _ref[location];
        item["delete"](this.watcher.recursive);
      }
      this.unwatch();
      this.parent.tree[this.location] = null;
      delete this.parent.tree[this.location];
      if (dispatch_event) {
        return this.watcher.emit('delete', this);
      }
    };

    return DirWatcher;

  })();

  Watcher = (function(_super) {

    __extends(Watcher, _super);

    function Watcher(root, pattern, recursive, persistent) {
      var _this = this;
      this.pattern = pattern;
      this.recursive = recursive != null ? recursive : false;
      this.persistent = persistent != null ? persistent : true;
      this.config(root);
      setTimeout(function() {
        return _this.init();
      }, 1);
    }

    Watcher.prototype.config = function(root) {
      this.tree = {};
      this.root = path.resolve(root);
      if (!fs.existsSync(this.root)) {
        throw new Error("Not found: " + this.root);
      }
    };

    Watcher.prototype.init = function() {
      if ((fs.statSync(this.root)).isDirectory()) {
        return this.tree[this.root] = new DirWatcher(this, this.root, this);
      } else if ((fs.statSync(this.root)).isFile()) {
        return this.tree[this.root] = new FileWatcher(this, this.root, this);
      }
    };

    Watcher.prototype.close = function() {
      var item;
      item = this.tree[this.root];
      if (item.type === 'dir') {
        item.unwatch(true);
      } else {
        item.unwatch();
      }
      this.removeAllListeners('create');
      this.removeAllListeners('watch');
      this.removeAllListeners('change');
      this.removeAllListeners('unwatch');
      return this.removeAllListeners('delete');
    };

    return Watcher;

  })(EventEmitter);

  exports.watch = function(root, pattern, recursive, persistent) {
    return new Watcher(root, pattern, recursive, persistent);
  };

}).call(this);