almost rebased

test/node_modules/mongoose/lib/schema/array.js

@@ -0,0 +1,261 @@
+/*!
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+  , NumberSchema = require('./number')
+  , Types = {
+        Boolean: require('./boolean')
+      , Date: require('./date')
+      , Number: require('./number')
+      , String: require('./string')
+      , ObjectId: require('./objectid')
+      , Buffer: require('./buffer')
+    }
+  , MongooseArray = require('../types').Array
+  , EmbeddedDoc = require('../types').Embedded
+  , Mixed = require('./mixed')
+  , Query = require('../query')
+  , isMongooseObject = require('../utils').isMongooseObject
+
+/**
+ * Array SchemaType constructor
+ *
+ * @param {String} key
+ * @param {SchemaType} cast
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api private
+ */
+
+function SchemaArray (key, cast, options) {
+  if (cast) {
+    var castOptions = {};
+
+    if ('Object' === cast.constructor.name) {
+      if (cast.type) {
+        // support { type: Woot }
+        castOptions = cast;
+        cast = cast.type;
+        delete castOptions.type;
+      } else {
+        cast = Mixed;
+      }
+    }
+
+    var caster = cast.name in Types ? Types[cast.name] : cast;
+    this.casterConstructor = caster;
+    this.caster = new caster(null, castOptions);
+    if (!(this.caster instanceof EmbeddedDoc)) {
+      this.caster.path = key;
+    }
+  }
+
+  SchemaType.call(this, key, options);
+
+  var self = this
+    , defaultArr
+    , fn;
+
+  if (this.defaultValue) {
+    defaultArr = this.defaultValue;
+    fn = 'function' == typeof defaultArr;
+  }
+
+  this.default(function(){
+    var arr = fn ? defaultArr() : defaultArr || [];
+    return new MongooseArray(arr, self.path, this);
+  });
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+
+SchemaArray.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Check required
+ *
+ * @param {Array} value
+ * @api private
+ */
+
+SchemaArray.prototype.checkRequired = function (value) {
+  return !!(value && value.length);
+};
+
+/**
+ * Overrides the getters application for the population special-case
+ *
+ * @param {Object} value
+ * @param {Object} scope
+ * @api private
+ */
+
+SchemaArray.prototype.applyGetters = function (value, scope) {
+  if (this.caster.options && this.caster.options.ref) {
+    // means the object id was populated
+    return value;
+  }
+
+  return SchemaType.prototype.applyGetters.call(this, value, scope);
+};
+
+/**
+ * Casts contents
+ *
+ * @param {Object} value
+ * @param {Document} doc document that triggers the casting
+ * @param {Boolean} init whether this is an initialization cast
+ * @api private
+ */
+
+SchemaArray.prototype.cast = function (value, doc, init) {
+  if (Array.isArray(value)) {
+    if (!(value instanceof MongooseArray)) {
+      value = new MongooseArray(value, this.path, doc);
+    }
+
+    if (this.caster) {
+      try {
+        for (var i = 0, l = value.length; i < l; i++) {
+          value[i] = this.caster.cast(value[i], doc, init);
+        }
+      } catch (e) {
+        // rethrow
+        throw new CastError(e.type, value, this.path);
+      }
+    }
+
+    return value;
+  } else {
+    return this.cast([value], doc, init);
+  }
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} [value]
+ * @api private
+ */
+
+SchemaArray.prototype.castForQuery = function ($conditional, value) {
+  var handler
+    , val;
+  if (arguments.length === 2) {
+    handler = this.$conditionalHandlers[$conditional];
+    if (!handler)
+      throw new Error("Can't use " + $conditional + " with Array.");
+    val = handler.call(this, value);
+  } else {
+    val = $conditional;
+    var proto = this.casterConstructor.prototype;
+    var method = proto.castForQuery || proto.cast;
+
+    var caster = this.caster;
+    if (Array.isArray(val)) {
+      val = val.map(function (v) {
+        if (method) v = method.call(caster, v);
+
+        return isMongooseObject(v)
+          ? v.toObject()
+          : v;
+      });
+    } else if (method) {
+      val = method.call(caster, val);
+    }
+  }
+  return val && isMongooseObject(val)
+    ? val.toObject()
+    : val;
+};
+
+/*!
+ * @ignore
+ */
+
+function castToNumber (val) {
+  return Types.Number.prototype.cast.call(this, val);
+}
+
+SchemaArray.prototype.$conditionalHandlers = {
+    '$all': function handle$all (val) {
+      if (!Array.isArray(val)) {
+        val = [val];
+      }
+
+      val = val.map(function (v) {
+        if (v && 'Object' === v.constructor.name) {
+          var o = {};
+          o[this.path] = v;
+          var query = new Query(o);
+          query.cast(this.casterConstructor);
+          return query._conditions[this.path];
+        }
+        return v;
+      }, this);
+
+      return this.castForQuery(val);
+    }
+  , '$elemMatch': function (val) {
+      if (val.$in) {
+        val.$in = this.castForQuery('$in', val.$in);
+        return val;
+      }
+
+      var query = new Query(val);
+      query.cast(this.casterConstructor);
+      return query._conditions;
+    }
+  , '$size': castToNumber
+  , '$ne': SchemaArray.prototype.castForQuery
+  , '$in': SchemaArray.prototype.castForQuery
+  , '$nin': SchemaArray.prototype.castForQuery
+  , '$regex': SchemaArray.prototype.castForQuery
+  , '$near': SchemaArray.prototype.castForQuery
+  , '$nearSphere': SchemaArray.prototype.castForQuery
+  , '$gt': SchemaArray.prototype.castForQuery
+  , '$gte': SchemaArray.prototype.castForQuery
+  , '$lt': SchemaArray.prototype.castForQuery
+  , '$lte': SchemaArray.prototype.castForQuery
+  , '$within': function (val) {
+      var self = this;
+
+      if (val.$maxDistance) {
+        val.$maxDistance = castToNumber.call(this, val.$maxDistance);
+      }
+
+      if (val.$box || val.$polygon) {
+        var type = val.$box ? '$box' : '$polygon';
+        val[type].forEach(function (arr) {
+          arr.forEach(function (v, i) {
+            arr[i] = castToNumber.call(this, v);
+          });
+        })
+      } else if (val.$center || val.$centerSphere) {
+        var type = val.$center ? '$center' : '$centerSphere';
+        val[type].forEach(function (item, i) {
+          if (Array.isArray(item)) {
+            item.forEach(function (v, j) {
+              item[j] = castToNumber.call(this, v);
+            });
+          } else {
+            val[type][i] = castToNumber.call(this, item);
+          }
+        })
+      }
+
+      return val;
+    }
+  , '$maxDistance': castToNumber
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaArray;

test/node_modules/mongoose/lib/schema/boolean.js

@@ -0,0 +1,91 @@
+
+/*!
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype');
+
+/**
+ * Boolean SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api private
+ */
+
+function SchemaBoolean (path, options) {
+  SchemaType.call(this, path, options);
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+SchemaBoolean.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator
+ *
+ * @api private
+ */
+
+SchemaBoolean.prototype.checkRequired = function (value) {
+  return value === true || value === false;
+};
+
+/**
+ * Casts to boolean
+ *
+ * @param {Object} value
+ * @api private
+ */
+
+SchemaBoolean.prototype.cast = function (value) {
+  if (value === null) return value;
+  if (value === '0') return false;
+  return !!value;
+};
+
+/*!
+ * ignore
+ */
+
+function handleArray (val) {
+  var self = this;
+  return val.map(function (m) {
+    return self.cast(m);
+  });
+}
+
+SchemaBoolean.$conditionalHandlers = {
+    '$in': handleArray
+}
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} val
+ * @api private
+ */
+
+SchemaBoolean.prototype.castForQuery = function ($conditional, val) {
+  var handler;
+  if (2 === arguments.length) {
+    handler = SchemaBoolean.$conditionalHandlers[$conditional];
+
+    if (handler) {
+      return handler.call(this, val);
+    }
+
+    return this.cast(val);
+  }
+
+  return this.cast($conditional);
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaBoolean;

test/node_modules/mongoose/lib/schema/buffer.js

@@ -0,0 +1,118 @@
+/*!
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+  , MongooseBuffer = require('../types').Buffer
+  , Binary = MongooseBuffer.Binary
+  , Query = require('../query');
+
+/**
+ * Buffer SchemaType constructor
+ *
+ * @param {String} key
+ * @param {SchemaType} cast
+ * @inherits SchemaType
+ * @api private
+ */
+
+function SchemaBuffer (key, options) {
+  SchemaType.call(this, key, options, 'Buffer');
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+
+SchemaBuffer.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Check required
+ *
+ * @api private
+ */
+
+SchemaBuffer.prototype.checkRequired = function (value) {
+  return !!(value && value.length);
+};
+
+/**
+ * Casts contents
+ *
+ * @param {Object} value
+ * @param {Document} doc document that triggers the casting
+ * @param {Boolean} init
+ * @api private
+ */
+
+SchemaBuffer.prototype.cast = function (value, doc, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+
+  if (Buffer.isBuffer(value)) {
+    if (!(value instanceof MongooseBuffer)) {
+      value = new MongooseBuffer(value, [this.path, doc]);
+    }
+
+    return value;
+  } else if (value instanceof Binary) {
+    return new MongooseBuffer(value.value(true), [this.path, doc]);
+  }
+
+  if ('string' === typeof value || Array.isArray(value)) {
+    return new MongooseBuffer(value, [this.path, doc]);
+  }
+
+  throw new CastError('buffer', value, this.path);
+};
+
+/*!
+ * ignore
+ */
+function handleSingle (val) {
+  return this.castForQuery(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map( function (m) {
+    return self.castForQuery(m);
+  });
+}
+
+SchemaBuffer.prototype.$conditionalHandlers = {
+    '$ne' : handleSingle
+  , '$in' : handleArray
+  , '$nin': handleArray
+  , '$gt' : handleSingle
+  , '$lt' : handleSingle
+  , '$gte': handleSingle
+  , '$lte': handleSingle
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} [value]
+ * @api private
+ */
+
+SchemaBuffer.prototype.castForQuery = function ($conditional, val) {
+  var handler;
+  if (arguments.length === 2) {
+    handler = this.$conditionalHandlers[$conditional];
+    if (!handler)
+      throw new Error("Can't use " + $conditional + " with Buffer.");
+    return handler.call(this, val);
+  } else {
+    val = $conditional;
+    return this.cast(val).toObject();
+  }
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaBuffer;

test/node_modules/mongoose/lib/schema/date.js

@@ -0,0 +1,126 @@
+
+/*!
+ * Module requirements.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError;
+
+/**
+ * Date SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api private
+ */
+
+function SchemaDate (key, options) {
+  SchemaType.call(this, key, options);
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+
+SchemaDate.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator for date
+ *
+ * @api private
+ */
+
+SchemaDate.prototype.checkRequired = function (value) {
+  return value instanceof Date;
+};
+
+/**
+ * Casts to date
+ *
+ * @param {Object} value to cast
+ * @api private
+ */
+
+SchemaDate.prototype.cast = function (value) {
+  if (value === null || value === '')
+    return null;
+
+  if (value instanceof Date)
+    return value;
+
+  var date;
+
+  // support for timestamps
+  if (value instanceof Number || 'number' == typeof value 
+      || String(value) == Number(value))
+    date = new Date(Number(value));
+
+  // support for date strings
+  else if (value.toString)
+    date = new Date(value.toString());
+
+  if (date.toString() != 'Invalid Date')
+    return date;
+
+  throw new CastError('date', value, this.path);
+};
+
+/*!
+ * Date Query casting.
+ *
+ * @api private
+ */
+
+function handleSingle (val) {
+  return this.cast(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map( function (m) {
+    return self.cast(m);
+  });
+}
+
+SchemaDate.prototype.$conditionalHandlers = {
+    '$lt': handleSingle
+  , '$lte': handleSingle
+  , '$gt': handleSingle
+  , '$gte': handleSingle
+  , '$ne': handleSingle
+  , '$in': handleArray
+  , '$nin': handleArray
+  , '$all': handleArray
+};
+
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} [value]
+ * @api private
+ */
+
+SchemaDate.prototype.castForQuery = function ($conditional, val) {
+  var handler;
+
+  if (2 !== arguments.length) {
+    return this.cast($conditional);
+  }
+
+  handler = this.$conditionalHandlers[$conditional];
+
+  if (!handler) {
+    throw new Error("Can't use " + $conditional + " with Date.");
+  }
+
+  return handler.call(this, val);
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaDate;

test/node_modules/mongoose/lib/schema/documentarray.js

@@ -0,0 +1,189 @@
+
+/*!
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , ArrayType = require('./array')
+  , MongooseDocumentArray = require('../types/documentarray')
+  , Subdocument = require('../types/embedded')
+  , Document = require('../document');
+
+/**
+ * SubdocsArray SchemaType constructor
+ *
+ * @param {String} key
+ * @param {Schema} schema
+ * @param {Object} options
+ * @inherits SchemaArray
+ * @api private
+ */
+
+function DocumentArray (key, schema, options) {
+
+  // compile an embedded document for this schema
+  function EmbeddedDocument () {
+    Subdocument.apply(this, arguments);
+  }
+
+  EmbeddedDocument.prototype.__proto__ = Subdocument.prototype;
+  EmbeddedDocument.prototype._setSchema(schema);
+  EmbeddedDocument.schema = schema;
+
+  // apply methods
+  for (var i in schema.methods) {
+    EmbeddedDocument.prototype[i] = schema.methods[i];
+  }
+
+  // apply statics
+  for (var i in schema.statics)
+    EmbeddedDocument[i] = schema.statics[i];
+
+  EmbeddedDocument.options = options;
+  this.schema = schema;
+
+  ArrayType.call(this, key, EmbeddedDocument, options);
+
+  this.schema = schema;
+  var path = this.path;
+  var fn = this.defaultValue;
+
+  this.default(function(){
+    var arr = fn.call(this);
+    if (!Array.isArray(arr)) arr = [arr];
+    return new MongooseDocumentArray(arr, path, this);
+  });
+};
+
+/*!
+ * Inherits from ArrayType.
+ */
+
+DocumentArray.prototype.__proto__ = ArrayType.prototype;
+
+/**
+ * Performs local validations first, then validations on each embedded doc
+ *
+ * @api private
+ */
+
+DocumentArray.prototype.doValidate = function (array, fn, scope) {
+  var self = this;
+
+  SchemaType.prototype.doValidate.call(this, array, function (err) {
+    if (err) return fn(err);
+
+    var count = array && array.length
+      , error;
+
+    if (!count) return fn();
+
+    // handle sparse arrays, do not use array.forEach which does not
+    // iterate over sparse elements yet reports array.length including
+    // them :(
+
+    for (var i = 0, len = count; i < len; ++i) {
+      // sidestep sparse entries
+      var doc = array[i];
+      if (!doc) {
+        --count || fn();
+        continue;
+      }
+
+      ;(function (i) {
+        doc.validate(function (err) {
+          if (err && !error) {
+            // rewrite the key
+            err.key = self.key + '.' + i + '.' + err.key;
+            return fn(error = err);
+          }
+          --count || fn();
+        });
+      })(i);
+    }
+  }, scope);
+};
+
+/**
+ * Casts contents
+ *
+ * @param {Object} value
+ * @param {Document} document that triggers the casting
+ * @api private
+ */
+
+DocumentArray.prototype.cast = function (value, doc, init, prev) {
+  var selected
+    , subdoc
+    , i
+
+  if (!Array.isArray(value)) {
+    return this.cast([value], doc, init, prev);
+  }
+
+  if (!(value instanceof MongooseDocumentArray)) {
+    value = new MongooseDocumentArray(value, this.path, doc);
+  }
+
+  i = value.length;
+
+  while (i--) {
+    if (!(value[i] instanceof Subdocument) && value[i]) {
+      if (init) {
+        selected || (selected = scopePaths(this, doc._selected, init));
+        subdoc = new this.casterConstructor(null, value, true, selected);
+        value[i] = subdoc.init(value[i]);
+      } else {
+        if (prev && (subdoc = prev.id(value[i]._id))) {
+          // handle resetting doc with existing id but differing data
+          // doc.array = [{ doc: 'val' }]
+          subdoc.set(value[i]);
+        } else {
+          subdoc = new this.casterConstructor(value[i], value);
+        }
+
+        // if set() is hooked it will have no return value
+        // see gh-746
+        value[i] = subdoc;
+      }
+    }
+  }
+
+  return value;
+}
+
+/*!
+ * Scopes paths selected in a query to this array.
+ * Necessary for proper default application of subdocument values.
+ *
+ * @param {DocumentArray} array - the array to scope `fields` paths
+ * @param {Object|undefined} fields - the root fields selected in the query
+ * @param {Boolean|undefined} init - if we are being created part of a query result
+ */
+
+function scopePaths (array, fields, init) {
+  if (!(init && fields)) return undefined;
+
+  var path = array.path + '.'
+    , keys = Object.keys(fields)
+    , i = keys.length
+    , selected = {}
+    , hasKeys
+    , key
+
+  while (i--) {
+    key = keys[i];
+    if (0 === key.indexOf(path)) {
+      hasKeys || (hasKeys = true);
+      selected[key.substring(path.length)] = fields[key];
+    }
+  }
+
+  return hasKeys && selected || undefined;
+}
+
+/*!
+ * Module exports.
+ */
+
+module.exports = DocumentArray;

test/node_modules/mongoose/lib/schema/index.js

@@ -0,0 +1,28 @@
+
+/*!
+ * Module exports.
+ */
+
+exports.String = require('./string');
+
+exports.Number = require('./number');
+
+exports.Boolean = require('./boolean');
+
+exports.DocumentArray = require('./documentarray');
+
+exports.Array = require('./array');
+
+exports.Buffer = require('./buffer');
+
+exports.Date = require('./date');
+
+exports.ObjectId = require('./objectid');
+
+exports.Mixed = require('./mixed');
+
+// alias
+
+exports.Oid = exports.ObjectId;
+exports.Object = exports.Mixed;
+exports.Bool = exports.Boolean;

test/node_modules/mongoose/lib/schema/mixed.js

@@ -0,0 +1,75 @@
+
+/*!
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype');
+
+/**
+ * Mixed SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api private
+ */
+
+function Mixed (path, options) {
+  // make sure empty array defaults are handled
+  if (options &&
+      options.default &&
+      Array.isArray(options.default) &&
+      0 === options.default.length) {
+    options.default = Array;
+  }
+
+  SchemaType.call(this, path, options);
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+
+Mixed.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator
+ *
+ * @api private
+ */
+
+Mixed.prototype.checkRequired = function (val) {
+  return true;
+};
+
+/**
+ * Casts `val` for Mixed.
+ *
+ * _this is a no-op_
+ *
+ * @param {Object} value to cast
+ * @api private
+ */
+
+Mixed.prototype.cast = function (val) {
+  return val;
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $cond
+ * @param {any} [val]
+ * @api private
+ */
+
+Mixed.prototype.castForQuery = function ($cond, val) {
+  if (arguments.length === 2) return val;
+  return $cond;
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = Mixed;

test/node_modules/mongoose/lib/schema/number.js

@@ -0,0 +1,182 @@
+/*!
+ * Module requirements.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+
+/**
+ * Number SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api private
+ */
+
+function SchemaNumber (key, options) {
+  SchemaType.call(this, key, options, 'Number');
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+
+SchemaNumber.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Required validator for number
+ *
+ * @api private
+ */
+
+SchemaNumber.prototype.checkRequired = function checkRequired (value) {
+  if (SchemaType._isRef(this, value, true)) {
+    return null != value;
+  } else {
+    return typeof value == 'number' || value instanceof Number;
+  }
+};
+
+/**
+ * Sets a maximum number validator.
+ *
+ * ####Example:
+ *
+ *     var s = new Schema({ n: { type: Number, min: 10 })
+ *     var M = db.model('M', s)
+ *     var m = new M({ n: 9 })
+ *     m.save(function (err) {
+ *       console.error(err) // validator error
+ *       m.n = 10;
+ *       m.save() // success
+ *     })
+ *
+ * @param {Number} value minimum number
+ * @param {String} message
+ * @api public
+ */
+
+SchemaNumber.prototype.min = function (value, message) {
+  if (this.minValidator)
+    this.validators = this.validators.filter(function(v){
+      return v[1] != 'min';
+    });
+  if (value != null)
+    this.validators.push([function(v){
+      return v === null || v >= value;
+    }, 'min']);
+  return this;
+};
+
+/**
+ * Sets a maximum number validator.
+ *
+ * ####Example:
+ *
+ *     var s = new Schema({ n: { type: Number, max: 10 })
+ *     var M = db.model('M', s)
+ *     var m = new M({ n: 11 })
+ *     m.save(function (err) {
+ *       console.error(err) // validator error
+ *       m.n = 10;
+ *       m.save() // success
+ *     })
+ *
+ * @param {Number} maximum number
+ * @param {String} message
+ * @api public
+ */
+
+SchemaNumber.prototype.max = function (value, message) {
+  if (this.maxValidator)
+    this.validators = this.validators.filter(function(v){
+      return v[1] != 'max';
+    });
+  if (value != null)
+    this.validators.push([this.maxValidator = function(v){
+      return v === null || v <= value;
+    }, 'max']);
+  return this;
+};
+
+/**
+ * Casts to number
+ *
+ * @param {Object} value value to cast
+ * @param {Document} doc document that triggers the casting
+ * @param {Boolean} init
+ * @api private
+ */
+
+SchemaNumber.prototype.cast = function (value, doc, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+
+  if (!isNaN(value)){
+    if (null === value) return value;
+    if ('' === value) return null;
+    if ('string' == typeof value) value = Number(value);
+    if (value instanceof Number) return value
+    if ('number' == typeof value) return value;
+    if (value.toString && !Array.isArray(value) &&
+        value.toString() == Number(value)) {
+      return new Number(value)
+    }
+  }
+
+  throw new CastError('number', value, this.path);
+};
+
+/*!
+ * ignore
+ */
+
+function handleSingle (val) {
+  return this.cast(val)
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map( function (m) {
+    return self.cast(m)
+  });
+}
+
+SchemaNumber.prototype.$conditionalHandlers = {
+    '$lt' : handleSingle
+  , '$lte': handleSingle
+  , '$gt' : handleSingle
+  , '$gte': handleSingle
+  , '$ne' : handleSingle
+  , '$in' : handleArray
+  , '$nin': handleArray
+  , '$mod': handleArray
+  , '$all': handleArray
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} [value]
+ * @api private
+ */
+
+SchemaNumber.prototype.castForQuery = function ($conditional, val) {
+  var handler;
+  if (arguments.length === 2) {
+    handler = this.$conditionalHandlers[$conditional];
+    if (!handler)
+      throw new Error("Can't use " + $conditional + " with Number.");
+    return handler.call(this, val);
+  } else {
+    val = this.cast($conditional);
+    return val == null ? val : val
+  }
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaNumber;

test/node_modules/mongoose/lib/schema/objectid.js

@@ -0,0 +1,151 @@
+/*!
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError
+  , driver = global.MONGOOSE_DRIVER_PATH || './../drivers/node-mongodb-native'
+  , oid = require('../types/objectid');
+
+
+/**
+ * ObjectId SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api private
+ */
+
+function ObjectId (key, options) {
+  SchemaType.call(this, key, options, 'ObjectID');
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+
+ObjectId.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Check required
+ *
+ * @api private
+ */
+
+ObjectId.prototype.checkRequired = function checkRequired (value) {
+  if (SchemaType._isRef(this, value, true)) {
+    return null != value;
+  } else {
+    return value instanceof oid;
+  }
+};
+
+/**
+ * Casts to ObjectId
+ *
+ * @param {Object} value
+ * @param {Object} scope
+ * @param {Boolean} init whether this is an initialization cast
+ * @api private
+ */
+
+ObjectId.prototype.cast = function (value, scope, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+
+  if (value === null) return value;
+
+  if (value instanceof oid)
+    return value;
+
+  if (value._id && value._id instanceof oid)
+    return value._id;
+
+  if (value.toString) {
+    try {
+      return oid.fromString(value.toString());
+    } catch (err) {
+      throw new CastError('ObjectId', value, this.path);
+    }
+  }
+
+  throw new CastError('ObjectId', value, this.path);
+};
+
+/*!
+ * ignore
+ */
+
+function handleSingle (val) {
+  return this.cast(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map(function (m) {
+    return self.cast(m);
+  });
+}
+
+ObjectId.prototype.$conditionalHandlers = {
+    '$ne': handleSingle
+  , '$in': handleArray
+  , '$nin': handleArray
+  , '$gt': handleSingle
+  , '$lt': handleSingle
+  , '$gte': handleSingle
+  , '$lte': handleSingle
+  , '$all': handleArray
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} [val]
+ * @api private
+ */
+
+ObjectId.prototype.castForQuery = function ($conditional, val) {
+  var handler;
+  if (arguments.length === 2) {
+    handler = this.$conditionalHandlers[$conditional];
+    if (!handler)
+      throw new Error("Can't use " + $conditional + " with ObjectId.");
+    return handler.call(this, val);
+  } else {
+    return this.cast($conditional);
+  }
+};
+
+/**
+ * Adds an auto-generated ObjectId default if turnOn is true.
+ * @param {Boolean} turnOn auto generated ObjectId defaults
+ * @api private
+ */
+
+ObjectId.prototype.auto = function (turnOn) {
+  if (turnOn) {
+    this.default(defaultId);
+    this.set(resetId)
+  }
+};
+
+/*!
+ * ignore
+ */
+
+function defaultId () {
+  return new oid();
+};
+
+function resetId (v) {
+  this.__id = null;
+  return v;
+}
+
+/*!
+ * Module exports.
+ */
+
+module.exports = ObjectId;

test/node_modules/mongoose/lib/schema/string.js

@@ -0,0 +1,255 @@
+
+/*!
+ * Module dependencies.
+ */
+
+var SchemaType = require('../schematype')
+  , CastError = SchemaType.CastError;
+
+/**
+ * String SchemaType constructor.
+ *
+ * @param {String} key
+ * @param {Object} options
+ * @inherits SchemaType
+ * @api private
+ */
+
+function SchemaString (key, options) {
+  this.enumValues = [];
+  this.regExp = null;
+  SchemaType.call(this, key, options, 'String');
+};
+
+/*!
+ * Inherits from SchemaType.
+ */
+
+SchemaString.prototype.__proto__ = SchemaType.prototype;
+
+/**
+ * Adds enumeration values and a coinciding validator.
+ *
+ * ####Example:
+ *
+ *     var states = 'opening open closing closed'.split(' ')
+ *     var s = new Schema({ state: { type: String, enum: states })
+ *     var M = db.model('M', s)
+ *     var m = new M({ state: 'invalid' })
+ *     m.save(function (err) {
+ *       console.error(err) // validator error
+ *       m.state = 'open'
+ *       m.save() // success
+ *     })
+ *
+ * @param {String} [args...] enumeration values
+ * @api public
+ */
+
+SchemaString.prototype.enum = function () {
+  var len = arguments.length;
+  if (!len || undefined === arguments[0] || false === arguments[0]) {
+    if (this.enumValidator){
+      this.enumValidator = false;
+      this.validators = this.validators.filter(function(v){
+        return v[1] != 'enum';
+      });
+    }
+    return;
+  }
+
+  for (var i = 0; i < len; i++) {
+    if (undefined !== arguments[i]) {
+      this.enumValues.push(this.cast(arguments[i]));
+    }
+  }
+
+  if (!this.enumValidator) {
+    var values = this.enumValues;
+    this.enumValidator = function(v){
+      return undefined === v || ~values.indexOf(v);
+    };
+    this.validators.push([this.enumValidator, 'enum']);
+  }
+};
+
+/**
+ * Adds a lowercase setter.
+ *
+ * ####Example:
+ *
+ *     var s = new Schema({ email: { type: String, lowercase: true }})
+ *     var M = db.model('M', s);
+ *     var m = new M({ email: 'SomeEmail@example.COM' });
+ *     console.log(m.email) // someemail@example.com
+ *
+ * @api public
+ */
+
+SchemaString.prototype.lowercase = function () {
+  return this.set(function (v, self) {
+    if ('string' != typeof v) v = self.cast(v)
+    if (v) return v.toLowerCase();
+    return v;
+  });
+};
+
+/**
+ * Adds an uppercase setter.
+ *
+ * ####Example:
+ *
+ *     var s = new Schema({ caps: { type: String, uppercase: true }})
+ *     var M = db.model('M', s);
+ *     var m = new M({ caps: 'an example' });
+ *     console.log(m.caps) // AN EXAMPLE
+ *
+ * @api public
+ */
+
+SchemaString.prototype.uppercase = function () {
+  return this.set(function (v, self) {
+    if ('string' != typeof v) v = self.cast(v)
+    if (v) return v.toUpperCase();
+    return v;
+  });
+};
+
+/**
+ * Adds a trim setter.
+ *
+ * The string value will be trimmed when set.
+ *
+ * ####Example:
+ *
+ *     var s = new Schema({ name: { type: String, trim: true }})
+ *     var M = db.model('M', s)
+ *     var string = ' some name '
+ *     console.log(string.length) // 11
+ *     var m = new M({ name: string })
+ *     console.log(m.name.length) // 9
+ *
+ * @api public
+ */
+
+SchemaString.prototype.trim = function () {
+  return this.set(function (v, self) {
+    if ('string' != typeof v) v = self.cast(v)
+    if (v) return v.trim();
+    return v;
+  });
+};
+
+/**
+ * Sets a regexp validator.
+ *
+ * Any value that does not pass `regExp`.test(val) will fail validation.
+ *
+ * ####Example:
+ *
+ *     var s = new Schema({ name: { type: String, match: /^a/ }})
+ *     var M = db.model('M', s)
+ *     var m = new M({ name: 'invalid' })
+ *     m.validate(function (err) {
+ *       console.error(err) // validation error
+ *       m.name = 'apples'
+ *       m.validate(function (err) {
+ *         assert.ok(err) // success
+ *       })
+ *     })
+ *
+ * @param {RegExp} regExp regular expression to test against
+ * @api public
+ */
+
+SchemaString.prototype.match = function match (regExp) {
+  this.validators.push([function(v){
+    return null != v && '' !== v
+      ? regExp.test(v)
+      : true
+  }, 'regexp']);
+};
+
+/**
+ * Check required
+ *
+ * @param {String|null|undefined} value
+ * @api private
+ */
+
+SchemaString.prototype.checkRequired = function checkRequired (value) {
+  if (SchemaType._isRef(this, value, true)) {
+    return null != value;
+  } else {
+    return (value instanceof String || typeof value == 'string') && value.length;
+  }
+};
+
+/**
+ * Casts to String
+ *
+ * @api private
+ */
+
+SchemaString.prototype.cast = function (value, scope, init) {
+  if (SchemaType._isRef(this, value, init)) return value;
+  if (value === null) return value;
+  if ('undefined' !== typeof value && value.toString) return value.toString();
+  throw new CastError('string', value, this.path);
+};
+
+/*!
+ * ignore
+ */
+
+function handleSingle (val) {
+  return this.castForQuery(val);
+}
+
+function handleArray (val) {
+  var self = this;
+  return val.map(function (m) {
+    return self.castForQuery(m);
+  });
+}
+
+SchemaString.prototype.$conditionalHandlers = {
+    '$ne' : handleSingle
+  , '$in' : handleArray
+  , '$nin': handleArray
+  , '$gt' : handleSingle
+  , '$lt' : handleSingle
+  , '$gte': handleSingle
+  , '$lte': handleSingle
+  , '$all': handleArray
+  , '$regex': handleSingle
+  , '$options': handleSingle
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $conditional
+ * @param {any} [val]
+ * @api private
+ */
+
+SchemaString.prototype.castForQuery = function ($conditional, val) {
+  var handler;
+  if (arguments.length === 2) {
+    handler = this.$conditionalHandlers[$conditional];
+    if (!handler)
+      throw new Error("Can't use " + $conditional + " with String.");
+    return handler.call(this, val);
+  } else {
+    val = $conditional;
+    if (val instanceof RegExp) return val;
+    return this.cast(val);
+  }
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaString;