batman-rails-flo 0.0.1

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/node_modules/watch/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "watch",
+  "description": "Utilities for watching file trees.",
+  "tags": [
+    "util",
+    "utility",
+    "fs",
+    "files"
+  ],
+  "version": "0.10.0",
+  "homepage": "https://github.com/mikeal/watch",
+  "bugs": {
+    "url": "https://github.com/mikeal/watch/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/mikeal/watch.git"
+  },
+  "author": {
+    "name": "Mikeal Rogers",
+    "email": "mikeal.rogers@gmail.com"
+  },
+  "directories": {
+    "lib": "lib"
+  },
+  "engines": [
+    "node >=0.1.95"
+  ],
+  "main": "./main",
+  "readme": "# watch -- Utilities for watching file trees in node.js\n\n## Install\n\n<pre>\n  npm install watch\n</pre>\n\n## Purpose\n\nThe intention of this module is provide tools that make managing the watching of file & directory trees easier.\n\n#### watch.watchTree(root, [options,] callback)\n\nThe first argument is the directory root you want to watch.\n\nThe options object is passed to fs.watchFile but can also be used to provide two additional watchTree specific options:\n\n* `'ignoreDotFiles'` - When true this option means that when the file tree is walked it will ignore files that being with \".\"\n* `'filter'` - You can use this option to provide a function that returns true or false for each file and directory that is walked to decide whether or not that file/directory is included in the watcher.\n\nThe callback takes 3 arguments. The first is the file that was modified. The second is the current stat object for that file and the third is the previous stat object.\n\nWhen a file is new the previous stat object is null.\n\nWhen watchTree is finished walking the tree and adding all the listeners it passes the file hash (keys are the file/directory names and the values are the current stat objects) as the first argument and null as both the previous and current stat object arguments.\n\n<pre>\n  watch.watchTree('/home/mikeal', function (f, curr, prev) {\n    if (typeof f == \"object\" && prev === null && curr === null) {\n      // Finished walking the tree\n    } else if (prev === null) {\n      // f is a new file\n    } else if (curr.nlink === 0) {\n      // f was removed\n    } else {\n      // f was changed\n    }\n  })\n</pre>\n\n### watch.createMonitor(root, [options,] callback)\n\nThis function creates an EventEmitter that gives notifications for different changes that happen to the file and directory tree under the given root argument.\n\nThe options object is passed to watch.watchTree.\n\nThe callback receives the monitor object.\n\nThe monitor object contains a property, `files`, which is a hash of files and directories as keys with the current stat object as the value.\n\nThe monitor has the following events.\n\n* `'created'` - New file has been created. Two arguments, the filename and the stat object.\n* `'removed'` - A file has been moved or deleted. Two arguments, the filename and the stat object for the fd.\n* `'changed'` - A file has been changed. Three arguments, the filename, the current stat object, and the previous stat object.\n\n<pre>\n  var watch = require('watch')\n  watch.createMonitor('/home/mikeal', function (monitor) {\n    monitor.files['/home/mikeal/.zshrc'] // Stat object for my zshrc.\n    monitor.on(\"created\", function (f, stat) {\n      // Handle new files\n    })\n    monitor.on(\"changed\", function (f, curr, prev) {\n      // Handle file changes\n    })\n    monitor.on(\"removed\", function (f, stat) {\n      // Handle removed files\n    })\n  })\n</pre>\n",
+  "readmeFilename": "readme.mkd",
+  "_id": "watch@0.10.0",
+  "_from": "watch@~0.10.0"
+}

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/node_modules/watch/readme.mkd

@@ -0,0 +1,72 @@
+# watch -- Utilities for watching file trees in node.js
+
+## Install
+
+<pre>
+  npm install watch
+</pre>
+
+## Purpose
+
+The intention of this module is provide tools that make managing the watching of file & directory trees easier.
+
+#### watch.watchTree(root, [options,] callback)
+
+The first argument is the directory root you want to watch.
+
+The options object is passed to fs.watchFile but can also be used to provide two additional watchTree specific options:
+
+* `'ignoreDotFiles'` - When true this option means that when the file tree is walked it will ignore files that being with "."
+* `'filter'` - You can use this option to provide a function that returns true or false for each file and directory that is walked to decide whether or not that file/directory is included in the watcher.
+
+The callback takes 3 arguments. The first is the file that was modified. The second is the current stat object for that file and the third is the previous stat object.
+
+When a file is new the previous stat object is null.
+
+When watchTree is finished walking the tree and adding all the listeners it passes the file hash (keys are the file/directory names and the values are the current stat objects) as the first argument and null as both the previous and current stat object arguments.
+
+<pre>
+  watch.watchTree('/home/mikeal', function (f, curr, prev) {
+    if (typeof f == "object" && prev === null && curr === null) {
+      // Finished walking the tree
+    } else if (prev === null) {
+      // f is a new file
+    } else if (curr.nlink === 0) {
+      // f was removed
+    } else {
+      // f was changed
+    }
+  })
+</pre>
+
+### watch.createMonitor(root, [options,] callback)
+
+This function creates an EventEmitter that gives notifications for different changes that happen to the file and directory tree under the given root argument.
+
+The options object is passed to watch.watchTree.
+
+The callback receives the monitor object.
+
+The monitor object contains a property, `files`, which is a hash of files and directories as keys with the current stat object as the value.
+
+The monitor has the following events.
+
+* `'created'` - New file has been created. Two arguments, the filename and the stat object.
+* `'removed'` - A file has been moved or deleted. Two arguments, the filename and the stat object for the fd.
+* `'changed'` - A file has been changed. Three arguments, the filename, the current stat object, and the previous stat object.
+
+<pre>
+  var watch = require('watch')
+  watch.createMonitor('/home/mikeal', function (monitor) {
+    monitor.files['/home/mikeal/.zshrc'] // Stat object for my zshrc.
+    monitor.on("created", function (f, stat) {
+      // Handle new files
+    })
+    monitor.on("changed", function (f, curr, prev) {
+      // Handle file changes
+    })
+    monitor.on("removed", function (f, stat) {
+      // Handle removed files
+    })
+  })
+</pre>

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/node_modules/watch/test/test_monitor.js

@@ -0,0 +1,31 @@
+var watch = require('../main')
+  , assert = require('assert')
+  , path = require('path')
+  , fs = require('fs')
+  , target = path.join(__dirname, "d/t")
+  ;
+
+function clearFile() {
+  fs.writeFileSync(target, '')
+}
+
+clearFile()
+
+// test if changed event is fired correctly
+watch.createMonitor(__dirname, { interval: 150 },
+  function (monitor) {
+    monitor.once('changed', function (f) {
+      assert.equal(f, target);
+      clearFile();
+      process.exit(0)
+    })
+
+    fs.writeFile(target, 'Test Write\n', function (err) {
+      if (err) throw err;
+
+      setTimeout(function () {
+        // should have got the other assert done by now
+        assert.ok(false);
+      }, 300);
+    })
+});

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/node_modules/watch/test/test_monitorRootDirectory.js

@@ -0,0 +1,28 @@
+var fs, watch, watch_original;
+watch = require('../main');
+watch_original = require('watch');
+fs = require('fs');
+
+watch.createMonitor(__dirname, function (monitor) {
+    monitor.on("created", function (f, stat) {
+        console.log(f + " created");
+    });
+    monitor.on("changed", function (f, curr, prev) {
+        console.log(f + " changed");
+    });
+    monitor.on("removed", function (f, stat) {
+        console.log(f + " removed");
+    });
+});
+
+watch_original.createMonitor(__dirname, function (monitor) {
+    monitor.on("created", function (f, stat) {
+        console.log("ORIGINAL: " + f + " created");
+    });
+    monitor.on("changed", function (f, curr, prev) {
+        console.log("ORIGINAL: " + f + " changed");
+    });
+    monitor.on("removed", function (f, stat) {
+        console.log("ORIGINAL: " + f + " removed");
+    });
+});

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/node_modules/watch/test/test_watchTree.js

@@ -0,0 +1,20 @@
+var fs = require('fs')
+  , watch = require('../main')
+  , assert = require('assert')
+  ;
+
+//
+// Demonstrate that the function of 'filter' is semantically inconsistent with
+// usual convention, that returning true means 'keep this'.
+//
+function isDirOrQ(f, stat) { return stat.isDirectory() || f === 'Q'; }
+
+watch.watchTree(__dirname, { filter: isDirOrQ }, function (f, curr, prev) {
+  if (typeof f == 'object' && prev === null && curr === null) {
+    Object.keys(f).forEach(function(name) {
+      var stat = f[name];
+      assert(isDirOrQ(name, stat));
+      fs.unwatchFile(name);
+    });
+  }
+});

data/vendor/assets/javascripts/batman_rails_flo/node_modules/fb-flo/node_modules/sane/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "sane",
+  "version": "0.5.4",
+  "description": "Sane aims to be fast, small, and reliable file system watcher.",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amasad/sane"
+  },
+  "scripts": {
+    "test": "mocha --bail"
+  },
+  "keywords": [
+    "watch",
+    "file",
+    "fswatcher",
+    "watchfile",
+    "fs",
+    "watching"
+  ],
+  "author": {
+    "name": "amasad"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "walker": "~1.0.5",
+    "minimatch": "~0.2.14",
+    "watch": "~0.10.0"
+  },
+  "devDependencies": {
+    "mocha": "~1.17.1",
+    "rimraf": "~2.2.6"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "bugs": {
+    "url": "https://github.com/amasad/sane/issues"
+  },
+  "homepage": "https://github.com/amasad/sane",
+  "readme": "sane\n----\n\nI've been driven to insanity by node filesystem watcher wrappers.\nSane aims to be fast, small, and reliable file system watcher. It does that by:\n\n* Always use fs.watch (unless polling is forced) and sensibly workaround the various issues with it\n* Sane is all JavaScript, no native components\n* Stay away from polling because it's very slow and cpu intensive\n* Support polling for environments like Vagrant shared directory where there are no native filesystem events\n\n## Install\n\nRequires node >= v0.10.0.\n\n```\n$ npm install sane\n```\n\n## API\n\n### sane(dir, globs, options)\n\nWatches a directory and all it's descendant directorys for changes, deletions, and additions on files and directories.\nShortcut for `new sane.Watcher(dir, {glob: globs, ..options})`.\n\n```js\nvar watcher = sane('path/to/dir', ['**/*.js, '**/*.css']);\nwatcher.on('ready', function () { console.log('ready') });\nwatcher.on('change', function (filepath) { console.log('file changed', filepath); });\nwatcher.on('add', function (filepath) { console.log('file added', filepath); });\nwatcher.on('delete', function (filepath) { console.log('file deleted', filepath); });\n// close\nwatcher.close();\n```\n\nFor `options` see `sane.Watcher`.\n\n### sane.Watcher(dir, options)\n\noptions:\n\n* `persistent`: boolean indicating that the process shouldn't die while we're watching files.\n* `glob`: a single string glob pattern or an array of them.\n* `poll`: puts the watcher in polling mode. Under the hood that means `fs.watchFile`.\n* `interval`: indicates how often the files should be polled. (passed to `fs.watchFile`)\n\nFor the glob pattern documentation, see [minimatch](https://github.com/isaacs/minimatch).\n\n### sane.Watcher#close\n\nStops watching.\n\n### sane.Watcher events\n\nEmits the following events:\n\nAll events are passed the file/dir path relative to the root directory\n* `ready` when the program is ready to detect events in the directory\n* `change` when a file changes\n* `add` when a file or directory has been added\n* `delete` when a file or directory has been deleted\n\n## License\n\nMIT\n",
+  "readmeFilename": "README.md",
+  "_id": "sane@0.5.4",
+  "_from": "sane@~0.5.1"
+}

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

@@ -0,0 +1,243 @@
+var os = require('os');
+var fs = require('fs');
+var sane = require('../');
+var rimraf = require('rimraf');
+var path = require('path');
+var assert = require('assert');
+
+var tmpdir = os.tmpdir();
+var jo = path.join.bind(path);
+var testdir = jo(tmpdir, 'sane_test');
+
+
+describe('sane in polling mode', function() {
+  harness.call(this, true);
+});
+describe('sand in normal mode', function() {
+  harness.call(this, false);
+});
+
+function harness(isPolling) {
+  if (isPolling) this.timeout(5000);
+  before(function() {
+    rimraf.sync(testdir);
+      try {
+      fs.mkdirSync(testdir);
+    } catch (e) {}
+    for (var i = 0; i < 10; i++) {
+      fs.writeFileSync(jo(testdir, 'file_' + i), 'test_' + i);
+      var subdir = jo(testdir, 'sub_' + i);
+      try {
+        fs.mkdirSync(subdir);
+      } catch (e) {}
+      for (var j = 0; j < 10; j++) {
+        fs.writeFileSync(jo(subdir, 'file_' + j), 'test_' + j);
+      }
+    }
+  });
+
+  describe('sane(file)', function() {
+    beforeEach(function () {
+      this.watcher = new sane.Watcher(testdir, { poll: isPolling });
+    });
+
+    afterEach(function() {
+      this.watcher.close();
+    });
+
+    it('emits a ready event', function(done) {
+      this.watcher.on('ready', done);
+    });
+
+    it('change emits event', function(done) {
+      var testfile = jo(testdir, 'file_1');
+      this.watcher.on('change', function(filepath) {
+        assert.equal(filepath, path.relative(testdir, testfile));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        fs.writeFileSync(testfile, 'wow');
+      });
+    });
+
+    it('emits change events for subdir files', function(done) {
+      var testfile = jo(testdir, 'sub_1', 'file_1');
+      this.watcher.on('change', function(filepath) {
+        assert.equal(filepath, path.relative(testdir, testfile));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        fs.writeFileSync(testfile, 'wow');
+      });
+    });
+
+    it('adding a file will trigger a change', function(done) {
+      var testfile = jo(testdir, 'file_x' + Math.floor(Math.random() * 10000));
+      this.watcher.on('add', function(filepath) {
+        assert.equal(filepath, path.relative(testdir, testfile));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        fs.writeFileSync(testfile, 'wow');
+      });
+    });
+
+    it('removing a file will emit delete event', function(done) {
+      var testfile = jo(testdir, 'file_9');
+      this.watcher.on('delete', function(filepath) {
+        assert.equal(filepath, path.relative(testdir, testfile));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        fs.unlinkSync(testfile);
+      });
+    });
+
+    it('removing a dir will emit delete event', function(done) {
+      var subdir = jo(testdir, 'sub_9');
+      this.watcher.on('delete', function(filepath) {
+        // Ignore delete events for files in the dir.
+        if (path.dirname(filepath) === path.relative(testdir, subdir)) {
+          return;
+        }
+        assert.equal(filepath, path.relative(testdir, subdir));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        rimraf.sync(subdir);
+      });
+    });
+
+    it('adding a dir will emit an add event', function(done) {
+      var subdir = jo(testdir, 'sub_x' + Math.floor(Math.random() * 10000));
+      this.watcher.on('add', function(filepath) {
+        assert.equal(filepath, path.relative(testdir, subdir));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        fs.mkdirSync(subdir);
+      });
+    });
+
+    it('adding in a new subdir will trigger an add event', function(done) {
+      var subdir = jo(testdir, 'sub_x' + Math.floor(Math.random() * 10000));
+      var testfile = jo(subdir, 'file_x' + Math.floor(Math.random() * 10000));
+      var i = 0;
+      this.watcher.on('add', function(filepath) {
+        if (++i === 1) {
+          assert.equal(filepath, path.relative(testdir, subdir));
+        } else {
+          assert.equal(filepath, path.relative(testdir, testfile));
+          done();
+        }
+      });
+      this.watcher.on('ready', function() {
+        fs.mkdirSync(subdir);
+        defer(function() {
+          fs.writeFileSync(testfile, 'wow');
+        });
+      });
+    });
+
+    it('closes watchers when dirs are deleted', function(done) {
+      var subdir = jo(testdir, 'sub_1');
+      var testfile = jo(subdir, 'file_1');
+      var i = 0;
+      var actualFiles = {};
+      this.watcher.on('ready', function() {
+        this.watcher.on('add', function(filepath) {
+          actualFiles[filepath] = true;
+          if (Object.keys(actualFiles).length === 2) {
+            // win32 order is not guaranteed
+            var expectedFiles = {};
+            expectedFiles[path.relative(testdir, subdir)] = true;
+            expectedFiles[path.relative(testdir, testfile)] = true;
+            assert.deepEqual(
+              expectedFiles,
+              actualFiles
+            );
+            done();
+          }
+        });
+        rimraf.sync(subdir);
+        defer(function() {
+          fs.mkdirSync(subdir);
+          defer(function() {
+            fs.writeFileSync(testfile, 'wow');
+          });
+        });
+      }.bind(this));
+    });
+
+    it('should be ok to remove and then add the same file', function(done) {
+      var testfile = jo(testdir, 'sub_8', 'file_1');
+      var i = 0;
+      this.watcher.on('add', function(filepath) {
+        assert.equal(filepath, path.relative(testdir, testfile));
+      });
+      this.watcher.on('delete', function(filepath) {
+        assert.equal(filepath, path.relative(testdir, testfile));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        fs.unlink(testfile);
+        defer(function() {
+          fs.writeFileSync(testfile, 'wow');
+        });
+      });
+    });
+  });
+
+  describe('sane(file, glob)', function() {
+    beforeEach(function () {
+      this.watcher = new sane.Watcher(
+        testdir,
+        { glob: ['**/file_1', '**/file_2'], poll: isPolling }
+      );
+    });
+
+    afterEach(function() {
+      this.watcher.close();
+    });
+
+    it('ignore files according to glob', function (done) {
+      var i = 0;
+      this.watcher.on('change', function(filepath) {
+        assert.ok(filepath.match(/file_(1|2)/), 'only file_1 and file_2');
+        if (++i == 2) done();
+      });
+      this.watcher.on('ready', function() {
+        fs.writeFileSync(jo(testdir, 'file_1'), 'wow');
+        fs.writeFileSync(jo(testdir, 'file_9'), 'wow');
+        fs.writeFileSync(jo(testdir, 'file_3'), 'wow');
+        fs.writeFileSync(jo(testdir, 'file_2'), 'wow');
+      });
+    });
+  });
+
+  describe('sane shortcut alias', function () {
+    
+    beforeEach(function () {
+      this.watcher = sane(testdir, '**/file_1');
+    });
+
+    afterEach(function() {
+      this.watcher.close();
+    });
+
+    it('allows for shortcut mode using just a string as glob', function (done) { 
+      this.watcher.on('change', function (filepath) {
+        assert.ok(filepath.match(/file_1/));
+        done();
+      });
+      this.watcher.on('ready', function() {
+        fs.writeFileSync(jo(testdir, 'file_1'), 'wow');
+      });
+    });
+  });
+
+  function defer(fn) {
+    setTimeout(fn, isPolling ? 1000 : 300);
+  }
+
+}