initial

familyark/app/node_modules/mongoose/lib/drivers/SPEC.md

@@ -0,0 +1,4 @@
+
+# Driver Spec
+
+TODO

familyark/app/node_modules/mongoose/lib/drivers/browser/ReadPreference.js

@@ -0,0 +1,5 @@
+/*!
+ * ignore
+ */
+
+module.exports = function() {};

familyark/app/node_modules/mongoose/lib/drivers/browser/binary.js

@@ -0,0 +1,12 @@
+
+/*!
+ * Module dependencies.
+ */
+
+var Binary = require('bson').Binary;
+
+/*!
+ * Module exports.
+ */
+
+module.exports = exports = Binary;

familyark/app/node_modules/mongoose/lib/drivers/browser/decimal128.js

@@ -0,0 +1,5 @@
+/*!
+ * ignore
+ */
+
+module.exports = require('bson').Decimal128;

familyark/app/node_modules/mongoose/lib/drivers/browser/index.js

@@ -0,0 +1,8 @@
+/*!
+ * Module exports.
+ */
+
+exports.Binary = require('./binary');
+exports.Decimal128 = require('./decimal128');
+exports.ObjectId = require('./objectid');
+exports.ReadPreference = require('./ReadPreference');

familyark/app/node_modules/mongoose/lib/drivers/browser/objectid.js

@@ -0,0 +1,14 @@
+
+/*!
+ * [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) ObjectId
+ * @constructor NodeMongoDbObjectId
+ * @see ObjectId
+ */
+
+var ObjectId = require('bson').ObjectID;
+
+/*!
+ * ignore
+ */
+
+module.exports = exports = ObjectId;

familyark/app/node_modules/mongoose/lib/drivers/index.js

@@ -0,0 +1,20 @@
+/*!
+ * ignore
+ */
+
+var driver;
+
+if (typeof window === 'undefined') {
+  driver = require('./node-mongodb-native');
+  if (global.MONGOOSE_DRIVER_PATH) {
+    driver = require(global.MONGOOSE_DRIVER_PATH);
+  }
+} else {
+  driver = require('./browser');
+}
+
+/*!
+ * ignore
+ */
+
+module.exports = driver;

familyark/app/node_modules/mongoose/lib/drivers/index.web.js

@@ -0,0 +1,5 @@
+/*!
+ * ignore
+ */
+
+module.exports = require('./browser');

familyark/app/node_modules/mongoose/lib/drivers/node-mongodb-native/ReadPreference.js

@@ -0,0 +1,45 @@
+/*!
+ * Module dependencies.
+ */
+
+var mongodb = require('mongodb');
+var ReadPref = mongodb.ReadPreference;
+
+/*!
+ * Converts arguments to ReadPrefs the driver
+ * can understand.
+ *
+ * @param {String|Array} pref
+ * @param {Array} [tags]
+ */
+
+module.exports = function readPref(pref, tags) {
+  if (Array.isArray(pref)) {
+    tags = pref[1];
+    pref = pref[0];
+  }
+
+  if (pref instanceof ReadPref) {
+    return pref;
+  }
+
+  switch (pref) {
+    case 'p':
+      pref = 'primary';
+      break;
+    case 'pp':
+      pref = 'primaryPreferred';
+      break;
+    case 's':
+      pref = 'secondary';
+      break;
+    case 'sp':
+      pref = 'secondaryPreferred';
+      break;
+    case 'n':
+      pref = 'nearest';
+      break;
+  }
+
+  return new ReadPref(pref, tags);
+};

familyark/app/node_modules/mongoose/lib/drivers/node-mongodb-native/binary.js

@@ -0,0 +1,8 @@
+
+/*!
+ * Module dependencies.
+ */
+
+var Binary = require('mongodb').Binary;
+
+module.exports = exports = Binary;

familyark/app/node_modules/mongoose/lib/drivers/node-mongodb-native/collection.js

@@ -0,0 +1,271 @@
+/*!
+ * Module dependencies.
+ */
+
+var MongooseCollection = require('../../collection');
+var Collection = require('mongodb').Collection;
+var utils = require('../../utils');
+
+/**
+ * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) collection implementation.
+ *
+ * All methods methods from the [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) driver are copied and wrapped in queue management.
+ *
+ * @inherits Collection
+ * @api private
+ */
+
+function NativeCollection() {
+  this.collection = null;
+  MongooseCollection.apply(this, arguments);
+}
+
+/*!
+ * Inherit from abstract Collection.
+ */
+
+NativeCollection.prototype.__proto__ = MongooseCollection.prototype;
+
+/**
+ * Called when the connection opens.
+ *
+ * @api private
+ */
+
+NativeCollection.prototype.onOpen = function() {
+  var _this = this;
+
+  // always get a new collection in case the user changed host:port
+  // of parent db instance when re-opening the connection.
+
+  if (!_this.opts.capped.size) {
+    // non-capped
+    callback(null, _this.conn.db.collection(_this.name));
+    return _this.collection;
+  }
+
+  // capped
+  return _this.conn.db.collection(_this.name, function(err, c) {
+    if (err) return callback(err);
+
+    // discover if this collection exists and if it is capped
+    _this.conn.db.listCollections({name: _this.name}).toArray(function(err, docs) {
+      if (err) {
+        return callback(err);
+      }
+      var doc = docs[0];
+      var exists = !!doc;
+
+      if (exists) {
+        if (doc.options && doc.options.capped) {
+          callback(null, c);
+        } else {
+          var msg = 'A non-capped collection exists with the name: ' + _this.name + '\n\n'
+              + ' To use this collection as a capped collection, please '
+              + 'first convert it.\n'
+              + ' http://www.mongodb.org/display/DOCS/Capped+Collections#CappedCollections-Convertingacollectiontocapped';
+          err = new Error(msg);
+          callback(err);
+        }
+      } else {
+        // create
+        var opts = utils.clone(_this.opts.capped);
+        opts.capped = true;
+        _this.conn.db.createCollection(_this.name, opts, callback);
+      }
+    });
+  });
+
+  function callback(err, collection) {
+    if (err) {
+      // likely a strict mode error
+      _this.conn.emit('error', err);
+    } else {
+      _this.collection = collection;
+      MongooseCollection.prototype.onOpen.call(_this);
+    }
+  }
+};
+
+/**
+ * Called when the connection closes
+ *
+ * @api private
+ */
+
+NativeCollection.prototype.onClose = function(force) {
+  MongooseCollection.prototype.onClose.call(this, force);
+};
+
+/*!
+ * Copy the collection methods and make them subject to queues
+ */
+
+function iter(i) {
+  NativeCollection.prototype[i] = function() {
+    // If user force closed, queueing will hang forever. See #5664
+    if (this.opts.$wasForceClosed) {
+      return this.conn.db.collection(this.name)[i].apply(collection, args);
+    }
+    if (this.buffer) {
+      this.addQueue(i, arguments);
+      return;
+    }
+
+    var collection = this.collection;
+    var args = arguments;
+    var _this = this;
+    var debug = _this.conn.base.options.debug;
+
+    if (debug) {
+      if (typeof debug === 'function') {
+        debug.apply(_this,
+          [_this.name, i].concat(utils.args(args, 0, args.length - 1)));
+      } else {
+        this.$print(_this.name, i, args);
+      }
+    }
+
+    try {
+      return collection[i].apply(collection, args);
+    } catch (error) {
+      // Collection operation may throw because of max bson size, catch it here
+      // See gh-3906
+      if (args.length > 0 &&
+          typeof args[args.length - 1] === 'function') {
+        args[args.length - 1](error);
+      } else {
+        throw error;
+      }
+    }
+  };
+}
+
+for (var i in Collection.prototype) {
+  // Janky hack to work around gh-3005 until we can get rid of the mongoose
+  // collection abstraction
+  try {
+    if (typeof Collection.prototype[i] !== 'function') {
+      continue;
+    }
+  } catch (e) {
+    continue;
+  }
+
+  iter(i);
+}
+
+/**
+ * Debug print helper
+ *
+ * @api public
+ * @method $print
+ */
+
+NativeCollection.prototype.$print = function(name, i, args) {
+  var moduleName = '\x1B[0;36mMongoose:\x1B[0m ';
+  var functionCall = [name, i].join('.');
+  var _args = [];
+  for (var j = args.length - 1; j >= 0; --j) {
+    if (this.$format(args[j]) || _args.length) {
+      _args.unshift(this.$format(args[j]));
+    }
+  }
+  var params = '(' + _args.join(', ') + ')';
+
+  console.error(moduleName + functionCall + params);
+};
+
+/**
+ * Formatter for debug print args
+ *
+ * @api public
+ * @method $format
+ */
+
+NativeCollection.prototype.$format = function(arg) {
+  var type = typeof arg;
+  if (type === 'function' || type === 'undefined') return '';
+  return format(arg);
+};
+
+/*!
+ * Debug print helper
+ */
+
+function map(o) {
+  return format(o, true);
+}
+function formatObjectId(x, key) {
+  var representation = 'ObjectId("' + x[key].toHexString() + '")';
+  x[key] = {inspect: function() { return representation; }};
+}
+function formatDate(x, key) {
+  var representation = 'new Date("' + x[key].toUTCString() + '")';
+  x[key] = {inspect: function() { return representation; }};
+}
+function format(obj, sub) {
+  if (obj && typeof obj.toBSON === 'function') {
+    obj = obj.toBSON();
+  }
+  var x = utils.clone(obj, {retainKeyOrder: 1, transform: false});
+  var representation;
+
+  if (x != null) {
+    if (x.constructor.name === 'Binary') {
+      x = 'BinData(' + x.sub_type + ', "' + x.toString('base64') + '")';
+    } else if (x.constructor.name === 'ObjectID') {
+      representation = 'ObjectId("' + x.toHexString() + '")';
+      x = {inspect: function() { return representation; }};
+    } else if (x.constructor.name === 'Date') {
+      representation = 'new Date("' + x.toUTCString() + '")';
+      x = {inspect: function() { return representation; }};
+    } else if (x.constructor.name === 'Object') {
+      var keys = Object.keys(x);
+      var numKeys = keys.length;
+      var key;
+      for (var i = 0; i < numKeys; ++i) {
+        key = keys[i];
+        if (x[key]) {
+          if (typeof x[key].toBSON === 'function') {
+            x[key] = x[key].toBSON();
+          }
+          if (x[key].constructor.name === 'Binary') {
+            x[key] = 'BinData(' + x[key].sub_type + ', "' +
+              x[key].buffer.toString('base64') + '")';
+          } else if (x[key].constructor.name === 'Object') {
+            x[key] = format(x[key], true);
+          } else if (x[key].constructor.name === 'ObjectID') {
+            formatObjectId(x, key);
+          } else if (x[key].constructor.name === 'Date') {
+            formatDate(x, key);
+          } else if (Array.isArray(x[key])) {
+            x[key] = x[key].map(map);
+          }
+        }
+      }
+    }
+    if (sub) return x;
+  }
+
+  return require('util')
+  .inspect(x, false, 10, true)
+  .replace(/\n/g, '')
+  .replace(/\s{2,}/g, ' ');
+}
+
+/**
+ * Retreives information about this collections indexes.
+ *
+ * @param {Function} callback
+ * @method getIndexes
+ * @api public
+ */
+
+NativeCollection.prototype.getIndexes = NativeCollection.prototype.indexInformation;
+
+/*!
+ * Module exports.
+ */
+
+module.exports = NativeCollection;

familyark/app/node_modules/mongoose/lib/drivers/node-mongodb-native/connection.js

@@ -0,0 +1,403 @@
+/*!
+ * Module dependencies.
+ */
+
+var MongooseConnection = require('../../connection');
+var mongo = require('mongodb');
+var Db = mongo.Db;
+var Server = mongo.Server;
+var Mongos = mongo.Mongos;
+var STATES = require('../../connectionstate');
+var ReplSetServers = mongo.ReplSet;
+var DisconnectedError = require('../../error/disconnected');
+
+/**
+ * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) connection implementation.
+ *
+ * @inherits Connection
+ * @api private
+ */
+
+function NativeConnection() {
+  MongooseConnection.apply(this, arguments);
+  this._listening = false;
+}
+
+/**
+ * Expose the possible connection states.
+ * @api public
+ */
+
+NativeConnection.STATES = STATES;
+
+/*!
+ * Inherits from Connection.
+ */
+
+NativeConnection.prototype.__proto__ = MongooseConnection.prototype;
+
+/**
+ * Opens the connection to MongoDB.
+ *
+ * @param {Function} fn
+ * @return {Connection} this
+ * @api private
+ */
+
+NativeConnection.prototype.doOpen = function(fn) {
+  var _this = this;
+  var server = new Server(this.host, this.port, this.options.server);
+
+  if (this.options && this.options.mongos) {
+    var mongos = new Mongos([server], this.options.mongos);
+    this.db = new Db(this.name, mongos, this.options.db);
+  } else {
+    this.db = new Db(this.name, server, this.options.db);
+  }
+
+  this.db.open(function(err) {
+    listen(_this);
+
+    if (!mongos) {
+      server.s.server.on('error', function(error) {
+        if (/after \d+ attempts/.test(error.message)) {
+          _this.emit('error', new DisconnectedError(server.s.server.name));
+        }
+      });
+    }
+
+    if (err) return fn(err);
+
+    fn();
+  });
+
+  return this;
+};
+
+/**
+ * Switches to a different database using the same connection pool.
+ *
+ * Returns a new connection object, with the new db.
+ *
+ * @param {String} name The database name
+ * @return {Connection} New Connection Object
+ * @api public
+ */
+
+NativeConnection.prototype.useDb = function(name) {
+  // we have to manually copy all of the attributes...
+  var newConn = new this.constructor();
+  newConn.name = name;
+  newConn.base = this.base;
+  newConn.collections = {};
+  newConn.models = {};
+  newConn.replica = this.replica;
+  newConn.hosts = this.hosts;
+  newConn.host = this.host;
+  newConn.port = this.port;
+  newConn.user = this.user;
+  newConn.pass = this.pass;
+  newConn.options = this.options;
+  newConn._readyState = this._readyState;
+  newConn._closeCalled = this._closeCalled;
+  newConn._hasOpened = this._hasOpened;
+  newConn._listening = false;
+
+  // First, when we create another db object, we are not guaranteed to have a
+  // db object to work with. So, in the case where we have a db object and it
+  // is connected, we can just proceed with setting everything up. However, if
+  // we do not have a db or the state is not connected, then we need to wait on
+  // the 'open' event of the connection before doing the rest of the setup
+  // the 'connected' event is the first time we'll have access to the db object
+
+  var _this = this;
+
+  if (this.db && this._readyState === STATES.connected) {
+    wireup();
+  } else {
+    this.once('connected', wireup);
+  }
+
+  function wireup() {
+    newConn.db = _this.db.db(name);
+    newConn.onOpen();
+    // setup the events appropriately
+    listen(newConn);
+  }
+
+  newConn.name = name;
+
+  // push onto the otherDbs stack, this is used when state changes
+  this.otherDbs.push(newConn);
+  newConn.otherDbs.push(this);
+
+  return newConn;
+};
+
+/*!
+ * Register listeners for important events and bubble appropriately.
+ */
+
+function listen(conn) {
+  if (conn.db._listening) {
+    return;
+  }
+  conn.db._listening = true;
+
+  conn.db.on('close', function(force) {
+    if (conn._closeCalled) return;
+
+    // the driver never emits an `open` event. auto_reconnect still
+    // emits a `close` event but since we never get another
+    // `open` we can't emit close
+    if (conn.db.serverConfig.autoReconnect) {
+      conn.readyState = STATES.disconnected;
+      conn.emit('close');
+      return;
+    }
+    conn.onClose(force);
+  });
+  conn.db.on('error', function(err) {
+    conn.emit('error', err);
+  });
+  conn.db.on('reconnect', function() {
+    conn.readyState = STATES.connected;
+    conn.emit('reconnect');
+    conn.emit('reconnected');
+    conn.onOpen();
+  });
+  conn.db.on('timeout', function(err) {
+    conn.emit('timeout', err);
+  });
+  conn.db.on('open', function(err, db) {
+    if (STATES.disconnected === conn.readyState && db && db.databaseName) {
+      conn.readyState = STATES.connected;
+      conn.emit('reconnect');
+      conn.emit('reconnected');
+    }
+  });
+  conn.db.on('parseError', function(err) {
+    conn.emit('parseError', err);
+  });
+}
+
+/**
+ * Opens a connection to a MongoDB ReplicaSet.
+ *
+ * See description of [doOpen](#NativeConnection-doOpen) for server options. In this case `options.replset` is also passed to ReplSetServers.
+ *
+ * @param {Function} fn
+ * @api private
+ * @return {Connection} this
+ */
+
+NativeConnection.prototype.doOpenSet = function(fn) {
+  var servers = [],
+      _this = this;
+
+  this.hosts.forEach(function(server) {
+    var host = server.host || server.ipc;
+    var port = server.port || 27017;
+    servers.push(new Server(host, port, _this.options.server));
+  });
+
+  var server = this.options.mongos
+    ? new Mongos(servers, this.options.mongos)
+    : new ReplSetServers(servers, this.options.replset || this.options.replSet);
+  this.db = new Db(this.name, server, this.options.db);
+
+  this.db.s.topology.on('left', function(data) {
+    _this.emit('left', data);
+  });
+
+  this.db.s.topology.on('joined', function(data) {
+    _this.emit('joined', data);
+  });
+
+  this.db.on('fullsetup', function() {
+    _this.emit('fullsetup');
+  });
+
+  this.db.on('all', function() {
+    _this.emit('all');
+  });
+
+  this.db.open(function(err) {
+    if (err) return fn(err);
+    fn();
+    listen(_this);
+  });
+
+  return this;
+};
+
+/**
+ * Closes the connection
+ *
+ * @param {Boolean} [force]
+ * @param {Function} [fn]
+ * @return {Connection} this
+ * @api private
+ */
+
+NativeConnection.prototype.doClose = function(force, fn) {
+  this.db.close(force, fn);
+  return this;
+};
+
+/**
+ * Prepares default connection options for the node-mongodb-native driver.
+ *
+ * _NOTE: `passed` options take precedence over connection string options._
+ *
+ * @param {Object} passed options that were passed directly during connection
+ * @param {Object} [connStrOptions] options that were passed in the connection string
+ * @api private
+ */
+
+NativeConnection.prototype.parseOptions = function(passed, connStrOpts) {
+  var o = passed ? require('../../utils').clone(passed) : {};
+
+  o.db || (o.db = {});
+  o.auth || (o.auth = {});
+  o.server || (o.server = {});
+  o.replset || (o.replset = o.replSet) || (o.replset = {});
+  o.server.socketOptions || (o.server.socketOptions = {});
+  o.replset.socketOptions || (o.replset.socketOptions = {});
+  o.mongos || (o.mongos = (connStrOpts && connStrOpts.mongos));
+  (o.mongos === true) && (o.mongos = {});
+
+  var opts = connStrOpts || {};
+  Object.keys(opts).forEach(function(name) {
+    switch (name) {
+      case 'ssl':
+        o.server.ssl = opts.ssl;
+        o.replset.ssl = opts.ssl;
+        o.mongos && (o.mongos.ssl = opts.ssl);
+        break;
+      case 'poolSize':
+        if (typeof o.server[name] === 'undefined') {
+          o.server[name] = o.replset[name] = opts[name];
+        }
+        break;
+      case 'slaveOk':
+        if (typeof o.server.slave_ok === 'undefined') {
+          o.server.slave_ok = opts[name];
+        }
+        break;
+      case 'autoReconnect':
+        if (typeof o.server.auto_reconnect === 'undefined') {
+          o.server.auto_reconnect = opts[name];
+        }
+        break;
+      case 'socketTimeoutMS':
+      case 'connectTimeoutMS':
+        if (typeof o.server.socketOptions[name] === 'undefined') {
+          o.server.socketOptions[name] = o.replset.socketOptions[name] = opts[name];
+        }
+        break;
+      case 'authdb':
+        if (typeof o.auth.authdb === 'undefined') {
+          o.auth.authdb = opts[name];
+        }
+        break;
+      case 'authSource':
+        if (typeof o.auth.authSource === 'undefined') {
+          o.auth.authSource = opts[name];
+        }
+        break;
+      case 'authMechanism':
+        if (typeof o.auth.authMechanism === 'undefined') {
+          o.auth.authMechanism = opts[name];
+        }
+        break;
+      case 'retries':
+      case 'reconnectWait':
+      case 'rs_name':
+        if (typeof o.replset[name] === 'undefined') {
+          o.replset[name] = opts[name];
+        }
+        break;
+      case 'replicaSet':
+        if (typeof o.replset.rs_name === 'undefined') {
+          o.replset.rs_name = opts[name];
+        }
+        break;
+      case 'readSecondary':
+        if (typeof o.replset.read_secondary === 'undefined') {
+          o.replset.read_secondary = opts[name];
+        }
+        break;
+      case 'nativeParser':
+        if (typeof o.db.native_parser === 'undefined') {
+          o.db.native_parser = opts[name];
+        }
+        break;
+      case 'w':
+      case 'safe':
+      case 'fsync':
+      case 'journal':
+      case 'wtimeoutMS':
+        if (typeof o.db[name] === 'undefined') {
+          o.db[name] = opts[name];
+        }
+        break;
+      case 'readPreference':
+        if (typeof o.db.readPreference === 'undefined') {
+          o.db.readPreference = opts[name];
+        }
+        break;
+      case 'readPreferenceTags':
+        if (typeof o.db.read_preference_tags === 'undefined') {
+          o.db.read_preference_tags = opts[name];
+        }
+        break;
+      case 'sslValidate':
+        o.server.sslValidate = opts.sslValidate;
+        o.replset.sslValidate = opts.sslValidate;
+        o.mongos && (o.mongos.sslValidate = opts.sslValidate);
+    }
+  });
+
+  if (!('auto_reconnect' in o.server)) {
+    o.server.auto_reconnect = true;
+  }
+
+  // mongoose creates its own ObjectIds
+  o.db.forceServerObjectId = false;
+
+  // default safe using new nomenclature
+  if (!('journal' in o.db || 'j' in o.db ||
+        'fsync' in o.db || 'safe' in o.db || 'w' in o.db)) {
+    o.db.w = 1;
+  }
+
+  if (o.promiseLibrary) {
+    o.db.promiseLibrary = o.promiseLibrary;
+  }
+
+  validate(o);
+  return o;
+};
+
+/*!
+ * Validates the driver db options.
+ *
+ * @param {Object} o
+ */
+
+function validate(o) {
+  if (o.db.w === -1 || o.db.w === 0) {
+    if (o.db.journal || o.db.fsync || o.db.safe) {
+      throw new Error(
+          'Invalid writeConcern: '
+        + 'w set to -1 or 0 cannot be combined with safe|fsync|journal');
+    }
+  }
+}
+
+/*!
+ * Module exports.
+ */
+
+module.exports = NativeConnection;

familyark/app/node_modules/mongoose/lib/drivers/node-mongodb-native/decimal128.js

@@ -0,0 +1,5 @@
+/*!
+ * ignore
+ */
+
+module.exports = require('mongodb').Decimal128;

familyark/app/node_modules/mongoose/lib/drivers/node-mongodb-native/index.js

@@ -0,0 +1,8 @@
+/*!
+ * Module exports.
+ */
+
+exports.Binary = require('./binary');
+exports.Decimal128 = require('./decimal128');
+exports.ObjectId = require('./objectid');
+exports.ReadPreference = require('./ReadPreference');

familyark/app/node_modules/mongoose/lib/drivers/node-mongodb-native/objectid.js

@@ -0,0 +1,14 @@
+
+/*!
+ * [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) ObjectId
+ * @constructor NodeMongoDbObjectId
+ * @see ObjectId
+ */
+
+var ObjectId = require('mongodb').ObjectId;
+
+/*!
+ * ignore
+ */
+
+module.exports = exports = ObjectId;