passenger 5.0.21 → 5.0.22

data/src/nodejs_supportlib/vendor-copy/codify/package.json

@@ -0,0 +1,29 @@
+{
+  "author": {
+    "name": "Andrew J. Stone",
+    "email": "andrew.j.stone.1@bozuko.com"
+  },
+  "name": "codify",
+  "description": "Turn integers into base36 codes",
+  "version": "0.3.0",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/bozuko/codify.git"
+  },
+  "main": "codify.js",
+  "engines": {
+    "node": "*"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "readme": "Codify lets you transform integers to base36 strings and vice versa. All strings use uppercase letters.\n\n## Example\n\n    var codify = require('codify');\n    var code = codify.toCode(10); // 'A'\n    var testInt = codify.toInt(code); // 10\n\n    // Zero Extend\n    code = codify.toCode(0, 5); // '00000'",
+  "readmeFilename": "README.md",
+  "bugs": {
+    "url": "https://github.com/bozuko/codify/issues"
+  },
+  "homepage": "https://github.com/bozuko/codify",
+  "_id": "codify@0.3.0",
+  "_shasum": "5489ce3b1c087fab99536d25afbb4b14e4d762f1",
+  "_from": "codify@^0.3.0",
+  "_resolved": "https://registry.npmjs.org/codify/-/codify-0.3.0.tgz"
+}

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/context.js

@@ -0,0 +1,200 @@
+'use strict';
+
+var assert      = require('assert');
+var wrapEmitter = require('emitter-listener');
+
+/*
+ *
+ * CONSTANTS
+ *
+ */
+var CONTEXTS_SYMBOL = 'cls@contexts';
+var ERROR_SYMBOL = 'error@context';
+
+// load polyfill if native support is unavailable
+if (!process.addAsyncListener) require('async-listener');
+
+function Namespace(name) {
+  this.name   = name;
+  // changed in 2.7: no default context
+  this.active = null;
+  this._set   = [];
+  this.id     = null;
+}
+
+Namespace.prototype.set = function (key, value) {
+  if (!this.active) {
+    throw new Error("No context available. ns.run() or ns.bind() must be called first.");
+  }
+
+  this.active[key] = value;
+  return value;
+};
+
+Namespace.prototype.get = function (key) {
+  if (!this.active) return undefined;
+
+  return this.active[key];
+};
+
+Namespace.prototype.createContext = function () {
+  return Object.create(this.active);
+};
+
+Namespace.prototype.run = function (fn) {
+  var context = this.createContext();
+  this.enter(context);
+  try {
+    fn(context);
+    return context;
+  }
+  catch (exception) {
+    exception[ERROR_SYMBOL] = context;
+    throw exception;
+  }
+  finally {
+    this.exit(context);
+  }
+};
+
+Namespace.prototype.bind = function (fn, context) {
+  if (!context) {
+    if (!this.active) {
+      context = Object.create(this.active);
+    }
+    else {
+      context = this.active;
+    }
+  }
+
+  var self = this;
+  return function () {
+    self.enter(context);
+    try {
+      return fn.apply(this, arguments);
+    }
+    catch (exception) {
+      exception[ERROR_SYMBOL] = context;
+      throw exception;
+    }
+    finally {
+      self.exit(context);
+    }
+  };
+};
+
+Namespace.prototype.enter = function (context) {
+  assert.ok(context, "context must be provided for entering");
+
+  this._set.push(this.active);
+  this.active = context;
+};
+
+Namespace.prototype.exit = function (context) {
+  assert.ok(context, "context must be provided for exiting");
+
+  // Fast path for most exits that are at the top of the stack
+  if (this.active === context) {
+    assert.ok(this._set.length, "can't remove top context");
+    this.active = this._set.pop();
+    return;
+  }
+
+  // Fast search in the stack using lastIndexOf
+  var index = this._set.lastIndexOf(context);
+
+  assert.ok(index >= 0, "context not currently entered; can't exit");
+  assert.ok(index,      "can't remove top context");
+
+  this._set.splice(index, 1);
+};
+
+Namespace.prototype.bindEmitter = function (emitter) {
+  assert.ok(emitter.on && emitter.addListener && emitter.emit, "can only bind real EEs");
+
+  var namespace  = this;
+  var thisSymbol = 'context@' + this.name;
+
+  // Capture the context active at the time the emitter is bound.
+  function attach(listener) {
+    if (!listener) return;
+    if (!listener[CONTEXTS_SYMBOL]) listener[CONTEXTS_SYMBOL] = Object.create(null);
+
+    listener[CONTEXTS_SYMBOL][thisSymbol] = {
+      namespace : namespace,
+      context   : namespace.active
+    };
+  }
+
+  // At emit time, bind the listener within the correct context.
+  function bind(unwrapped) {
+    if (!(unwrapped && unwrapped[CONTEXTS_SYMBOL])) return unwrapped;
+
+    var wrapped  = unwrapped;
+    var contexts = unwrapped[CONTEXTS_SYMBOL];
+    Object.keys(contexts).forEach(function (name) {
+      var thunk = contexts[name];
+      wrapped = thunk.namespace.bind(wrapped, thunk.context);
+    });
+    return wrapped;
+  }
+
+  wrapEmitter(emitter, attach, bind);
+};
+
+/**
+ * If an error comes out of a namespace, it will have a context attached to it.
+ * This function knows how to find it.
+ *
+ * @param {Error} exception Possibly annotated error.
+ */
+Namespace.prototype.fromException = function (exception) {
+  return exception[ERROR_SYMBOL];
+};
+
+function get(name) {
+  return process.namespaces[name];
+}
+
+function create(name) {
+  assert.ok(name, "namespace must be given a name!");
+
+  var namespace = new Namespace(name);
+  namespace.id = process.addAsyncListener({
+    create : function () { return namespace.active; },
+    before : function (context, storage) { if (storage) namespace.enter(storage); },
+    after  : function (context, storage) { if (storage) namespace.exit(storage); },
+    error  : function (storage) { if (storage) namespace.exit(storage); }
+  });
+
+  process.namespaces[name] = namespace;
+  return namespace;
+}
+
+function destroy(name) {
+  var namespace = get(name);
+
+  assert.ok(namespace,    "can't delete nonexistent namespace!");
+  assert.ok(namespace.id, "don't assign to process.namespaces directly!");
+
+  process.removeAsyncListener(namespace.id);
+  process.namespaces[name] = null;
+}
+
+function reset() {
+  // must unregister async listeners
+  if (process.namespaces) {
+    Object.keys(process.namespaces).forEach(function (name) {
+      destroy(name);
+    });
+  }
+  process.namespaces = Object.create(null);
+}
+if (!process.namespaces) reset(); // call immediately to set up
+
+module.exports = {
+  getNamespace     : get,
+  createNamespace  : create,
+  destroyNamespace : destroy,
+  reset            : reset
+};

data/src/nodejs_supportlib/vendor-copy/continuation-local-storage/node_modules/async-listener/glue.js

@@ -0,0 +1,488 @@
+var wrap = require('shimmer').wrap;
+
+/*
+ *
+ * CONSTANTS
+ *
+ */
+var HAS_CREATE_AL = 1 << 0;
+var HAS_BEFORE_AL = 1 << 1;
+var HAS_AFTER_AL = 1 << 2;
+var HAS_ERROR_AL = 1 << 3;
+
+/**
+ * There is one list of currently active listeners that is mutated in place by
+ * addAsyncListener and removeAsyncListener. This complicates error-handling,
+ * for reasons that are discussed below.
+ */
+var listeners = [];
+
+/**
+ * There can be multiple listeners with the same properties, so disambiguate
+ * them by assigning them an ID at creation time.
+ */
+var uid = 0;
+
+/**
+ * Ensure that errors coming from within listeners are handed off to domains,
+ * process._fatalException, or uncaughtException without being treated like
+ * user errors.
+ */
+var inAsyncTick = false;
+
+/**
+ * Because asynchronous contexts can be nested, and errors can come from anywhere
+ * in the stack, a little extra work is required to keep track of where in the
+ * nesting we are. Because JS arrays are frequently mutated in place
+ */
+var listenerStack = [];
+
+/**
+ * The error handler on a listener can capture errors thrown during synchronous
+ * execution immediately after the listener is added. To capture both
+ * synchronous and asynchronous errors, the error handler just uses the
+ * "global" list of active listeners, and the rest of the code ensures that the
+ * listener list is correct by using a stack of listener lists during
+ * asynchronous execution.
+ */
+var asyncCatcher;
+
+/**
+ * The guts of the system -- called each time an asynchronous event happens
+ * while one or more listeners are active.
+ */
+var asyncWrap;
+
+/**
+ * Simple helper function that's probably faster than using Array
+ * filter methods and can be inlined.
+ */
+function union(dest, added) {
+  var destLength = dest.length;
+  var addedLength = added.length;
+  var returned = [];
+
+  if (destLength === 0 && addedLength === 0) return returned;
+
+  for (var j  = 0; j < destLength; j++) returned[j] = dest[j];
+
+  if (addedLength === 0) return returned;
+
+  for (var i = 0; i < addedLength; i++) {
+    var missing = true;
+    for (j = 0; j < destLength; j++) {
+      if (dest[j].uid === added[i].uid) {
+        missing = false;
+        break;
+      }
+    }
+    if (missing) returned.push(added[i]);
+  }
+
+  return returned;
+}
+
+/*
+ * For performance, split error-handlers and asyncCatcher up into two separate
+ * code paths.
+ */
+
+// 0.9+
+if (process._fatalException) {
+  /**
+   * Error handlers on listeners can throw, the the catcher needs to be able to
+   * discriminate between exceptions thrown by user code, and exceptions coming
+   * from within the catcher itself. Use a global to keep track of which state
+   * the catcher is currently in.
+   */
+  var inErrorTick = false;
+
+  /**
+   * Throwing always happens synchronously. If the current array of values for
+   * the current list of asyncListeners is put in a module-scoped variable right
+   * before a call that can throw, it will always be correct when the error
+   * handlers are run.
+   */
+  var errorValues;
+
+  asyncCatcher = function asyncCatcher(er) {
+    var length = listeners.length;
+    if (inErrorTick || length === 0) return false;
+
+    var handled = false;
+
+    /*
+     * error handlers
+     */
+    inErrorTick = true;
+    for (var i = 0; i < length; ++i) {
+      var listener = listeners[i];
+      if ((listener.flags & HAS_ERROR_AL) === 0) continue;
+
+      var value = errorValues && errorValues[listener.uid];
+      handled = listener.error(value, er) || handled;
+    }
+    inErrorTick = false;
+
+    /* Test whether there are any listener arrays on the stack. In the case of
+     * synchronous throws when the listener is active, there may have been
+     * none pushed yet.
+     */
+    if (listenerStack.length > 0) listeners = listenerStack.pop();
+    errorValues = undefined;
+
+    return handled && !inAsyncTick;
+  };
+
+  asyncWrap = function asyncWrap(original, list, length) {
+    var values = [];
+
+    /*
+     * listeners
+     */
+    inAsyncTick = true;
+    for (var i = 0; i < length; ++i) {
+      var listener = list[i];
+      values[listener.uid] = listener.data;
+
+      if ((listener.flags & HAS_CREATE_AL) === 0) continue;
+
+      var value = listener.create(listener.data);
+      if (value !== undefined) values[listener.uid] = value;
+    }
+    inAsyncTick = false;
+
+    /* One of the main differences between this polyfill and the core
+     * asyncListener support is that core avoids creating closures by putting a
+     * lot of the state managemnt on the C++ side of Node (and of course also it
+     * bakes support for async listeners into the Node C++ API through the
+     * AsyncWrap class, which means that it doesn't monkeypatch basically every
+     * async method like this does).
+     */
+    return function () {
+      // put the current values where the catcher can see them
+      errorValues = values;
+
+      /* More than one listener can end up inside these closures, so save the
+       * current listeners on a stack.
+       */
+      listenerStack.push(listeners);
+
+      /* Activate both the listeners that were active when the closure was
+       * created and the listeners that were previously active.
+       */
+      listeners = union(list, listeners);
+
+      /*
+       * before handlers
+       */
+      inAsyncTick = true;
+      for (var i = 0; i < length; ++i) {
+        if ((list[i].flags & HAS_BEFORE_AL) > 0) {
+          list[i].before(this, values[list[i].uid]);
+        }
+      }
+      inAsyncTick = false;
+
+      // save the return value to pass to the after callbacks
+      var returned = original.apply(this, arguments);
+
+      /*
+       * after handlers (not run if original throws)
+       */
+      inAsyncTick = true;
+      for (i = 0; i < length; ++i) {
+        if ((list[i].flags & HAS_AFTER_AL) > 0) {
+          list[i].after(this, values[list[i].uid]);
+        }
+      }
+      inAsyncTick = false;
+
+      // back to the previous listener list on the stack
+      listeners = listenerStack.pop();
+      errorValues = undefined;
+
+      return returned;
+    };
+  };
+
+  wrap(process, '_fatalException', function (_fatalException) {
+    return function _asyncFatalException(er) {
+      return asyncCatcher(er) || _fatalException(er);
+    };
+  });
+}
+// 0.8 and below
+else {
+  /**
+   * If an error handler in asyncWrap throws, the process must die. Under 0.8
+   * and earlier the only way to put a bullet through the head of the process
+   * is to rethrow from inside the exception handler, so rethrow and set
+   * errorThrew to tell the uncaughtHandler what to do.
+   */
+  var errorThrew = false;
+
+  /**
+   * Under Node 0.8, this handler *only* handles synchronously thrown errors.
+   * This simplifies it, which almost but not quite makes up for the hit taken
+   * by putting everything in a try-catch.
+   */
+  asyncCatcher = function uncaughtCatcher(er) {
+    // going down hard
+    if (errorThrew) throw er;
+
+    var handled = false;
+
+    /*
+     * error handlers
+     */
+    var length = listeners.length;
+    for (var i = 0; i < length; ++i) {
+      var listener = listeners[i];
+      if ((listener.flags & HAS_ERROR_AL) === 0) continue;
+      handled = listener.error(null, er) || handled;
+    }
+
+    /* Rethrow if one of the before / after handlers fire, which will bring the
+     * process down immediately.
+     */
+    if (!handled && inAsyncTick) throw er;
+  };
+
+  asyncWrap = function asyncWrap(original, list, length) {
+    var values = [];
+
+    /*
+     * listeners
+     */
+    inAsyncTick = true;
+    for (var i = 0; i < length; ++i) {
+      var listener = list[i];
+      values[listener.uid] = listener.data;
+
+      if ((listener.flags & HAS_CREATE_AL) === 0) continue;
+
+      var value = listener.create(listener.data);
+      if (value !== undefined) values[listener.uid] = value;
+    }
+    inAsyncTick = false;
+
+    /* One of the main differences between this polyfill and the core
+     * asyncListener support is that core avoids creating closures by putting a
+     * lot of the state managemnt on the C++ side of Node (and of course also it
+     * bakes support for async listeners into the Node C++ API through the
+     * AsyncWrap class, which means that it doesn't monkeypatch basically every
+     * async method like this does).
+     */
+    return function () {
+      /*jshint maxdepth:4*/
+
+      // after() handlers don't run if threw
+      var threw = false;
+
+      // ...unless the error is handled
+      var handled = false;
+
+      /* More than one listener can end up inside these closures, so save the
+       * current listeners on a stack.
+       */
+      listenerStack.push(listeners);
+
+      /* Activate both the listeners that were active when the closure was
+       * created and the listeners that were previously active.
+       */
+      listeners = union(list, listeners);
+
+      /*
+       * before handlers
+       */
+      inAsyncTick = true;
+      for (var i = 0; i < length; ++i) {
+        if ((list[i].flags & HAS_BEFORE_AL) > 0) {
+          list[i].before(this, values[list[i].uid]);
+        }
+      }
+      inAsyncTick = false;
+
+      // save the return value to pass to the after callbacks
+      var returned;
+      try {
+        returned = original.apply(this, arguments);
+      }
+      catch (er) {
+        threw = true;
+        for (var i = 0; i < length; ++i) {
+          if ((listeners[i].flags & HAS_ERROR_AL) == 0) continue;
+          try {
+            handled = listeners[i].error(values[list[i].uid], er) || handled;
+          }
+          catch (x) {
+            errorThrew = true;
+            throw x;
+          }
+        }
+
+        if (!handled) {
+          // having an uncaughtException handler here alters crash semantics
+          process.removeListener('uncaughtException', asyncCatcher);
+          process._originalNextTick(function () {
+            process.addListener('uncaughtException', asyncCatcher);
+          });
+
+          throw er;
+        }
+      }
+      finally {
+        /*
+         * after handlers (not run if original throws)
+         */
+        if (!threw || handled) {
+          inAsyncTick = true;
+          for (i = 0; i < length; ++i) {
+            if ((list[i].flags & HAS_AFTER_AL) > 0) {
+              list[i].after(this, values[list[i].uid]);
+            }
+          }
+          inAsyncTick = false;
+        }
+
+        // back to the previous listener list on the stack
+        listeners = listenerStack.pop();
+      }
+
+
+      return returned;
+    };
+  };
+
+  // will be the first to fire if async-listener is the first module loaded
+  process.addListener('uncaughtException', asyncCatcher);
+}
+
+// for performance in the case where there are no handlers, just the listener
+function simpleWrap(original, list, length) {
+  inAsyncTick = true;
+  for (var i = 0; i < length; ++i) {
+    var listener = list[i];
+    if (listener.create) listener.create(listener.data);
+  }
+  inAsyncTick = false;
+
+  // still need to make sure nested async calls are made in the context
+  // of the listeners active at their creation
+  return function () {
+    listenerStack.push(listeners);
+    listeners = union(list, listeners);
+
+    var returned = original.apply(this, arguments);
+
+    listeners = listenerStack.pop();
+
+    return returned;
+  };
+}
+
+/**
+ * Called each time an asynchronous function that's been monkeypatched in
+ * index.js is called. If there are no listeners, return the function
+ * unwrapped.  If there are any asyncListeners and any of them have callbacks,
+ * pass them off to asyncWrap for later use, otherwise just call the listener.
+ */
+function wrapCallback(original) {
+  var length = listeners.length;
+
+  // no context to capture, so avoid closure creation
+  if (length === 0) return original;
+
+  // capture the active listeners as of when the wrapped function was called
+  var list = listeners.slice();
+
+  for (var i = 0; i < length; ++i) {
+    if (list[i].flags > 0) return asyncWrap(original, list, length);
+  }
+
+  return simpleWrap(original, list, length);
+}
+
+function AsyncListener(callbacks, data) {
+  if (typeof callbacks.create === 'function') {
+    this.create = callbacks.create;
+    this.flags |= HAS_CREATE_AL;
+  }
+
+  if (typeof callbacks.before === 'function') {
+    this.before = callbacks.before;
+    this.flags |= HAS_BEFORE_AL;
+  }
+
+  if (typeof callbacks.after === 'function') {
+    this.after = callbacks.after;
+    this.flags |= HAS_AFTER_AL;
+  }
+
+  if (typeof callbacks.error === 'function') {
+    this.error = callbacks.error;
+    this.flags |= HAS_ERROR_AL;
+  }
+
+  this.uid = ++uid;
+  this.data = data === undefined ? null : data;
+}
+AsyncListener.prototype.create = undefined;
+AsyncListener.prototype.before = undefined;
+AsyncListener.prototype.after  = undefined;
+AsyncListener.prototype.error  = undefined;
+AsyncListener.prototype.data   = undefined;
+AsyncListener.prototype.uid    = 0;
+AsyncListener.prototype.flags  = 0;
+
+function createAsyncListener(callbacks, data) {
+  if (typeof callbacks !== 'object' || !callbacks) {
+    throw new TypeError('callbacks argument must be an object');
+  }
+
+  if (callbacks instanceof AsyncListener) {
+    return callbacks;
+  }
+  else {
+    return new AsyncListener(callbacks, data);
+  }
+}
+
+function addAsyncListener(callbacks, data) {
+  var listener;
+  if (!(callbacks instanceof AsyncListener)) {
+    listener = createAsyncListener(callbacks, data);
+  }
+  else {
+    listener = callbacks;
+  }
+
+  // Make sure the listener isn't already in the list.
+  var registered = false;
+  for (var i = 0; i < listeners.length; i++) {
+    if (listener === listeners[i]) {
+      registered = true;
+      break;
+    }
+  }
+
+  if (!registered) listeners.push(listener);
+
+  return listener;
+}
+
+function removeAsyncListener(listener) {
+  for (var i = 0; i < listeners.length; i++) {
+    if (listener === listeners[i]) {
+      listeners.splice(i, 1);
+      break;
+    }
+  }
+}
+
+process.createAsyncListener = createAsyncListener;
+process.addAsyncListener    = addAsyncListener;
+process.removeAsyncListener = removeAsyncListener;
+
+module.exports = wrapCallback;