added; support for mongodb 2.4 geojson

http://docs.mongodb.org/manual/release-notes/2.4/#new-geospatial-indexes-with-geojson-and-improved-spherical-geometry

closes #1229

lib/query.js

@@ -30,6 +30,7 @@ function Query (criteria, options) {
   this._conditions = {};
   this._updateArg = {};
   this._fields = undefined;
+  this._geoComparison = undefined;
   if (criteria) this.find(criteria);
 }
 
@@ -301,7 +302,8 @@ Query.prototype.cast = function (model, obj) {
 
           var geo = val.$near ? '$near' :
                     val.$nearSphere ? '$nearSphere' :
-                    val.$within ? '$within' : '';
+                    val.$within ? '$within' :
+                    val.$geoIntersects ? '$geoIntersects' : '';
 
           if (!geo) {
             continue;
@@ -316,12 +318,23 @@ Query.prototype.cast = function (model, obj) {
 
           if ('$within' == geo) {
             // find $center, $centerSphere, $box, $polygon
-            var withinType = value.$center || value.$centerSphere || value.$box || value.$polygon;
+            var withinType = value.$center || value.$centerSphere || value.$box || value.$polygon// || value.$geometry;
             if (!withinType) {
               throw new Error('Bad $within paramater: ' + JSON.stringify(val));
             }
 
             value = withinType;
+
+          } else if ('$near' == geo &&
+              'string' == typeof value.type && Array.isArray(value.coordinates)) {
+            // geojson; cast the coordinates
+            value = value.coordinates;
+
+          } else if (('$near' == geo || '$geoIntersects' == geo) &&
+              value.$geometry && 'string' == typeof value.$geometry.type &&
+              Array.isArray(value.$geometry.coordinates)) {
+            // geojson; cast the coordinates
+            value = value.$geometry.coordinates;
           }
 
           ;(function _cast (val) {
@@ -976,7 +989,34 @@ Query.prototype.elemMatch = function (path, criteria) {
  */
 
 Object.defineProperty(Query.prototype, 'within', {
-  get: function () { return this }
+  get: function () {
+    this._geoComparison = '$within';
+    return this
+  }
+});
+
+/**
+ * Declares an intersects query for `geometry()`.
+ *
+ * ####Example
+ *
+ *     query.intersects.geometry({
+ *         type: 'LineString'
+ *       , coordinates: [[180.0, 11.0], [180, 9.0]]
+ *     })
+ *
+ * @property intersects
+ * @see Query#geometry #query_Query-geometry
+ * @memberOf Query
+ * @return {Query} this
+ * @api public
+ */
+
+Object.defineProperty(Query.prototype, 'intersects', {
+  get: function () {
+    this._geoComparison = '$geoIntersects';
+    return this
+  }
 });
 
 /**
@@ -1092,6 +1132,57 @@ Query.prototype.polygon = function (path, val) {
   return this;
 };
 
+/**
+ * Specifies a $geometry condition
+ *
+ * Accepts an object that must contain the following two properties:
+ *
+ * - type: `String`
+ * - coordinates: `Array`
+ *
+ * ####Example
+ *
+ *     var polyA = [[[ 10, 20 ], [ 10, 40 ], [ 30, 40 ], [ 30, 20 ]]]
+ *     query.where('loc').within.geometry({ type: 'Polygon', coordinates: polyA })
+ *
+ *     // or
+ *     var polyB = [[ 0, 0 ], [ 1, 1 ]]
+ *     query.where('loc').within.geometry({ type: 'LineString', coordinates: polyB })
+ *
+ *     // or
+ *     var polyC = [ 0, 0 ]
+ *     query.where('loc').within.geometry({ type: 'Point', coordinates: polyC })
+ *
+ *     // or
+ *     var polyC = [ 0, 0 ]
+ *     query.where('loc').intersects.geometry({ type: 'Point', coordinates: polyC })
+ *
+ * _NOTE: Must come after `intersects` or `within`._
+ *
+ * @param {String} [path]
+ * @param {Object} obj
+ * @return {Query} this
+ * @see http://docs.mongodb.org/manual/release-notes/2.4/#new-geospatial-indexes-with-geojson-and-improved-spherical-geometry
+ * @see http://www.mongodb.org/display/DOCS/Geospatial+Indexing
+ * @api public
+ */
+
+Query.prototype.geometry = function (path, val) {
+  if (arguments.length === 1) {
+    val = path;
+    path = this._currPath;
+  }
+
+  var conds = this._conditions[path] || (this._conditions[path] = {});
+
+  if (!this._geoComparison) {
+    throw new Error('query.geometry() must come after either `within` or `intersects`');
+  }
+
+  conds[this._geoComparison] = { $geometry: val };
+  return this;
+};
+
 /**
  * Specifies which document fields to include or exclude
  *

lib/schema.js

@@ -675,10 +675,10 @@ Schema.prototype.get = function (key) {
 
 Schema.prototype.indexes = function () {
   var indexes = []
-    , seenSchemas = [];
+    , seenSchemas = []
+    , indexTypes = '2d 2dsphere'.split(' ');
 
   collectIndexes(this);
-
   return indexes;
 
   function collectIndexes (schema, prefix) {
@@ -696,10 +696,10 @@ Schema.prototype.indexes = function () {
         } else {
           index = paths[i]._index;
 
-          if (index !== false && index !== null){
+          if (index !== false && index !== null) {
             var field = {};
-            field[prefix + i] = '2d' === index ? index : 1;
-            var options = 'Object' === index.constructor.name ? index : {};
+            field[prefix + i] = ~indexTypes.indexOf(index) ? index : 1;
+            var options = utils.isObject(index) ? index : {};
             if (!('background' in options)) options.background = true;
             indexes.push([field, options]);
           }

lib/schema/array.js

@@ -190,6 +190,18 @@ function castToNumber (val) {
   return Types.Number.prototype.cast.call(this, val);
 }
 
+function castArray (arr, self) {
+  self || (self = this);
+
+  arr.forEach(function (v, i) {
+    if (Array.isArray(v)) {
+      castArray(v, self);
+    } else {
+      arr[i] = castToNumber.call(self, v);
+    }
+  });
+}
+
 SchemaArray.prototype.$conditionalHandlers = {
     '$all': function handle$all (val) {
       if (!Array.isArray(val)) {
@@ -255,10 +267,36 @@ SchemaArray.prototype.$conditionalHandlers = {
             val[type][i] = castToNumber.call(this, item);
           }
         })
+      } else if (val.$geometry) {
+        switch (val.$geometry.type) {
+          case 'Polygon':
+          case 'LineString':
+          case 'Point':
+            val.$geometry.coordinates.forEach(castArray);
+            break;
+          default:
+            // ignore unknowns
+            break;
+        }
       }
 
       return val;
     }
+  , '$geoIntersects': function (val) {
+      var geo = val.$geometry;
+      if (!geo) return;
+
+      switch (val.$geometry.type) {
+        case 'Polygon':
+        case 'LineString':
+        case 'Point':
+          val.$geometry.coordinates.forEach(castArray);
+          break;
+        default:
+          // ignore unknowns
+          break;
+      }
+    }
   , '$maxDistance': castToNumber
 };
 

lib/schema/number.js

@@ -144,7 +144,7 @@ function handleSingle (val) {
 
 function handleArray (val) {
   var self = this;
-  return val.map( function (m) {
+  return val.map(function (m) {
     return self.cast(m)
   });
 }

test/common.js

@@ -98,7 +98,28 @@ module.exports = function (options) {
 };
 
 /**
- * Module exports.
+ * expose mongoose
  */
 
 module.exports.mongoose = mongoose;
+
+/**
+ * expose mongod version helper
+ */
+
+module.exports.mongodVersion = function (cb) {
+  var db = module.exports();
+
+  db.on('error', cb);
+
+  db.on('open', function () {
+    db.db.admin(function (err, admin) {
+      if (err) return cb(err);
+      admin.serverStatus(function (err, info) {
+        if (err) return cb(err);
+        var version = info.version.split('.').map(function(n){return parseInt(n, 10) });
+        cb(null, version);
+      });
+    });
+  })
+}