vulcan 0.6.1 → 0.7.0

data/server/node_modules/cradle/node_modules/follow/Rakefile

@@ -0,0 +1,54 @@
+require 'json'
+
+LIBRARY = [ "api.js", "feed.js", "lib.js", "cli.js" ]
+BROWSER_TOOLS = Dir.glob("browser/*").select{|x| x != "browser/export.js" }
+
+task :default => :export
+
+desc 'Export Follow for use in web browsers'
+task :export => ([:clean, "cli.js"] + LIBRARY + BROWSER_TOOLS) do |task|
+  build = "./build"
+  target = "#{build}/follow"
+
+  sh "mkdir", "-p", target
+  LIBRARY.each do |js|
+    sh "node", "browser/export.js", js, "#{target}/#{js}"
+  end
+
+  BROWSER_TOOLS.each do |file|
+    sh "cp", file, build
+  end
+
+  # EventEmitter2 needs wrapping.
+  sh "node", "browser/export.js", "browser/eventemitter2.js", "#{build}/eventemitter2.js"
+
+  File.open("#{build}/boot.js", 'w') do |boot|
+    requirejs_paths = { 'request' => 'request.jquery',
+                        'events' => 'eventemitter2',
+                        # 'foo' => 'bar', etc.
+                      }
+
+    opts = { # 'baseUrl' => "follow",
+             'paths'   => requirejs_paths,
+           }
+
+    main_js = "main.js"
+
+    boot.write([ 'require(',
+                   '// Options',
+                   opts.to_json() + ',',
+                   '',
+                   '// Modules',
+                   [main_js].to_json() + ',',
+                   '',
+                   '// Code to run when ready',
+                   'function(main) { return main(); }',
+                 ');'
+               ].join("\n"));
+  end
+end
+
+desc 'Clean up build files'
+task :clean do
+  sh "rm", "-rf", "./build"
+end

data/server/node_modules/cradle/node_modules/follow/api.js

@@ -0,0 +1,35 @@
+// The changes_couchdb API
+//
+// Copyright 2011 Iris Couch
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+var feed = require('./lib/feed')
+  , stream = require('./lib/stream')
+
+function follow_feed(opts, cb) {
+  var ch_feed = new feed.Feed(opts);
+  ch_feed.on('error' , function(er) { return cb && cb.call(ch_feed, er) });
+  ch_feed.on('change', function(ch) { return cb && cb.call(ch_feed, null, ch) });
+
+  // Give the caller a chance to hook into any events.
+  process.nextTick(function() {
+    ch_feed.follow();
+  })
+
+  return ch_feed;
+}
+
+module.exports = follow_feed;
+module.exports.Feed = feed.Feed;
+module.exports.Changes = stream.Changes

data/server/node_modules/cradle/node_modules/follow/browser/eventemitter2.js

@@ -0,0 +1,453 @@
+
+;!function(exports, undefined) {
+
+  var isArray = Array.isArray;
+  var defaultMaxListeners = 10;
+
+  function init() {
+    this._events = new Object;
+  }
+
+  function configure(conf) {
+
+    if (conf) {
+      this.wildcard = conf.wildcard;
+      this.delimiter = conf.delimiter || '.';
+
+      if (this.wildcard) {
+        this.listenerTree = new Object;
+      }
+    }
+  }
+
+  function EventEmitter(conf) {
+    this._events = new Object;
+    configure.call(this, conf);
+  }
+
+  function searchListenerTree(handlers, type, tree, i) {
+    if (!tree) {
+      return;
+    }
+
+    var listeners;
+
+    if (i === type.length && tree._listeners) {
+      //
+      // If at the end of the event(s) list and the tree has listeners
+      // invoke those listeners.
+      //
+      if (typeof tree._listeners === 'function') {
+        handlers && handlers.push(tree._listeners);
+        return tree;
+      } else {
+        for (var leaf = 0, len = tree._listeners.length; leaf < len; leaf++) {
+          handlers && handlers.push(tree._listeners[leaf]);
+        }
+        return tree;
+      }
+    }
+
+    if (type[i] === '*' || tree[type[i]]) {
+      //
+      // If the event emitted is '*' at this part
+      // or there is a concrete match at this patch
+      //
+      if (type[i] === '*') {
+        for (var branch in tree) {
+          if (branch !== '_listeners' && tree.hasOwnProperty(branch)) {
+            listeners = searchListenerTree(handlers, type, tree[branch], i+1);
+          }
+        }
+        return listeners;
+      }
+
+      listeners = searchListenerTree(handlers, type, tree[type[i]], i+1);
+    }
+
+
+    if (tree['*']) {
+      //
+      // If the listener tree will allow any match for this part,
+      // then recursively explore all branches of the tree
+      //
+      searchListenerTree(handlers, type, tree['*'], i+1);
+    }
+
+    return listeners;
+  };
+
+  function growListenerTree(type, listener) {
+
+    type = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+
+    var tree = this.listenerTree;
+    var name = type.shift();
+
+    while (name) {
+
+      if (!tree[name]) {
+        tree[name] = new Object;
+      }
+
+      tree = tree[name];
+
+      if (type.length === 0) {
+
+        if (!tree._listeners) {
+          tree._listeners = listener;
+        }
+        else if(typeof tree._listeners === 'function') {
+          tree._listeners = [tree._listeners, listener];
+        }
+        else if (isArray(tree._listeners)) {
+
+          tree._listeners.push(listener);
+
+          if (!tree._listeners.warned) {
+
+            var m = defaultMaxListeners;
+
+            if (m > 0 && tree._listeners.length > m) {
+
+              tree._listeners.warned = true;
+              console.error('(node) warning: possible EventEmitter memory ' +
+                            'leak detected. %d listeners added. ' +
+                            'Use emitter.setMaxListeners() to increase limit.',
+                            tree._listeners.length);
+              console.trace();
+            }
+          }
+        }
+        return true;
+      }
+      name = type.shift();
+    }
+    return true;
+  };
+
+  // By default EventEmitters will print a warning if more than
+  // 10 listeners are added to it. This is a useful default which
+  // helps finding memory leaks.
+  //
+  // Obviously not all Emitters should be limited to 10. This function allows
+  // that to be increased. Set to zero for unlimited.
+
+  EventEmitter.prototype.setMaxListeners = function(n) {
+    this._events || init.call(this);
+    this._events.maxListeners = n;
+  };
+
+  EventEmitter.prototype.event = '';
+
+  EventEmitter.prototype.once = function(event, fn) {
+    this.many(event, 1, fn);
+    return this;
+  };
+
+  EventEmitter.prototype.many = function(event, ttl, fn) {
+    var self = this;
+
+    if (typeof fn !== 'function') {
+      throw new Error('many only accepts instances of Function');
+    }
+
+    function listener() {
+      if (--ttl === 0) {
+        self.off(event, listener);
+      }
+      fn.apply(null, arguments);
+    };
+
+    listener._origin = fn;
+
+    this.on(event, listener);
+
+    return self;
+  };
+
+  EventEmitter.prototype.emit = function() {
+    this._events || init.call(this);
+
+    var type = arguments[0];
+
+    if (type === 'newListener') {
+      if (!this._events.newListener) { return false; }
+    }
+
+    // Loop through the *_all* functions and invoke them.
+    if (this._all) {
+      var l = arguments.length;
+      var args = new Array(l - 1);
+      for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
+      for (i = 0, l = this._all.length; i < l; i++) {
+        this.event = type;
+        this._all[i].apply(this, args);
+      }
+    }
+
+    // If there is no 'error' event listener then throw.
+    if (type === 'error') {
+      
+      if (!this._all && 
+        !this._events.error && 
+        !(this.wildcard && this.listenerTree.error)) {
+
+        if (arguments[1] instanceof Error) {
+          throw arguments[1]; // Unhandled 'error' event
+        } else {
+          throw new Error("Uncaught, unspecified 'error' event.");
+        }
+        return false;
+      }
+    }
+
+    var handler;
+
+    if(this.wildcard) {
+      handler = [];
+      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+      searchListenerTree.call(this, handler, ns, this.listenerTree, 0);
+    }
+    else {
+      handler = this._events[type];
+    }
+
+    if (typeof handler === 'function') {
+      this.event = type;
+      if (arguments.length === 1) {
+        handler.call(this);
+      }
+      else if (arguments.length > 1)
+        switch (arguments.length) {
+          case 2:
+            handler.call(this, arguments[1]);
+            break;
+          case 3:
+            handler.call(this, arguments[1], arguments[2]);
+            break;
+          // slower
+          default:
+            var l = arguments.length;
+            var args = new Array(l - 1);
+            for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
+            handler.apply(this, args);
+        }
+      return true;
+    }
+    else if (handler) {
+      var l = arguments.length;
+      var args = new Array(l - 1);
+      for (var i = 1; i < l; i++) args[i - 1] = arguments[i];
+
+      var listeners = handler.slice();
+      for (var i = 0, l = listeners.length; i < l; i++) {
+        this.event = type;
+        listeners[i].apply(this, args);
+      }
+      return true;
+    }
+
+  };
+
+  EventEmitter.prototype.on = function(type, listener) {
+    this._events || init.call(this);
+
+    // To avoid recursion in the case that type == "newListeners"! Before
+    // adding it to the listeners, first emit "newListeners".
+    this.emit('newListener', type, listener);
+
+    if(this.wildcard) {
+      growListenerTree.call(this, type, listener);
+      return this;
+    }
+
+    if (!this._events[type]) {
+      // Optimize the case of one listener. Don't need the extra array object.
+      this._events[type] = listener;
+    }
+    else if(typeof this._events[type] === 'function') {
+      // Adding the second element, need to change to array.
+      this._events[type] = [this._events[type], listener];
+    }
+    else if (isArray(this._events[type])) {
+      // If we've already got an array, just append.
+      this._events[type].push(listener);
+
+      // Check for listener leak
+      if (!this._events[type].warned) {
+
+        var m;
+        if (this._events.maxListeners !== undefined) {
+          m = this._events.maxListeners;
+        } else {
+          m = defaultMaxListeners;
+        }
+
+        if (m && m > 0 && this._events[type].length > m) {
+
+          this._events[type].warned = true;
+          console.error('(node) warning: possible EventEmitter memory ' +
+                        'leak detected. %d listeners added. ' +
+                        'Use emitter.setMaxListeners() to increase limit.',
+                        this._events[type].length);
+          console.trace();
+        }
+      }
+    }
+    return this;
+  };
+
+  EventEmitter.prototype.onAny = function(fn) {
+
+    if(!this._all) {
+      this._all = [];
+    }
+
+    if (typeof fn !== 'function') {
+      throw new Error('onAny only accepts instances of Function');
+    }
+
+    // Add the function to the event listener collection.
+    this._all.push(fn);
+    return this;
+  };
+
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+
+  EventEmitter.prototype.off = function(type, listener) {
+    if (typeof listener !== 'function') {
+      throw new Error('removeListener only takes instances of Function');
+    }
+
+    var handlers;
+
+    if(this.wildcard) {
+      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+      var leaf = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
+
+      if('undefined' === typeof leaf) { return this; }
+      handlers = leaf._listeners;
+    }
+    else {
+      // does not use listeners(), so no side effect of creating _events[type]
+      if (!this._events[type]) return this;
+      handlers = this._events[type];
+    }
+
+    if (isArray(handlers)) {
+
+      var position = -1;
+
+      for (var i = 0, length = handlers.length; i < length; i++) {
+        if (handlers[i] === listener ||
+          (handlers[i].listener && handlers[i].listener === listener) ||
+          (handlers[i]._origin && handlers[i]._origin === listener)) {
+          position = i;
+          break;
+        }
+      }
+
+      if (position < 0) {
+        return this;
+      }
+
+      if(this.wildcard) {
+        leaf._listeners.splice(position, 1)
+      }
+      else {
+        this._events[type].splice(position, 1);
+      }
+
+      if (handlers.length === 0) {
+        if(this.wildcard) {
+          delete leaf._listeners;
+        }
+        else {
+          delete this._events[type];
+        }
+      }
+    }
+    else if (handlers === listener ||
+      (handlers.listener && handlers.listener === listener) ||
+      (handlers._origin && handlers._origin === listener)) {
+      if(this.wildcard) {
+        delete leaf._listeners;
+      }
+      else {
+        delete this._events[type];
+      }
+    }
+
+    return this;
+  };
+
+  EventEmitter.prototype.offAny = function(fn) {
+    var i = 0, l = 0, fns;
+    if (fn && this._all && this._all.length > 0) {
+      fns = this._all;
+      for(i = 0, l = fns.length; i < l; i++) {
+        if(fn === fns[i]) {
+          fns.splice(i, 1);
+          return this;
+        }
+      }
+    } else {
+      this._all = [];
+    }
+    return this;
+  };
+
+  EventEmitter.prototype.removeListener = EventEmitter.prototype.off;
+
+  EventEmitter.prototype.removeAllListeners = function(type) {
+    if (arguments.length === 0) {
+      !this._events || init.call(this);
+      return this;
+    }
+
+    if(this.wildcard) {
+      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+      var leaf = searchListenerTree.call(this, null, ns, this.listenerTree, 0);
+
+      if('undefined' === typeof leaf) { return this; }
+      leaf._listeners = null;
+    }
+    else {
+      if (!this._events[type]) return this;
+      this._events[type] = null;
+    }
+    return this;
+  };
+
+  EventEmitter.prototype.listeners = function(type) {
+    if(this.wildcard) {
+      var handlers = [];
+      var ns = typeof type === 'string' ? type.split(this.delimiter) : type.slice();
+      searchListenerTree.call(this, handlers, ns, this.listenerTree, 0);
+      return handlers;
+    }
+
+    this._events || init.call(this);
+
+    if (!this._events[type]) this._events[type] = [];
+    if (!isArray(this._events[type])) {
+      this._events[type] = [this._events[type]];
+    }
+    return this._events[type];
+  };
+
+  EventEmitter.prototype.listenersAny = function() {
+
+    if(this._all) {
+      return this._all;
+    }
+    else {
+      return [];
+    }
+
+  };
+
+  exports.EventEmitter2 = EventEmitter;
+
+}(typeof exports === 'undefined' ? window : exports);