batman-rails-flo 0.0.1

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/index.js

@@ -0,0 +1,10 @@
+/**
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+module.exports = require('./lib/flo');

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/lib/flo.js

@@ -0,0 +1,226 @@
+/**
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var sane = require('sane');
+var assert = require('assert');
+var Server = require('./server');
+var EventEmitter = require('events').EventEmitter;
+
+module.exports = flo;
+
+/**
+ * Top-level API for flo. Defaults params and instantiates `Flo`.
+ *
+ * @param {string} dir
+ * @param {object} options
+ * @param {function} callback
+ * @return {Flo}
+ * @public
+ */
+
+function flo(dir, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = null;
+  }
+
+  dir = path.resolve(dir);
+
+  options = options || {};
+  options = {
+    port: options.port || 8888,
+    host: options.host || 'localhost',
+    verbose: options.verbose || false,
+    glob: options.glob || [],
+    useFilePolling: options.useFilePolling || false,
+    pollingInterval: options.pollingInterval
+  };
+
+  callback = callback || noBuildCallback(dir);
+
+  return new Flo(dir, options, callback);
+}
+
+/**
+ * Time before we emit the ready event.
+ */
+
+var DELAY = 200;
+
+/**
+ * Starts the server and the watcher and handles the piping between both and the
+ * resolver callback.
+ *
+ * @param {string} dir
+ * @param {object} options
+ * @param {function} callback
+ * @class Flo
+ * @private
+ */
+
+function Flo(dir, options, callback) {
+  this.log = logger(options.verbose, 'Flo');
+  this.dir = dir;
+  this.realpathdir = fs.realpathSync(dir);
+  this.resolver = callback;
+  this.server = new Server({
+    port: options.port,
+    host: options.host,
+    log: logger(options.verbose, 'Server')
+  });
+
+  this.watcher = new sane.Watcher(dir, {
+    glob: options.glob,
+    poll: options.useFilePolling,
+    pollingInterval: options.pollingInterval
+  });
+  this.watcher.on('change', this.onFileChange.bind(this));
+  this.watcher.on(
+    'ready',
+    this.emit.bind(this, 'ready')
+  );
+}
+
+Flo.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Handles file changes.
+ *
+ * @param {string} filepath
+ * @private
+ */
+
+Flo.prototype.onFileChange = function(filepath) {
+  this.log('File changed', filepath);
+  var server = this.server;
+  this.resolver(filepath, function(resource) {
+    resource = normalizeResource(resource);
+    server.broadcast(resource);
+  });
+};
+
+/**
+ * Closes the server and the watcher.
+ *
+ * @public
+ */
+
+Flo.prototype.close = function() {
+  this.log('Shutting down flo');
+  this.watcher.close();
+  this.server.close();
+};
+
+/**
+ * Creates a logger for a given module.
+ *
+ * @param {boolean} verbose
+ * @param {string} moduleName
+ * @private
+ */
+
+function logger(verbose, moduleName) {
+  var slice = [].slice;
+  return function() {
+    var args = slice.call(arguments);
+    args[0] = '[' + moduleName + '] ' + args[0];
+    if (verbose) {
+      console.log.apply(console, args);
+    }
+  }
+}
+
+/**
+ * Check if an object is of type RegExp.
+ *
+ * @param {*} o
+ * @return {boolean}
+ * @private
+ */
+
+function isRegExp(o) {
+  return o && typeof o === 'object' &&
+    Object.prototype.toString.call(o) === '[object RegExp]';
+}
+
+/**
+ * Given a resource, enforce type checks, default params, and prepare for
+ * serialization.
+ *
+ * @param {*} o
+ * @return {boolean}
+ * @private
+ */
+
+function normalizeResource(resource) {
+  if (resource.reload) {
+    return resource;
+  }
+
+  assert(resource.resourceURL, 'expecting resourceURL');
+  assert(resource.contents != null, 'expecting contents');
+
+  var ret = {};
+
+  ret.match = resource.match || 'indexOf';
+  ret.contents = resource.contents.toString();
+  ret.resourceURL = resource.resourceURL;
+
+  if (path.sep === '\\') {
+    ret.resourceURL = ret.resourceURL.replace(/\\/g, '/');
+  }
+
+  assert.ok(
+    isRegExp(ret.match) ||
+      ['indexOf', 'equal'].indexOf(ret.match) > -1,
+      'resource.match must be of type function, or regexp, ' +
+        'or a string either "indexOf" or "equal'
+  );
+
+  if (isRegExp(ret.match)) {
+    var r = ret.match;
+    ret.match = {
+      type: 'regexp',
+      source: r.source,
+      global: r.global,
+      multiline: r.multiline,
+      ignoreCase: r.ignoreCase
+    };
+  }
+
+  return ret;
+}
+
+/**
+ * Default resolver callback that will simply read the file and pass back the
+ * filename relative to the watched dir as the url.
+ *
+ * @param {string} dir
+ * @return {function}
+ * @private
+ */
+
+function noBuildCallback(dir) {
+  return function(filepath, callback) {
+    fs.readFile(path.join(dir, filepath), function(err, data) {
+      // Todo better error handling.
+      if (err) {
+        throw err;
+      }
+      callback({
+        resourceURL: filepath,
+        contents: data.toString()
+      });
+    });
+  };
+}

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/lib/server.js

@@ -0,0 +1,94 @@
+/**
+ *  Copyright (c) 2014, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the BSD-style license found in the
+ *  LICENSE file in the root directory of this source tree. An additional grant
+ *  of patent rights can be found in the PATENTS file in the same directory.
+ */
+
+'use strict';
+
+var http = require('http');
+var WSS = require('websocket').server;
+
+module.exports = Server;
+
+/**
+ * Starts an http server with the given options and attaches a websocket server
+ * to it.
+ *
+ * @class Server
+ * @param {object} options
+ */
+
+function Server(options) {
+  this.log = options.log || function() {};
+  this.httpServer = http.createServer(function(req, res) {
+    res.writeHead(404);
+    res.end();
+  });
+  this.httpServer.listen(options.port);
+  this.wsServer = new WSS({
+    httpServer: this.httpServer,
+    autoAcceptConnections: false
+  });
+  this.wsServer.on('request', this.onRequest.bind(this));
+  this.connections = [];
+}
+
+/**
+ * Request handler.
+ *
+ * @param {object} req
+ * @private
+ */
+
+Server.prototype.onRequest = function(req) {
+  this.log('Client connected', req.socket.address());
+  var ws = req.accept();
+  this.connections.push(ws);
+  ws.on('close', this.onClose.bind(this, ws));
+};
+
+/**
+ * Websocket connection close handler.
+ *
+ * @param {object} ws
+ * @private
+ */
+
+Server.prototype.onClose = function(ws) {
+  this.log('Client disconnected', ws.remoteAddress);
+  if (this.connections) {
+    this.connections.splice(this.connections.indexOf(ws), 1);
+  }
+};
+
+/**
+ * Message handler.
+ *
+ * @param {object} msg
+ * @public
+ */
+
+Server.prototype.broadcast = function(msg) {
+  this.log('Broadcasting', msg);
+  msg = JSON.stringify(msg);
+  this.connections.forEach(function(ws) {
+    ws.send(msg);
+  });
+};
+
+/**
+ * Close the server.
+ *
+ * @public
+ */
+
+Server.prototype.close = function() {
+  this.log('Shutting down WebSocket server');
+  this.connections = null;
+  this.wsServer.shutDown();
+  this.httpServer.close();
+};

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/README.md

@@ -0,0 +1,66 @@
+sane
+----
+
+I've been driven to insanity by node filesystem watcher wrappers.
+Sane aims to be fast, small, and reliable file system watcher. It does that by:
+
+* Always use fs.watch (unless polling is forced) and sensibly workaround the various issues with it
+* Sane is all JavaScript, no native components
+* Stay away from polling because it's very slow and cpu intensive
+* Support polling for environments like Vagrant shared directory where there are no native filesystem events
+
+## Install
+
+Requires node >= v0.10.0.
+
+```
+$ npm install sane
+```
+
+## API
+
+### sane(dir, globs, options)
+
+Watches a directory and all it's descendant directorys for changes, deletions, and additions on files and directories.
+Shortcut for `new sane.Watcher(dir, {glob: globs, ..options})`.
+
+```js
+var watcher = sane('path/to/dir', ['**/*.js, '**/*.css']);
+watcher.on('ready', function () { console.log('ready') });
+watcher.on('change', function (filepath) { console.log('file changed', filepath); });
+watcher.on('add', function (filepath) { console.log('file added', filepath); });
+watcher.on('delete', function (filepath) { console.log('file deleted', filepath); });
+// close
+watcher.close();
+```
+
+For `options` see `sane.Watcher`.
+
+### sane.Watcher(dir, options)
+
+options:
+
+* `persistent`: boolean indicating that the process shouldn't die while we're watching files.
+* `glob`: a single string glob pattern or an array of them.
+* `poll`: puts the watcher in polling mode. Under the hood that means `fs.watchFile`.
+* `interval`: indicates how often the files should be polled. (passed to `fs.watchFile`)
+
+For the glob pattern documentation, see [minimatch](https://github.com/isaacs/minimatch).
+
+### sane.Watcher#close
+
+Stops watching.
+
+### sane.Watcher events
+
+Emits the following events:
+
+All events are passed the file/dir path relative to the root directory
+* `ready` when the program is ready to detect events in the directory
+* `change` when a file changes
+* `add` when a file or directory has been added
+* `delete` when a file or directory has been deleted
+
+## License
+
+MIT

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/index.js

@@ -0,0 +1,437 @@
+var fs = require('fs');
+var path = require('path');
+var watch = require('watch');
+var walker = require('walker');
+var platform = require('os').platform();
+var minimatch = require('minimatch');
+var EventEmitter = require('events').EventEmitter;
+
+module.exports = sane;
+
+/**
+ * Sugar for creating a watcher.
+ *
+ * @param {String} dir
+ * @param {Array<String>} glob
+ * @param {Object} opts
+ * @return {Watcher}
+ * @public
+ */
+
+function sane(dir, glob, opts) {
+  opts = opts || {};
+  opts.glob = glob;
+  return new Watcher(dir, opts);
+}
+
+/**
+ * Export `Watcher` class.
+ */
+
+sane.Watcher = Watcher;
+
+/**
+ * Watches `dir`.
+ *
+ * @class Watcher
+ * @param String dir
+ * @param {Object} opts
+ * @public
+ */
+
+function Watcher(dir, opts) {
+  opts = opts || {};
+  this.persistent = opts.persistent != null
+    ? opts.persistent
+    : true;
+  this.globs = opts.glob || [];
+  if (!Array.isArray(this.globs)) this.globs = [this.globs];
+  this.watched = Object.create(null);
+  this.changeTimers = Object.create(null);
+  this.dirRegistery = Object.create(null);
+  this.root = path.resolve(dir);
+  this.watchdir = this.watchdir.bind(this);
+  this.register = this.register.bind(this);
+  this.stopWatching = this.stopWatching.bind(this);
+  this.filter = this.filter.bind(this);
+
+  if (opts.poll) {
+    this.polling = true;
+    watch.createMonitor(
+      dir,
+      { interval: opts.interval || DEFAULT_DELAY , filter: this.filter },
+      this.initPoller.bind(this)
+    );
+  } else {
+    this.watchdir(dir);
+    recReaddir(
+      dir,
+      this.watchdir,
+      this.register,
+      this.emit.bind(this, 'ready')
+    );
+  }
+}
+
+Watcher.prototype.__proto__ = EventEmitter.prototype;
+
+/**
+ * Checks a file relative path against the globs array.
+ *
+ * @param {string} relativePath
+ * @return {boolean}
+ * @private
+ */
+
+Watcher.prototype.isFileIncluded = function(relativePath) {
+  var globs = this.globs;
+  var matched;
+  if (globs.length) {
+    for (var i = 0; i < globs.length; i++) {
+      if (minimatch(relativePath, globs[i])) {
+        matched = true;
+        break;
+      }
+    }
+  } else {
+    matched = true;
+  }
+  return matched;
+};
+
+/**
+ * Register files that matches our globs to know what to type of event to
+ * emit in the future.
+ *
+ * Registery looks like the following:
+ *
+ *  dirRegister => Map {
+ *    dirpath => Map {
+ *       filename => true
+ *    }
+ *  }
+ *
+ * @param {string} filepath
+ * @return {boolean} whether or not we have registered the file.
+ * @private
+ */
+
+Watcher.prototype.register = function(filepath) {
+  var relativePath = path.relative(this.root, filepath);
+  if (!this.isFileIncluded(relativePath)) {
+    return false;
+  }
+
+  var dir = path.dirname(filepath);
+  if (!this.dirRegistery[dir]) {
+    this.dirRegistery[dir] = Object.create(null);
+  }
+
+  var filename = path.basename(filepath);
+  this.dirRegistery[dir][filename] = true;
+
+  return true;
+};
+
+/**
+ * Removes a file from the registery.
+ *
+ * @param {string} filepath
+ * @private
+ */
+
+Watcher.prototype.unregister = function(filepath) {
+  var dir = path.dirname(filepath);
+  if (this.dirRegistery[dir]) {
+    var filename = path.basename(filepath);
+    delete this.dirRegistery[dir][filename];
+  }
+};
+
+/**
+ * Removes a dir from the registery.
+ *
+ * @param {string} dirpath
+ * @private
+ */
+
+Watcher.prototype.unregisterDir = function(dirpath) {
+  if (this.dirRegistery[dirpath]) {
+    delete this.dirRegistery[dirpath];
+  }
+};
+
+/**
+ * Checks if a file or directory exists in the registery.
+ *
+ * @param {string} fullpath
+ * @return {boolean}
+ * @private
+ */
+
+Watcher.prototype.registered = function(fullpath) {
+  var dir = path.dirname(fullpath);
+  return this.dirRegistery[fullpath] ||
+    this.dirRegistery[dir] && this.dirRegistery[dir][path.basename(fullpath)];
+};
+
+/**
+ * Watch a directory.
+ *
+ * @param {string} dir
+ * @private
+ */
+
+Watcher.prototype.watchdir = function(dir) {
+  if (this.watched[dir]) return;
+  var watcher = fs.watch(
+    dir,
+    { persistent: this.persistent },
+    this.normalizeChange.bind(this, dir)
+  );
+  this.watched[dir] = watcher;
+
+  // Workaround Windows node issue #4337.
+  if (platform === 'win32') {
+    watcher.on('error', function(error) {
+      if (error.code !== 'EPERM') throw error;
+    });
+  }
+
+  if (this.root !== dir) {
+    this.register(dir);
+  }
+};
+
+/**
+ * In polling mode stop watching files and directories, in normal mode, stop
+ * watching files.
+ *
+ * @param {string} filepath
+ * @private
+ */
+
+Watcher.prototype.stopWatching = function(filepath) {
+  if (this.polling) {
+    fs.unwatchFile(filepath);
+  } else if (this.watched[filepath]) {
+    this.watched[filepath].close();
+    delete this.watched[filepath];
+  }
+};
+
+/**
+ * End watching.
+ *
+ * @public
+ */
+
+Watcher.prototype.close = function() {
+  Object.keys(this.watched).forEach(this.stopWatching);
+  this.removeAllListeners();
+};
+
+/**
+ * On some platforms, as pointed out on the fs docs (most likely just win32)
+ * the file argument might be missing from the fs event. Try to detect what
+ * change by detecting if something was deleted or the most recent file change.
+ *
+ * @param {string} dir
+ * @param {string} event
+ * @param {string} file
+ * @public
+ */
+
+Watcher.prototype.detectChangedFile = function(dir, event, callback) {
+  var found = false;
+  var closest = {mtime: 0};
+  var c = 0;
+  Object.keys(this.dirRegistery[dir]).forEach(function(file, i, arr) {
+    fs.stat(path.join(dir, file), function(error, stat) {
+      if (found) return;
+      if (error) {
+        if (error.code === 'ENOENT') {
+          found = true;
+          callback(file);
+        } else {
+          this.emit('error', error);
+        }
+      } else {
+        if (stat.mtime > closest.mtime) {
+          stat.file = file;
+          closest = stat;
+        }
+        if (arr.length === ++c) {
+          callback(closest.file);
+        }
+      }
+    }.bind(this));
+  }, this);
+};
+
+/**
+ * Normalize fs events and pass it on to be processed.
+ *
+ * @param {string} dir
+ * @param {string} event
+ * @param {string} file
+ * @public
+ */
+
+Watcher.prototype.normalizeChange = function(dir, event, file) {
+  if (!file) {
+    this.detectChangedFile(dir, event, function(actualFile) {
+      if (actualFile) {
+        this.processChange(dir, event, actualFile);
+      }
+    }.bind(this));
+  } else {
+    this.processChange(dir, event, path.normalize(file));
+  }
+};
+
+/**
+ * Process changes.
+ *
+ * @param {string} dir
+ * @param {string} event
+ * @param {string} file
+ * @public
+ */
+
+Watcher.prototype.processChange = function(dir, event, file) {
+  var fullPath = path.join(dir, file);
+  var relativePath = path.join(path.relative(this.root, dir), file);
+  fs.stat(fullPath, function(error, stat) {
+    if (error && error.code !== 'ENOENT') {
+      this.emit('error', error);
+    } else if (!error && stat.isDirectory()) {
+      // win32 emits usless change events on dirs.
+      if (event !== 'change') {
+        this.watchdir(fullPath);
+        this.emitEvent(ADD_EVENT, relativePath);
+      }
+    } else {
+      var registered = this.registered(fullPath);
+      if (error && error.code === 'ENOENT') {
+        this.unregister(fullPath);
+        this.stopWatching(fullPath);
+        this.unregisterDir(fullPath);
+        if (registered) {
+          this.emitEvent(DELETE_EVENT, relativePath);
+        }
+      } else if (registered) {
+        this.emitEvent(CHANGE_EVENT, relativePath);
+      } else {
+        if (this.register(fullPath)) {
+          this.emitEvent(ADD_EVENT, relativePath);
+        }
+      }
+    }
+  }.bind(this));
+};
+
+/**
+ * Triggers a 'change' event after debounding it to take care of duplicate
+ * events on os x.
+ *
+ * @private
+ */
+
+Watcher.prototype.emitEvent = function(type, file) {
+  var key = type + '-' + file;
+  clearTimeout(this.changeTimers[key]);
+  this.changeTimers[key] = setTimeout(function() {
+    delete this.changeTimers[key];
+    this.emit(type, file);
+  }.bind(this), DEFAULT_DELAY);
+};
+
+/**
+ * Initiate the polling file watcher with the event emitter passed from
+ * `watch.watchTree`.
+ *
+ * @param {EventEmitter} monitor
+ * @public
+ */
+
+Watcher.prototype.initPoller = function(monitor) {
+  this.watched = monitor.files;
+  monitor.on('changed', this.pollerEmit.bind(this, CHANGE_EVENT));
+  monitor.on('removed', this.pollerEmit.bind(this, DELETE_EVENT));
+  monitor.on('created', this.pollerEmit.bind(this, ADD_EVENT));
+  // 1 second wait because mtime is second-based.
+  setTimeout(this.emit.bind(this, 'ready'), 1000);
+};
+
+/**
+ * Transform and emit an event comming from the poller.
+ *
+ * @param {EventEmitter} monitor
+ * @public
+ */
+
+Watcher.prototype.pollerEmit = function(type, file) {
+  file = path.relative(this.root, file);
+  this.emit(type, file);
+};
+
+/**
+ * Given a fullpath of a file or directory check if we need to watch it.
+ *
+ * @param {string} filepath
+ * @param {object} stat
+ * @public
+ */
+
+Watcher.prototype.filter = function(filepath, stat) {
+  return stat.isDirectory() || this.isFileIncluded(
+    path.relative(this.root, filepath)
+  );
+};
+
+/**
+ * Constants
+ */
+
+var DEFAULT_DELAY = 100;
+var CHANGE_EVENT = 'change';
+var DELETE_EVENT = 'delete';
+var ADD_EVENT = 'add';
+
+/**
+ * Traverse a directory recursively calling `callback` on every directory.
+ *
+ * @param {string} dir
+ * @param {function} callback
+ * @param {function} endCallback
+ * @private
+ */
+
+function recReaddir(dir, dirCallback, fileCallback, endCallback) {
+  walker(dir)
+    .on('dir', normalizeProxy(dirCallback))
+    .on('file', normalizeProxy(fileCallback))
+    .on('end', function() {
+      if (platform === 'win32') {
+        setTimeout(endCallback, 1000);
+      } else {
+        endCallback();
+      }
+    });
+}
+
+/**
+ * Returns a callback that when called will normalize a path and call the
+ * original callback
+ *
+ * @param {function} callback
+ * @return {function}
+ * @private
+ */
+
+function normalizeProxy(callback) {
+  return function(filepath) {
+    return callback(path.normalize(filepath));
+  }
+}