4089 lines
448 KiB
JavaScript
4089 lines
448 KiB
JavaScript
//////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// This is a generated file. You can view the original //
|
|
// source in your browser if your browser supports source maps. //
|
|
// //
|
|
// If you are using Chrome, open the Developer Tools and click the gear //
|
|
// icon in its lower right corner. In the General Settings panel, turn //
|
|
// on 'Enable source maps'. //
|
|
// //
|
|
// If you are using Firefox 23, go to `about:config` and set the //
|
|
// `devtools.debugger.source-maps-enabled` preference to true. //
|
|
// (The preference should be on by default in Firefox 24; versions //
|
|
// older than 23 do not support source maps.) //
|
|
// //
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
(function () {
|
|
|
|
/* Imports */
|
|
var Meteor = Package.meteor.Meteor;
|
|
var _ = Package.underscore._;
|
|
var JSON = Package.json.JSON;
|
|
var EJSON = Package.ejson.EJSON;
|
|
var IdMap = Package['id-map'].IdMap;
|
|
var OrderedDict = Package['ordered-dict'].OrderedDict;
|
|
var Tracker = Package.tracker.Tracker;
|
|
var Deps = Package.tracker.Deps;
|
|
var Random = Package.random.Random;
|
|
var GeoJSON = Package['geojson-utils'].GeoJSON;
|
|
|
|
/* Package-scope variables */
|
|
var LocalCollection, Minimongo, MinimongoTest, MinimongoError, isArray, isPlainObject, isIndexable, isOperatorObject, isNumericKey, regexpElementMatcher, equalityElementMatcher, ELEMENT_OPERATORS, makeLookupFunction, expandArraysInBranches, projectionDetails, pathsToTree;
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/minimongo.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// XXX type checking on selectors (graceful error if malformed) // 1
|
|
// 2
|
|
// LocalCollection: a set of documents that supports queries and modifiers. // 3
|
|
// 4
|
|
// Cursor: a specification for a particular subset of documents, w/ // 5
|
|
// a defined order, limit, and offset. creating a Cursor with LocalCollection.find(), // 6
|
|
// 7
|
|
// ObserveHandle: the return value of a live query. // 8
|
|
// 9
|
|
LocalCollection = function (name) { // 10
|
|
var self = this; // 11
|
|
self.name = name; // 12
|
|
// _id -> document (also containing id) // 13
|
|
self._docs = new LocalCollection._IdMap; // 14
|
|
// 15
|
|
self._observeQueue = new Meteor._SynchronousQueue(); // 16
|
|
// 17
|
|
self.next_qid = 1; // live query id generator // 18
|
|
// 19
|
|
// qid -> live query object. keys: // 20
|
|
// ordered: bool. ordered queries have addedBefore/movedBefore callbacks. // 21
|
|
// results: array (ordered) or object (unordered) of current results // 22
|
|
// (aliased with self._docs!) // 23
|
|
// resultsSnapshot: snapshot of results. null if not paused. // 24
|
|
// cursor: Cursor object for the query. // 25
|
|
// selector, sorter, (callbacks): functions // 26
|
|
self.queries = {}; // 27
|
|
// 28
|
|
// null if not saving originals; an IdMap from id to original document value if // 29
|
|
// saving originals. See comments before saveOriginals(). // 30
|
|
self._savedOriginals = null; // 31
|
|
// 32
|
|
// True when observers are paused and we should not send callbacks. // 33
|
|
self.paused = false; // 34
|
|
}; // 35
|
|
// 36
|
|
Minimongo = {}; // 37
|
|
// 38
|
|
// Object exported only for unit testing. // 39
|
|
// Use it to export private functions to test in Tinytest. // 40
|
|
MinimongoTest = {}; // 41
|
|
// 42
|
|
LocalCollection._applyChanges = function (doc, changeFields) { // 43
|
|
_.each(changeFields, function (value, key) { // 44
|
|
if (value === undefined) // 45
|
|
delete doc[key]; // 46
|
|
else // 47
|
|
doc[key] = value; // 48
|
|
}); // 49
|
|
}; // 50
|
|
// 51
|
|
MinimongoError = function (message) { // 52
|
|
var e = new Error(message); // 53
|
|
e.name = "MinimongoError"; // 54
|
|
return e; // 55
|
|
}; // 56
|
|
// 57
|
|
// 58
|
|
// options may include sort, skip, limit, reactive // 59
|
|
// sort may be any of these forms: // 60
|
|
// {a: 1, b: -1} // 61
|
|
// [["a", "asc"], ["b", "desc"]] // 62
|
|
// ["a", ["b", "desc"]] // 63
|
|
// (in the first form you're beholden to key enumeration order in // 64
|
|
// your javascript VM) // 65
|
|
// // 66
|
|
// reactive: if given, and false, don't register with Tracker (default // 67
|
|
// is true) // 68
|
|
// // 69
|
|
// XXX possibly should support retrieving a subset of fields? and // 70
|
|
// have it be a hint (ignored on the client, when not copying the // 71
|
|
// doc?) // 72
|
|
// // 73
|
|
// XXX sort does not yet support subkeys ('a.b') .. fix that! // 74
|
|
// XXX add one more sort form: "key" // 75
|
|
// XXX tests // 76
|
|
LocalCollection.prototype.find = function (selector, options) { // 77
|
|
// default syntax for everything is to omit the selector argument. // 78
|
|
// but if selector is explicitly passed in as false or undefined, we // 79
|
|
// want a selector that matches nothing. // 80
|
|
if (arguments.length === 0) // 81
|
|
selector = {}; // 82
|
|
// 83
|
|
return new LocalCollection.Cursor(this, selector, options); // 84
|
|
}; // 85
|
|
// 86
|
|
// don't call this ctor directly. use LocalCollection.find(). // 87
|
|
// 88
|
|
LocalCollection.Cursor = function (collection, selector, options) { // 89
|
|
var self = this; // 90
|
|
if (!options) options = {}; // 91
|
|
// 92
|
|
self.collection = collection; // 93
|
|
self.sorter = null; // 94
|
|
// 95
|
|
if (LocalCollection._selectorIsId(selector)) { // 96
|
|
// stash for fast path // 97
|
|
self._selectorId = selector; // 98
|
|
self.matcher = new Minimongo.Matcher(selector); // 99
|
|
} else { // 100
|
|
self._selectorId = undefined; // 101
|
|
self.matcher = new Minimongo.Matcher(selector); // 102
|
|
if (self.matcher.hasGeoQuery() || options.sort) { // 103
|
|
self.sorter = new Minimongo.Sorter(options.sort || [], // 104
|
|
{ matcher: self.matcher }); // 105
|
|
} // 106
|
|
} // 107
|
|
self.skip = options.skip; // 108
|
|
self.limit = options.limit; // 109
|
|
self.fields = options.fields; // 110
|
|
// 111
|
|
self._projectionFn = LocalCollection._compileProjection(self.fields || {}); // 112
|
|
// 113
|
|
self._transform = LocalCollection.wrapTransform(options.transform); // 114
|
|
// 115
|
|
// by default, queries register w/ Tracker when it is available. // 116
|
|
if (typeof Tracker !== "undefined") // 117
|
|
self.reactive = (options.reactive === undefined) ? true : options.reactive; // 118
|
|
}; // 119
|
|
// 120
|
|
// Since we don't actually have a "nextObject" interface, there's really no // 121
|
|
// reason to have a "rewind" interface. All it did was make multiple calls // 122
|
|
// to fetch/map/forEach return nothing the second time. // 123
|
|
// XXX COMPAT WITH 0.8.1 // 124
|
|
LocalCollection.Cursor.prototype.rewind = function () { // 125
|
|
}; // 126
|
|
// 127
|
|
LocalCollection.prototype.findOne = function (selector, options) { // 128
|
|
if (arguments.length === 0) // 129
|
|
selector = {}; // 130
|
|
// 131
|
|
// NOTE: by setting limit 1 here, we end up using very inefficient // 132
|
|
// code that recomputes the whole query on each update. The upside is // 133
|
|
// that when you reactively depend on a findOne you only get // 134
|
|
// invalidated when the found object changes, not any object in the // 135
|
|
// collection. Most findOne will be by id, which has a fast path, so // 136
|
|
// this might not be a big deal. In most cases, invalidation causes // 137
|
|
// the called to re-query anyway, so this should be a net performance // 138
|
|
// improvement. // 139
|
|
options = options || {}; // 140
|
|
options.limit = 1; // 141
|
|
// 142
|
|
return this.find(selector, options).fetch()[0]; // 143
|
|
}; // 144
|
|
// 145
|
|
/** // 146
|
|
* @callback IterationCallback // 147
|
|
* @param {Object} doc // 148
|
|
* @param {Number} index // 149
|
|
*/ // 150
|
|
/** // 151
|
|
* @summary Call `callback` once for each matching document, sequentially and synchronously. // 152
|
|
* @locus Anywhere // 153
|
|
* @method forEach // 154
|
|
* @instance // 155
|
|
* @memberOf Mongo.Cursor // 156
|
|
* @param {IterationCallback} callback Function to call. It will be called with three arguments: the document, a 0-based index, and <em>cursor</em> itself.
|
|
* @param {Any} [thisArg] An object which will be the value of `this` inside `callback`. // 158
|
|
*/ // 159
|
|
LocalCollection.Cursor.prototype.forEach = function (callback, thisArg) { // 160
|
|
var self = this; // 161
|
|
// 162
|
|
var objects = self._getRawObjects({ordered: true}); // 163
|
|
// 164
|
|
if (self.reactive) { // 165
|
|
self._depend({ // 166
|
|
addedBefore: true, // 167
|
|
removed: true, // 168
|
|
changed: true, // 169
|
|
movedBefore: true}); // 170
|
|
} // 171
|
|
// 172
|
|
_.each(objects, function (elt, i) { // 173
|
|
// This doubles as a clone operation. // 174
|
|
elt = self._projectionFn(elt); // 175
|
|
// 176
|
|
if (self._transform) // 177
|
|
elt = self._transform(elt); // 178
|
|
callback.call(thisArg, elt, i, self); // 179
|
|
}); // 180
|
|
}; // 181
|
|
// 182
|
|
LocalCollection.Cursor.prototype.getTransform = function () { // 183
|
|
return this._transform; // 184
|
|
}; // 185
|
|
// 186
|
|
/** // 187
|
|
* @summary Map callback over all matching documents. Returns an Array. // 188
|
|
* @locus Anywhere // 189
|
|
* @method map // 190
|
|
* @instance // 191
|
|
* @memberOf Mongo.Cursor // 192
|
|
* @param {IterationCallback} callback Function to call. It will be called with three arguments: the document, a 0-based index, and <em>cursor</em> itself.
|
|
* @param {Any} [thisArg] An object which will be the value of `this` inside `callback`. // 194
|
|
*/ // 195
|
|
LocalCollection.Cursor.prototype.map = function (callback, thisArg) { // 196
|
|
var self = this; // 197
|
|
var res = []; // 198
|
|
self.forEach(function (doc, index) { // 199
|
|
res.push(callback.call(thisArg, doc, index, self)); // 200
|
|
}); // 201
|
|
return res; // 202
|
|
}; // 203
|
|
// 204
|
|
/** // 205
|
|
* @summary Return all matching documents as an Array. // 206
|
|
* @memberOf Mongo.Cursor // 207
|
|
* @method fetch // 208
|
|
* @instance // 209
|
|
* @locus Anywhere // 210
|
|
* @returns {Object[]} // 211
|
|
*/ // 212
|
|
LocalCollection.Cursor.prototype.fetch = function () { // 213
|
|
var self = this; // 214
|
|
var res = []; // 215
|
|
self.forEach(function (doc) { // 216
|
|
res.push(doc); // 217
|
|
}); // 218
|
|
return res; // 219
|
|
}; // 220
|
|
// 221
|
|
/** // 222
|
|
* @summary Returns the number of documents that match a query. // 223
|
|
* @memberOf Mongo.Cursor // 224
|
|
* @method count // 225
|
|
* @instance // 226
|
|
* @locus Anywhere // 227
|
|
* @returns {Number} // 228
|
|
*/ // 229
|
|
LocalCollection.Cursor.prototype.count = function () { // 230
|
|
var self = this; // 231
|
|
// 232
|
|
if (self.reactive) // 233
|
|
self._depend({added: true, removed: true}, // 234
|
|
true /* allow the observe to be unordered */); // 235
|
|
// 236
|
|
return self._getRawObjects({ordered: true}).length; // 237
|
|
}; // 238
|
|
// 239
|
|
LocalCollection.Cursor.prototype._publishCursor = function (sub) { // 240
|
|
var self = this; // 241
|
|
if (! self.collection.name) // 242
|
|
throw new Error("Can't publish a cursor from a collection without a name."); // 243
|
|
var collection = self.collection.name; // 244
|
|
// 245
|
|
// XXX minimongo should not depend on mongo-livedata! // 246
|
|
return Mongo.Collection._publishCursor(self, sub, collection); // 247
|
|
}; // 248
|
|
// 249
|
|
LocalCollection.Cursor.prototype._getCollectionName = function () { // 250
|
|
var self = this; // 251
|
|
return self.collection.name; // 252
|
|
}; // 253
|
|
// 254
|
|
LocalCollection._observeChangesCallbacksAreOrdered = function (callbacks) { // 255
|
|
if (callbacks.added && callbacks.addedBefore) // 256
|
|
throw new Error("Please specify only one of added() and addedBefore()"); // 257
|
|
return !!(callbacks.addedBefore || callbacks.movedBefore); // 258
|
|
}; // 259
|
|
// 260
|
|
LocalCollection._observeCallbacksAreOrdered = function (callbacks) { // 261
|
|
if (callbacks.addedAt && callbacks.added) // 262
|
|
throw new Error("Please specify only one of added() and addedAt()"); // 263
|
|
if (callbacks.changedAt && callbacks.changed) // 264
|
|
throw new Error("Please specify only one of changed() and changedAt()"); // 265
|
|
if (callbacks.removed && callbacks.removedAt) // 266
|
|
throw new Error("Please specify only one of removed() and removedAt()"); // 267
|
|
// 268
|
|
return !!(callbacks.addedAt || callbacks.movedTo || callbacks.changedAt // 269
|
|
|| callbacks.removedAt); // 270
|
|
}; // 271
|
|
// 272
|
|
// the handle that comes back from observe. // 273
|
|
LocalCollection.ObserveHandle = function () {}; // 274
|
|
// 275
|
|
// options to contain: // 276
|
|
// * callbacks for observe(): // 277
|
|
// - addedAt (document, atIndex) // 278
|
|
// - added (document) // 279
|
|
// - changedAt (newDocument, oldDocument, atIndex) // 280
|
|
// - changed (newDocument, oldDocument) // 281
|
|
// - removedAt (document, atIndex) // 282
|
|
// - removed (document) // 283
|
|
// - movedTo (document, oldIndex, newIndex) // 284
|
|
// // 285
|
|
// attributes available on returned query handle: // 286
|
|
// * stop(): end updates // 287
|
|
// * collection: the collection this query is querying // 288
|
|
// // 289
|
|
// iff x is a returned query handle, (x instanceof // 290
|
|
// LocalCollection.ObserveHandle) is true // 291
|
|
// // 292
|
|
// initial results delivered through added callback // 293
|
|
// XXX maybe callbacks should take a list of objects, to expose transactions? // 294
|
|
// XXX maybe support field limiting (to limit what you're notified on) // 295
|
|
// 296
|
|
_.extend(LocalCollection.Cursor.prototype, { // 297
|
|
/** // 298
|
|
* @summary Watch a query. Receive callbacks as the result set changes. // 299
|
|
* @locus Anywhere // 300
|
|
* @memberOf Mongo.Cursor // 301
|
|
* @instance // 302
|
|
* @param {Object} callbacks Functions to call to deliver the result set as it changes // 303
|
|
*/ // 304
|
|
observe: function (options) { // 305
|
|
var self = this; // 306
|
|
return LocalCollection._observeFromObserveChanges(self, options); // 307
|
|
}, // 308
|
|
// 309
|
|
/** // 310
|
|
* @summary Watch a query. Receive callbacks as the result set changes. Only the differences between the old and new documents are passed to the callbacks.
|
|
* @locus Anywhere // 312
|
|
* @memberOf Mongo.Cursor // 313
|
|
* @instance // 314
|
|
* @param {Object} callbacks Functions to call to deliver the result set as it changes // 315
|
|
*/ // 316
|
|
observeChanges: function (options) { // 317
|
|
var self = this; // 318
|
|
// 319
|
|
var ordered = LocalCollection._observeChangesCallbacksAreOrdered(options); // 320
|
|
// 321
|
|
// there are several places that assume you aren't combining skip/limit with // 322
|
|
// unordered observe. eg, update's EJSON.clone, and the "there are several" // 323
|
|
// comment in _modifyAndNotify // 324
|
|
// XXX allow skip/limit with unordered observe // 325
|
|
if (!options._allow_unordered && !ordered && (self.skip || self.limit)) // 326
|
|
throw new Error("must use ordered observe (ie, 'addedBefore' instead of 'added') with skip or limit"); // 327
|
|
// 328
|
|
if (self.fields && (self.fields._id === 0 || self.fields._id === false)) // 329
|
|
throw Error("You may not observe a cursor with {fields: {_id: 0}}"); // 330
|
|
// 331
|
|
var query = { // 332
|
|
matcher: self.matcher, // not fast pathed // 333
|
|
sorter: ordered && self.sorter, // 334
|
|
distances: ( // 335
|
|
self.matcher.hasGeoQuery() && ordered && new LocalCollection._IdMap), // 336
|
|
resultsSnapshot: null, // 337
|
|
ordered: ordered, // 338
|
|
cursor: self, // 339
|
|
projectionFn: self._projectionFn // 340
|
|
}; // 341
|
|
var qid; // 342
|
|
// 343
|
|
// Non-reactive queries call added[Before] and then never call anything // 344
|
|
// else. // 345
|
|
if (self.reactive) { // 346
|
|
qid = self.collection.next_qid++; // 347
|
|
self.collection.queries[qid] = query; // 348
|
|
} // 349
|
|
query.results = self._getRawObjects({ // 350
|
|
ordered: ordered, distances: query.distances}); // 351
|
|
if (self.collection.paused) // 352
|
|
query.resultsSnapshot = (ordered ? [] : new LocalCollection._IdMap); // 353
|
|
// 354
|
|
// wrap callbacks we were passed. callbacks only fire when not paused and // 355
|
|
// are never undefined // 356
|
|
// Filters out blacklisted fields according to cursor's projection. // 357
|
|
// XXX wrong place for this? // 358
|
|
// 359
|
|
// furthermore, callbacks enqueue until the operation we're working on is // 360
|
|
// done. // 361
|
|
var wrapCallback = function (f) { // 362
|
|
if (!f) // 363
|
|
return function () {}; // 364
|
|
return function (/*args*/) { // 365
|
|
var context = this; // 366
|
|
var args = arguments; // 367
|
|
// 368
|
|
if (self.collection.paused) // 369
|
|
return; // 370
|
|
// 371
|
|
self.collection._observeQueue.queueTask(function () { // 372
|
|
f.apply(context, args); // 373
|
|
}); // 374
|
|
}; // 375
|
|
}; // 376
|
|
query.added = wrapCallback(options.added); // 377
|
|
query.changed = wrapCallback(options.changed); // 378
|
|
query.removed = wrapCallback(options.removed); // 379
|
|
if (ordered) { // 380
|
|
query.addedBefore = wrapCallback(options.addedBefore); // 381
|
|
query.movedBefore = wrapCallback(options.movedBefore); // 382
|
|
} // 383
|
|
// 384
|
|
if (!options._suppress_initial && !self.collection.paused) { // 385
|
|
// XXX unify ordered and unordered interface // 386
|
|
var each = ordered // 387
|
|
? _.bind(_.each, null, query.results) // 388
|
|
: _.bind(query.results.forEach, query.results); // 389
|
|
each(function (doc) { // 390
|
|
var fields = EJSON.clone(doc); // 391
|
|
// 392
|
|
delete fields._id; // 393
|
|
if (ordered) // 394
|
|
query.addedBefore(doc._id, self._projectionFn(fields), null); // 395
|
|
query.added(doc._id, self._projectionFn(fields)); // 396
|
|
}); // 397
|
|
} // 398
|
|
// 399
|
|
var handle = new LocalCollection.ObserveHandle; // 400
|
|
_.extend(handle, { // 401
|
|
collection: self.collection, // 402
|
|
stop: function () { // 403
|
|
if (self.reactive) // 404
|
|
delete self.collection.queries[qid]; // 405
|
|
} // 406
|
|
}); // 407
|
|
// 408
|
|
if (self.reactive && Tracker.active) { // 409
|
|
// XXX in many cases, the same observe will be recreated when // 410
|
|
// the current autorun is rerun. we could save work by // 411
|
|
// letting it linger across rerun and potentially get // 412
|
|
// repurposed if the same observe is performed, using logic // 413
|
|
// similar to that of Meteor.subscribe. // 414
|
|
Tracker.onInvalidate(function () { // 415
|
|
handle.stop(); // 416
|
|
}); // 417
|
|
} // 418
|
|
// run the observe callbacks resulting from the initial contents // 419
|
|
// before we leave the observe. // 420
|
|
self.collection._observeQueue.drain(); // 421
|
|
// 422
|
|
return handle; // 423
|
|
} // 424
|
|
}); // 425
|
|
// 426
|
|
// Returns a collection of matching objects, but doesn't deep copy them. // 427
|
|
// // 428
|
|
// If ordered is set, returns a sorted array, respecting sorter, skip, and limit // 429
|
|
// properties of the query. if sorter is falsey, no sort -- you get the natural // 430
|
|
// order. // 431
|
|
// // 432
|
|
// If ordered is not set, returns an object mapping from ID to doc (sorter, skip // 433
|
|
// and limit should not be set). // 434
|
|
// // 435
|
|
// If ordered is set and this cursor is a $near geoquery, then this function // 436
|
|
// will use an _IdMap to track each distance from the $near argument point in // 437
|
|
// order to use it as a sort key. If an _IdMap is passed in the 'distances' // 438
|
|
// argument, this function will clear it and use it for this purpose (otherwise // 439
|
|
// it will just create its own _IdMap). The observeChanges implementation uses // 440
|
|
// this to remember the distances after this function returns. // 441
|
|
LocalCollection.Cursor.prototype._getRawObjects = function (options) { // 442
|
|
var self = this; // 443
|
|
options = options || {}; // 444
|
|
// 445
|
|
// XXX use OrderedDict instead of array, and make IdMap and OrderedDict // 446
|
|
// compatible // 447
|
|
var results = options.ordered ? [] : new LocalCollection._IdMap; // 448
|
|
// 449
|
|
// fast path for single ID value // 450
|
|
if (self._selectorId !== undefined) { // 451
|
|
// If you have non-zero skip and ask for a single id, you get // 452
|
|
// nothing. This is so it matches the behavior of the '{_id: foo}' // 453
|
|
// path. // 454
|
|
if (self.skip) // 455
|
|
return results; // 456
|
|
// 457
|
|
var selectedDoc = self.collection._docs.get(self._selectorId); // 458
|
|
if (selectedDoc) { // 459
|
|
if (options.ordered) // 460
|
|
results.push(selectedDoc); // 461
|
|
else // 462
|
|
results.set(self._selectorId, selectedDoc); // 463
|
|
} // 464
|
|
return results; // 465
|
|
} // 466
|
|
// 467
|
|
// slow path for arbitrary selector, sort, skip, limit // 468
|
|
// 469
|
|
// in the observeChanges case, distances is actually part of the "query" (ie, // 470
|
|
// live results set) object. in other cases, distances is only used inside // 471
|
|
// this function. // 472
|
|
var distances; // 473
|
|
if (self.matcher.hasGeoQuery() && options.ordered) { // 474
|
|
if (options.distances) { // 475
|
|
distances = options.distances; // 476
|
|
distances.clear(); // 477
|
|
} else { // 478
|
|
distances = new LocalCollection._IdMap(); // 479
|
|
} // 480
|
|
} // 481
|
|
// 482
|
|
self.collection._docs.forEach(function (doc, id) { // 483
|
|
var matchResult = self.matcher.documentMatches(doc); // 484
|
|
if (matchResult.result) { // 485
|
|
if (options.ordered) { // 486
|
|
results.push(doc); // 487
|
|
if (distances && matchResult.distance !== undefined) // 488
|
|
distances.set(id, matchResult.distance); // 489
|
|
} else { // 490
|
|
results.set(id, doc); // 491
|
|
} // 492
|
|
} // 493
|
|
// Fast path for limited unsorted queries. // 494
|
|
// XXX 'length' check here seems wrong for ordered // 495
|
|
if (self.limit && !self.skip && !self.sorter && // 496
|
|
results.length === self.limit) // 497
|
|
return false; // break // 498
|
|
return true; // continue // 499
|
|
}); // 500
|
|
// 501
|
|
if (!options.ordered) // 502
|
|
return results; // 503
|
|
// 504
|
|
if (self.sorter) { // 505
|
|
var comparator = self.sorter.getComparator({distances: distances}); // 506
|
|
results.sort(comparator); // 507
|
|
} // 508
|
|
// 509
|
|
var idx_start = self.skip || 0; // 510
|
|
var idx_end = self.limit ? (self.limit + idx_start) : results.length; // 511
|
|
return results.slice(idx_start, idx_end); // 512
|
|
}; // 513
|
|
// 514
|
|
// XXX Maybe we need a version of observe that just calls a callback if // 515
|
|
// anything changed. // 516
|
|
LocalCollection.Cursor.prototype._depend = function (changers, _allow_unordered) { // 517
|
|
var self = this; // 518
|
|
// 519
|
|
if (Tracker.active) { // 520
|
|
var v = new Tracker.Dependency; // 521
|
|
v.depend(); // 522
|
|
var notifyChange = _.bind(v.changed, v); // 523
|
|
// 524
|
|
var options = { // 525
|
|
_suppress_initial: true, // 526
|
|
_allow_unordered: _allow_unordered // 527
|
|
}; // 528
|
|
_.each(['added', 'changed', 'removed', 'addedBefore', 'movedBefore'], // 529
|
|
function (fnName) { // 530
|
|
if (changers[fnName]) // 531
|
|
options[fnName] = notifyChange; // 532
|
|
}); // 533
|
|
// 534
|
|
// observeChanges will stop() when this computation is invalidated // 535
|
|
self.observeChanges(options); // 536
|
|
} // 537
|
|
}; // 538
|
|
// 539
|
|
// XXX enforce rule that field names can't start with '$' or contain '.' // 540
|
|
// (real mongodb does in fact enforce this) // 541
|
|
// XXX possibly enforce that 'undefined' does not appear (we assume // 542
|
|
// this in our handling of null and $exists) // 543
|
|
LocalCollection.prototype.insert = function (doc, callback) { // 544
|
|
var self = this; // 545
|
|
doc = EJSON.clone(doc); // 546
|
|
// 547
|
|
if (!_.has(doc, '_id')) { // 548
|
|
// if you really want to use ObjectIDs, set this global. // 549
|
|
// Mongo.Collection specifies its own ids and does not use this code. // 550
|
|
doc._id = LocalCollection._useOID ? new LocalCollection._ObjectID() // 551
|
|
: Random.id(); // 552
|
|
} // 553
|
|
var id = doc._id; // 554
|
|
// 555
|
|
if (self._docs.has(id)) // 556
|
|
throw MinimongoError("Duplicate _id '" + id + "'"); // 557
|
|
// 558
|
|
self._saveOriginal(id, undefined); // 559
|
|
self._docs.set(id, doc); // 560
|
|
// 561
|
|
var queriesToRecompute = []; // 562
|
|
// trigger live queries that match // 563
|
|
for (var qid in self.queries) { // 564
|
|
var query = self.queries[qid]; // 565
|
|
var matchResult = query.matcher.documentMatches(doc); // 566
|
|
if (matchResult.result) { // 567
|
|
if (query.distances && matchResult.distance !== undefined) // 568
|
|
query.distances.set(id, matchResult.distance); // 569
|
|
if (query.cursor.skip || query.cursor.limit) // 570
|
|
queriesToRecompute.push(qid); // 571
|
|
else // 572
|
|
LocalCollection._insertInResults(query, doc); // 573
|
|
} // 574
|
|
} // 575
|
|
// 576
|
|
_.each(queriesToRecompute, function (qid) { // 577
|
|
if (self.queries[qid]) // 578
|
|
self._recomputeResults(self.queries[qid]); // 579
|
|
}); // 580
|
|
self._observeQueue.drain(); // 581
|
|
// 582
|
|
// Defer because the caller likely doesn't expect the callback to be run // 583
|
|
// immediately. // 584
|
|
if (callback) // 585
|
|
Meteor.defer(function () { // 586
|
|
callback(null, id); // 587
|
|
}); // 588
|
|
return id; // 589
|
|
}; // 590
|
|
// 591
|
|
// Iterates over a subset of documents that could match selector; calls // 592
|
|
// f(doc, id) on each of them. Specifically, if selector specifies // 593
|
|
// specific _id's, it only looks at those. doc is *not* cloned: it is the // 594
|
|
// same object that is in _docs. // 595
|
|
LocalCollection.prototype._eachPossiblyMatchingDoc = function (selector, f) { // 596
|
|
var self = this; // 597
|
|
var specificIds = LocalCollection._idsMatchedBySelector(selector); // 598
|
|
if (specificIds) { // 599
|
|
for (var i = 0; i < specificIds.length; ++i) { // 600
|
|
var id = specificIds[i]; // 601
|
|
var doc = self._docs.get(id); // 602
|
|
if (doc) { // 603
|
|
var breakIfFalse = f(doc, id); // 604
|
|
if (breakIfFalse === false) // 605
|
|
break; // 606
|
|
} // 607
|
|
} // 608
|
|
} else { // 609
|
|
self._docs.forEach(f); // 610
|
|
} // 611
|
|
}; // 612
|
|
// 613
|
|
LocalCollection.prototype.remove = function (selector, callback) { // 614
|
|
var self = this; // 615
|
|
// 616
|
|
// Easy special case: if we're not calling observeChanges callbacks and we're // 617
|
|
// not saving originals and we got asked to remove everything, then just empty // 618
|
|
// everything directly. // 619
|
|
if (self.paused && !self._savedOriginals && EJSON.equals(selector, {})) { // 620
|
|
var result = self._docs.size(); // 621
|
|
self._docs.clear(); // 622
|
|
_.each(self.queries, function (query) { // 623
|
|
if (query.ordered) { // 624
|
|
query.results = []; // 625
|
|
} else { // 626
|
|
query.results.clear(); // 627
|
|
} // 628
|
|
}); // 629
|
|
if (callback) { // 630
|
|
Meteor.defer(function () { // 631
|
|
callback(null, result); // 632
|
|
}); // 633
|
|
} // 634
|
|
return result; // 635
|
|
} // 636
|
|
// 637
|
|
var matcher = new Minimongo.Matcher(selector); // 638
|
|
var remove = []; // 639
|
|
self._eachPossiblyMatchingDoc(selector, function (doc, id) { // 640
|
|
if (matcher.documentMatches(doc).result) // 641
|
|
remove.push(id); // 642
|
|
}); // 643
|
|
// 644
|
|
var queriesToRecompute = []; // 645
|
|
var queryRemove = []; // 646
|
|
for (var i = 0; i < remove.length; i++) { // 647
|
|
var removeId = remove[i]; // 648
|
|
var removeDoc = self._docs.get(removeId); // 649
|
|
_.each(self.queries, function (query, qid) { // 650
|
|
if (query.matcher.documentMatches(removeDoc).result) { // 651
|
|
if (query.cursor.skip || query.cursor.limit) // 652
|
|
queriesToRecompute.push(qid); // 653
|
|
else // 654
|
|
queryRemove.push({qid: qid, doc: removeDoc}); // 655
|
|
} // 656
|
|
}); // 657
|
|
self._saveOriginal(removeId, removeDoc); // 658
|
|
self._docs.remove(removeId); // 659
|
|
} // 660
|
|
// 661
|
|
// run live query callbacks _after_ we've removed the documents. // 662
|
|
_.each(queryRemove, function (remove) { // 663
|
|
var query = self.queries[remove.qid]; // 664
|
|
if (query) { // 665
|
|
query.distances && query.distances.remove(remove.doc._id); // 666
|
|
LocalCollection._removeFromResults(query, remove.doc); // 667
|
|
} // 668
|
|
}); // 669
|
|
_.each(queriesToRecompute, function (qid) { // 670
|
|
var query = self.queries[qid]; // 671
|
|
if (query) // 672
|
|
self._recomputeResults(query); // 673
|
|
}); // 674
|
|
self._observeQueue.drain(); // 675
|
|
result = remove.length; // 676
|
|
if (callback) // 677
|
|
Meteor.defer(function () { // 678
|
|
callback(null, result); // 679
|
|
}); // 680
|
|
return result; // 681
|
|
}; // 682
|
|
// 683
|
|
// XXX atomicity: if multi is true, and one modification fails, do // 684
|
|
// we rollback the whole operation, or what? // 685
|
|
LocalCollection.prototype.update = function (selector, mod, options, callback) { // 686
|
|
var self = this; // 687
|
|
if (! callback && options instanceof Function) { // 688
|
|
callback = options; // 689
|
|
options = null; // 690
|
|
} // 691
|
|
if (!options) options = {}; // 692
|
|
// 693
|
|
var matcher = new Minimongo.Matcher(selector); // 694
|
|
// 695
|
|
// Save the original results of any query that we might need to // 696
|
|
// _recomputeResults on, because _modifyAndNotify will mutate the objects in // 697
|
|
// it. (We don't need to save the original results of paused queries because // 698
|
|
// they already have a resultsSnapshot and we won't be diffing in // 699
|
|
// _recomputeResults.) // 700
|
|
var qidToOriginalResults = {}; // 701
|
|
_.each(self.queries, function (query, qid) { // 702
|
|
// XXX for now, skip/limit implies ordered observe, so query.results is // 703
|
|
// always an array // 704
|
|
if ((query.cursor.skip || query.cursor.limit) && ! self.paused) // 705
|
|
qidToOriginalResults[qid] = EJSON.clone(query.results); // 706
|
|
}); // 707
|
|
var recomputeQids = {}; // 708
|
|
// 709
|
|
var updateCount = 0; // 710
|
|
// 711
|
|
self._eachPossiblyMatchingDoc(selector, function (doc, id) { // 712
|
|
var queryResult = matcher.documentMatches(doc); // 713
|
|
if (queryResult.result) { // 714
|
|
// XXX Should we save the original even if mod ends up being a no-op? // 715
|
|
self._saveOriginal(id, doc); // 716
|
|
self._modifyAndNotify(doc, mod, recomputeQids, queryResult.arrayIndices); // 717
|
|
++updateCount; // 718
|
|
if (!options.multi) // 719
|
|
return false; // break // 720
|
|
} // 721
|
|
return true; // 722
|
|
}); // 723
|
|
// 724
|
|
_.each(recomputeQids, function (dummy, qid) { // 725
|
|
var query = self.queries[qid]; // 726
|
|
if (query) // 727
|
|
self._recomputeResults(query, qidToOriginalResults[qid]); // 728
|
|
}); // 729
|
|
self._observeQueue.drain(); // 730
|
|
// 731
|
|
// If we are doing an upsert, and we didn't modify any documents yet, then // 732
|
|
// it's time to do an insert. Figure out what document we are inserting, and // 733
|
|
// generate an id for it. // 734
|
|
var insertedId; // 735
|
|
if (updateCount === 0 && options.upsert) { // 736
|
|
var newDoc = LocalCollection._removeDollarOperators(selector); // 737
|
|
LocalCollection._modify(newDoc, mod, {isInsert: true}); // 738
|
|
if (! newDoc._id && options.insertedId) // 739
|
|
newDoc._id = options.insertedId; // 740
|
|
insertedId = self.insert(newDoc); // 741
|
|
updateCount = 1; // 742
|
|
} // 743
|
|
// 744
|
|
// Return the number of affected documents, or in the upsert case, an object // 745
|
|
// containing the number of affected docs and the id of the doc that was // 746
|
|
// inserted, if any. // 747
|
|
var result; // 748
|
|
if (options._returnObject) { // 749
|
|
result = { // 750
|
|
numberAffected: updateCount // 751
|
|
}; // 752
|
|
if (insertedId !== undefined) // 753
|
|
result.insertedId = insertedId; // 754
|
|
} else { // 755
|
|
result = updateCount; // 756
|
|
} // 757
|
|
// 758
|
|
if (callback) // 759
|
|
Meteor.defer(function () { // 760
|
|
callback(null, result); // 761
|
|
}); // 762
|
|
return result; // 763
|
|
}; // 764
|
|
// 765
|
|
// A convenience wrapper on update. LocalCollection.upsert(sel, mod) is // 766
|
|
// equivalent to LocalCollection.update(sel, mod, { upsert: true, _returnObject: // 767
|
|
// true }). // 768
|
|
LocalCollection.prototype.upsert = function (selector, mod, options, callback) { // 769
|
|
var self = this; // 770
|
|
if (! callback && typeof options === "function") { // 771
|
|
callback = options; // 772
|
|
options = {}; // 773
|
|
} // 774
|
|
return self.update(selector, mod, _.extend({}, options, { // 775
|
|
upsert: true, // 776
|
|
_returnObject: true // 777
|
|
}), callback); // 778
|
|
}; // 779
|
|
// 780
|
|
LocalCollection.prototype._modifyAndNotify = function ( // 781
|
|
doc, mod, recomputeQids, arrayIndices) { // 782
|
|
var self = this; // 783
|
|
// 784
|
|
var matched_before = {}; // 785
|
|
for (var qid in self.queries) { // 786
|
|
var query = self.queries[qid]; // 787
|
|
if (query.ordered) { // 788
|
|
matched_before[qid] = query.matcher.documentMatches(doc).result; // 789
|
|
} else { // 790
|
|
// Because we don't support skip or limit (yet) in unordered queries, we // 791
|
|
// can just do a direct lookup. // 792
|
|
matched_before[qid] = query.results.has(doc._id); // 793
|
|
} // 794
|
|
} // 795
|
|
// 796
|
|
var old_doc = EJSON.clone(doc); // 797
|
|
// 798
|
|
LocalCollection._modify(doc, mod, {arrayIndices: arrayIndices}); // 799
|
|
// 800
|
|
for (qid in self.queries) { // 801
|
|
query = self.queries[qid]; // 802
|
|
var before = matched_before[qid]; // 803
|
|
var afterMatch = query.matcher.documentMatches(doc); // 804
|
|
var after = afterMatch.result; // 805
|
|
if (after && query.distances && afterMatch.distance !== undefined) // 806
|
|
query.distances.set(doc._id, afterMatch.distance); // 807
|
|
// 808
|
|
if (query.cursor.skip || query.cursor.limit) { // 809
|
|
// We need to recompute any query where the doc may have been in the // 810
|
|
// cursor's window either before or after the update. (Note that if skip // 811
|
|
// or limit is set, "before" and "after" being true do not necessarily // 812
|
|
// mean that the document is in the cursor's output after skip/limit is // 813
|
|
// applied... but if they are false, then the document definitely is NOT // 814
|
|
// in the output. So it's safe to skip recompute if neither before or // 815
|
|
// after are true.) // 816
|
|
if (before || after) // 817
|
|
recomputeQids[qid] = true; // 818
|
|
} else if (before && !after) { // 819
|
|
LocalCollection._removeFromResults(query, doc); // 820
|
|
} else if (!before && after) { // 821
|
|
LocalCollection._insertInResults(query, doc); // 822
|
|
} else if (before && after) { // 823
|
|
LocalCollection._updateInResults(query, doc, old_doc); // 824
|
|
} // 825
|
|
} // 826
|
|
}; // 827
|
|
// 828
|
|
// XXX the sorted-query logic below is laughably inefficient. we'll // 829
|
|
// need to come up with a better datastructure for this. // 830
|
|
// // 831
|
|
// XXX the logic for observing with a skip or a limit is even more // 832
|
|
// laughably inefficient. we recompute the whole results every time! // 833
|
|
// 834
|
|
LocalCollection._insertInResults = function (query, doc) { // 835
|
|
var fields = EJSON.clone(doc); // 836
|
|
delete fields._id; // 837
|
|
if (query.ordered) { // 838
|
|
if (!query.sorter) { // 839
|
|
query.addedBefore(doc._id, query.projectionFn(fields), null); // 840
|
|
query.results.push(doc); // 841
|
|
} else { // 842
|
|
var i = LocalCollection._insertInSortedList( // 843
|
|
query.sorter.getComparator({distances: query.distances}), // 844
|
|
query.results, doc); // 845
|
|
var next = query.results[i+1]; // 846
|
|
if (next) // 847
|
|
next = next._id; // 848
|
|
else // 849
|
|
next = null; // 850
|
|
query.addedBefore(doc._id, query.projectionFn(fields), next); // 851
|
|
} // 852
|
|
query.added(doc._id, query.projectionFn(fields)); // 853
|
|
} else { // 854
|
|
query.added(doc._id, query.projectionFn(fields)); // 855
|
|
query.results.set(doc._id, doc); // 856
|
|
} // 857
|
|
}; // 858
|
|
// 859
|
|
LocalCollection._removeFromResults = function (query, doc) { // 860
|
|
if (query.ordered) { // 861
|
|
var i = LocalCollection._findInOrderedResults(query, doc); // 862
|
|
query.removed(doc._id); // 863
|
|
query.results.splice(i, 1); // 864
|
|
} else { // 865
|
|
var id = doc._id; // in case callback mutates doc // 866
|
|
query.removed(doc._id); // 867
|
|
query.results.remove(id); // 868
|
|
} // 869
|
|
}; // 870
|
|
// 871
|
|
LocalCollection._updateInResults = function (query, doc, old_doc) { // 872
|
|
if (!EJSON.equals(doc._id, old_doc._id)) // 873
|
|
throw new Error("Can't change a doc's _id while updating"); // 874
|
|
var projectionFn = query.projectionFn; // 875
|
|
var changedFields = LocalCollection._makeChangedFields( // 876
|
|
projectionFn(doc), projectionFn(old_doc)); // 877
|
|
// 878
|
|
if (!query.ordered) { // 879
|
|
if (!_.isEmpty(changedFields)) { // 880
|
|
query.changed(doc._id, changedFields); // 881
|
|
query.results.set(doc._id, doc); // 882
|
|
} // 883
|
|
return; // 884
|
|
} // 885
|
|
// 886
|
|
var orig_idx = LocalCollection._findInOrderedResults(query, doc); // 887
|
|
// 888
|
|
if (!_.isEmpty(changedFields)) // 889
|
|
query.changed(doc._id, changedFields); // 890
|
|
if (!query.sorter) // 891
|
|
return; // 892
|
|
// 893
|
|
// just take it out and put it back in again, and see if the index // 894
|
|
// changes // 895
|
|
query.results.splice(orig_idx, 1); // 896
|
|
var new_idx = LocalCollection._insertInSortedList( // 897
|
|
query.sorter.getComparator({distances: query.distances}), // 898
|
|
query.results, doc); // 899
|
|
if (orig_idx !== new_idx) { // 900
|
|
var next = query.results[new_idx+1]; // 901
|
|
if (next) // 902
|
|
next = next._id; // 903
|
|
else // 904
|
|
next = null; // 905
|
|
query.movedBefore && query.movedBefore(doc._id, next); // 906
|
|
} // 907
|
|
}; // 908
|
|
// 909
|
|
// Recomputes the results of a query and runs observe callbacks for the // 910
|
|
// difference between the previous results and the current results (unless // 911
|
|
// paused). Used for skip/limit queries. // 912
|
|
// // 913
|
|
// When this is used by insert or remove, it can just use query.results for the // 914
|
|
// old results (and there's no need to pass in oldResults), because these // 915
|
|
// operations don't mutate the documents in the collection. Update needs to pass // 916
|
|
// in an oldResults which was deep-copied before the modifier was applied. // 917
|
|
// // 918
|
|
// oldResults is guaranteed to be ignored if the query is not paused. // 919
|
|
LocalCollection.prototype._recomputeResults = function (query, oldResults) { // 920
|
|
var self = this; // 921
|
|
if (! self.paused && ! oldResults) // 922
|
|
oldResults = query.results; // 923
|
|
if (query.distances) // 924
|
|
query.distances.clear(); // 925
|
|
query.results = query.cursor._getRawObjects({ // 926
|
|
ordered: query.ordered, distances: query.distances}); // 927
|
|
// 928
|
|
if (! self.paused) { // 929
|
|
LocalCollection._diffQueryChanges( // 930
|
|
query.ordered, oldResults, query.results, query, // 931
|
|
{ projectionFn: query.projectionFn }); // 932
|
|
} // 933
|
|
}; // 934
|
|
// 935
|
|
// 936
|
|
LocalCollection._findInOrderedResults = function (query, doc) { // 937
|
|
if (!query.ordered) // 938
|
|
throw new Error("Can't call _findInOrderedResults on unordered query"); // 939
|
|
for (var i = 0; i < query.results.length; i++) // 940
|
|
if (query.results[i] === doc) // 941
|
|
return i; // 942
|
|
throw Error("object missing from query"); // 943
|
|
}; // 944
|
|
// 945
|
|
// This binary search puts a value between any equal values, and the first // 946
|
|
// lesser value. // 947
|
|
LocalCollection._binarySearch = function (cmp, array, value) { // 948
|
|
var first = 0, rangeLength = array.length; // 949
|
|
// 950
|
|
while (rangeLength > 0) { // 951
|
|
var halfRange = Math.floor(rangeLength/2); // 952
|
|
if (cmp(value, array[first + halfRange]) >= 0) { // 953
|
|
first += halfRange + 1; // 954
|
|
rangeLength -= halfRange + 1; // 955
|
|
} else { // 956
|
|
rangeLength = halfRange; // 957
|
|
} // 958
|
|
} // 959
|
|
return first; // 960
|
|
}; // 961
|
|
// 962
|
|
LocalCollection._insertInSortedList = function (cmp, array, value) { // 963
|
|
if (array.length === 0) { // 964
|
|
array.push(value); // 965
|
|
return 0; // 966
|
|
} // 967
|
|
// 968
|
|
var idx = LocalCollection._binarySearch(cmp, array, value); // 969
|
|
array.splice(idx, 0, value); // 970
|
|
return idx; // 971
|
|
}; // 972
|
|
// 973
|
|
// To track what documents are affected by a piece of code, call saveOriginals() // 974
|
|
// before it and retrieveOriginals() after it. retrieveOriginals returns an // 975
|
|
// object whose keys are the ids of the documents that were affected since the // 976
|
|
// call to saveOriginals(), and the values are equal to the document's contents // 977
|
|
// at the time of saveOriginals. (In the case of an inserted document, undefined // 978
|
|
// is the value.) You must alternate between calls to saveOriginals() and // 979
|
|
// retrieveOriginals(). // 980
|
|
LocalCollection.prototype.saveOriginals = function () { // 981
|
|
var self = this; // 982
|
|
if (self._savedOriginals) // 983
|
|
throw new Error("Called saveOriginals twice without retrieveOriginals"); // 984
|
|
self._savedOriginals = new LocalCollection._IdMap; // 985
|
|
}; // 986
|
|
LocalCollection.prototype.retrieveOriginals = function () { // 987
|
|
var self = this; // 988
|
|
if (!self._savedOriginals) // 989
|
|
throw new Error("Called retrieveOriginals without saveOriginals"); // 990
|
|
// 991
|
|
var originals = self._savedOriginals; // 992
|
|
self._savedOriginals = null; // 993
|
|
return originals; // 994
|
|
}; // 995
|
|
// 996
|
|
LocalCollection.prototype._saveOriginal = function (id, doc) { // 997
|
|
var self = this; // 998
|
|
// Are we even trying to save originals? // 999
|
|
if (!self._savedOriginals) // 1000
|
|
return; // 1001
|
|
// Have we previously mutated the original (and so 'doc' is not actually // 1002
|
|
// original)? (Note the 'has' check rather than truth: we store undefined // 1003
|
|
// here for inserted docs!) // 1004
|
|
if (self._savedOriginals.has(id)) // 1005
|
|
return; // 1006
|
|
self._savedOriginals.set(id, EJSON.clone(doc)); // 1007
|
|
}; // 1008
|
|
// 1009
|
|
// Pause the observers. No callbacks from observers will fire until // 1010
|
|
// 'resumeObservers' is called. // 1011
|
|
LocalCollection.prototype.pauseObservers = function () { // 1012
|
|
// No-op if already paused. // 1013
|
|
if (this.paused) // 1014
|
|
return; // 1015
|
|
// 1016
|
|
// Set the 'paused' flag such that new observer messages don't fire. // 1017
|
|
this.paused = true; // 1018
|
|
// 1019
|
|
// Take a snapshot of the query results for each query. // 1020
|
|
for (var qid in this.queries) { // 1021
|
|
var query = this.queries[qid]; // 1022
|
|
// 1023
|
|
query.resultsSnapshot = EJSON.clone(query.results); // 1024
|
|
} // 1025
|
|
}; // 1026
|
|
// 1027
|
|
// Resume the observers. Observers immediately receive change // 1028
|
|
// notifications to bring them to the current state of the // 1029
|
|
// database. Note that this is not just replaying all the changes that // 1030
|
|
// happened during the pause, it is a smarter 'coalesced' diff. // 1031
|
|
LocalCollection.prototype.resumeObservers = function () { // 1032
|
|
var self = this; // 1033
|
|
// No-op if not paused. // 1034
|
|
if (!this.paused) // 1035
|
|
return; // 1036
|
|
// 1037
|
|
// Unset the 'paused' flag. Make sure to do this first, otherwise // 1038
|
|
// observer methods won't actually fire when we trigger them. // 1039
|
|
this.paused = false; // 1040
|
|
// 1041
|
|
for (var qid in this.queries) { // 1042
|
|
var query = self.queries[qid]; // 1043
|
|
// Diff the current results against the snapshot and send to observers. // 1044
|
|
// pass the query object for its observer callbacks. // 1045
|
|
LocalCollection._diffQueryChanges( // 1046
|
|
query.ordered, query.resultsSnapshot, query.results, query, // 1047
|
|
{ projectionFn: query.projectionFn }); // 1048
|
|
query.resultsSnapshot = null; // 1049
|
|
} // 1050
|
|
self._observeQueue.drain(); // 1051
|
|
}; // 1052
|
|
// 1053
|
|
// 1054
|
|
// NB: used by livedata // 1055
|
|
LocalCollection._idStringify = function (id) { // 1056
|
|
if (id instanceof LocalCollection._ObjectID) { // 1057
|
|
return id.valueOf(); // 1058
|
|
} else if (typeof id === 'string') { // 1059
|
|
if (id === "") { // 1060
|
|
return id; // 1061
|
|
} else if (id.substr(0, 1) === "-" || // escape previously dashed strings // 1062
|
|
id.substr(0, 1) === "~" || // escape escaped numbers, true, false // 1063
|
|
LocalCollection._looksLikeObjectID(id) || // escape object-id-form strings // 1064
|
|
id.substr(0, 1) === '{') { // escape object-form strings, for maybe implementing later // 1065
|
|
return "-" + id; // 1066
|
|
} else { // 1067
|
|
return id; // other strings go through unchanged. // 1068
|
|
} // 1069
|
|
} else if (id === undefined) { // 1070
|
|
return '-'; // 1071
|
|
} else if (typeof id === 'object' && id !== null) { // 1072
|
|
throw new Error("Meteor does not currently support objects other than ObjectID as ids"); // 1073
|
|
} else { // Numbers, true, false, null // 1074
|
|
return "~" + JSON.stringify(id); // 1075
|
|
} // 1076
|
|
}; // 1077
|
|
// 1078
|
|
// 1079
|
|
// NB: used by livedata // 1080
|
|
LocalCollection._idParse = function (id) { // 1081
|
|
if (id === "") { // 1082
|
|
return id; // 1083
|
|
} else if (id === '-') { // 1084
|
|
return undefined; // 1085
|
|
} else if (id.substr(0, 1) === '-') { // 1086
|
|
return id.substr(1); // 1087
|
|
} else if (id.substr(0, 1) === '~') { // 1088
|
|
return JSON.parse(id.substr(1)); // 1089
|
|
} else if (LocalCollection._looksLikeObjectID(id)) { // 1090
|
|
return new LocalCollection._ObjectID(id); // 1091
|
|
} else { // 1092
|
|
return id; // 1093
|
|
} // 1094
|
|
}; // 1095
|
|
// 1096
|
|
LocalCollection._makeChangedFields = function (newDoc, oldDoc) { // 1097
|
|
var fields = {}; // 1098
|
|
LocalCollection._diffObjects(oldDoc, newDoc, { // 1099
|
|
leftOnly: function (key, value) { // 1100
|
|
fields[key] = undefined; // 1101
|
|
}, // 1102
|
|
rightOnly: function (key, value) { // 1103
|
|
fields[key] = value; // 1104
|
|
}, // 1105
|
|
both: function (key, leftValue, rightValue) { // 1106
|
|
if (!EJSON.equals(leftValue, rightValue)) // 1107
|
|
fields[key] = rightValue; // 1108
|
|
} // 1109
|
|
}); // 1110
|
|
return fields; // 1111
|
|
}; // 1112
|
|
// 1113
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/wrap_transform.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Wrap a transform function to return objects that have the _id field // 1
|
|
// of the untransformed document. This ensures that subsystems such as // 2
|
|
// the observe-sequence package that call `observe` can keep track of // 3
|
|
// the documents identities. // 4
|
|
// // 5
|
|
// - Require that it returns objects // 6
|
|
// - If the return value has an _id field, verify that it matches the // 7
|
|
// original _id field // 8
|
|
// - If the return value doesn't have an _id field, add it back. // 9
|
|
LocalCollection.wrapTransform = function (transform) { // 10
|
|
if (! transform) // 11
|
|
return null; // 12
|
|
// 13
|
|
// No need to doubly-wrap transforms. // 14
|
|
if (transform.__wrappedTransform__) // 15
|
|
return transform; // 16
|
|
// 17
|
|
var wrapped = function (doc) { // 18
|
|
if (!_.has(doc, '_id')) { // 19
|
|
// XXX do we ever have a transform on the oplog's collection? because that // 20
|
|
// collection has no _id. // 21
|
|
throw new Error("can only transform documents with _id"); // 22
|
|
} // 23
|
|
// 24
|
|
var id = doc._id; // 25
|
|
// XXX consider making tracker a weak dependency and checking Package.tracker here // 26
|
|
var transformed = Tracker.nonreactive(function () { // 27
|
|
return transform(doc); // 28
|
|
}); // 29
|
|
// 30
|
|
if (!isPlainObject(transformed)) { // 31
|
|
throw new Error("transform must return object"); // 32
|
|
} // 33
|
|
// 34
|
|
if (_.has(transformed, '_id')) { // 35
|
|
if (!EJSON.equals(transformed._id, id)) { // 36
|
|
throw new Error("transformed document can't have different _id"); // 37
|
|
} // 38
|
|
} else { // 39
|
|
transformed._id = id; // 40
|
|
} // 41
|
|
return transformed; // 42
|
|
}; // 43
|
|
wrapped.__wrappedTransform__ = true; // 44
|
|
return wrapped; // 45
|
|
}; // 46
|
|
// 47
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/helpers.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Like _.isArray, but doesn't regard polyfilled Uint8Arrays on old browsers as // 1
|
|
// arrays. // 2
|
|
// XXX maybe this should be EJSON.isArray // 3
|
|
isArray = function (x) { // 4
|
|
return _.isArray(x) && !EJSON.isBinary(x); // 5
|
|
}; // 6
|
|
// 7
|
|
// XXX maybe this should be EJSON.isObject, though EJSON doesn't know about // 8
|
|
// RegExp // 9
|
|
// XXX note that _type(undefined) === 3!!!! // 10
|
|
isPlainObject = LocalCollection._isPlainObject = function (x) { // 11
|
|
return x && LocalCollection._f._type(x) === 3; // 12
|
|
}; // 13
|
|
// 14
|
|
isIndexable = function (x) { // 15
|
|
return isArray(x) || isPlainObject(x); // 16
|
|
}; // 17
|
|
// 18
|
|
// Returns true if this is an object with at least one key and all keys begin // 19
|
|
// with $. Unless inconsistentOK is set, throws if some keys begin with $ and // 20
|
|
// others don't. // 21
|
|
isOperatorObject = function (valueSelector, inconsistentOK) { // 22
|
|
if (!isPlainObject(valueSelector)) // 23
|
|
return false; // 24
|
|
// 25
|
|
var theseAreOperators = undefined; // 26
|
|
_.each(valueSelector, function (value, selKey) { // 27
|
|
var thisIsOperator = selKey.substr(0, 1) === '$'; // 28
|
|
if (theseAreOperators === undefined) { // 29
|
|
theseAreOperators = thisIsOperator; // 30
|
|
} else if (theseAreOperators !== thisIsOperator) { // 31
|
|
if (!inconsistentOK) // 32
|
|
throw new Error("Inconsistent operator: " + // 33
|
|
JSON.stringify(valueSelector)); // 34
|
|
theseAreOperators = false; // 35
|
|
} // 36
|
|
}); // 37
|
|
return !!theseAreOperators; // {} has no operators // 38
|
|
}; // 39
|
|
// 40
|
|
// 41
|
|
// string can be converted to integer // 42
|
|
isNumericKey = function (s) { // 43
|
|
return /^[0-9]+$/.test(s); // 44
|
|
}; // 45
|
|
// 46
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/selector.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// The minimongo selector compiler! // 1
|
|
// 2
|
|
// Terminology: // 3
|
|
// - a "selector" is the EJSON object representing a selector // 4
|
|
// - a "matcher" is its compiled form (whether a full Minimongo.Matcher // 5
|
|
// object or one of the component lambdas that matches parts of it) // 6
|
|
// - a "result object" is an object with a "result" field and maybe // 7
|
|
// distance and arrayIndices. // 8
|
|
// - a "branched value" is an object with a "value" field and maybe // 9
|
|
// "dontIterate" and "arrayIndices". // 10
|
|
// - a "document" is a top-level object that can be stored in a collection. // 11
|
|
// - a "lookup function" is a function that takes in a document and returns // 12
|
|
// an array of "branched values". // 13
|
|
// - a "branched matcher" maps from an array of branched values to a result // 14
|
|
// object. // 15
|
|
// - an "element matcher" maps from a single value to a bool. // 16
|
|
// 17
|
|
// Main entry point. // 18
|
|
// var matcher = new Minimongo.Matcher({a: {$gt: 5}}); // 19
|
|
// if (matcher.documentMatches({a: 7})) ... // 20
|
|
Minimongo.Matcher = function (selector) { // 21
|
|
var self = this; // 22
|
|
// A set (object mapping string -> *) of all of the document paths looked // 23
|
|
// at by the selector. Also includes the empty string if it may look at any // 24
|
|
// path (eg, $where). // 25
|
|
self._paths = {}; // 26
|
|
// Set to true if compilation finds a $near. // 27
|
|
self._hasGeoQuery = false; // 28
|
|
// Set to true if compilation finds a $where. // 29
|
|
self._hasWhere = false; // 30
|
|
// Set to false if compilation finds anything other than a simple equality or // 31
|
|
// one or more of '$gt', '$gte', '$lt', '$lte', '$ne', '$in', '$nin' used with // 32
|
|
// scalars as operands. // 33
|
|
self._isSimple = true; // 34
|
|
// Set to a dummy document which always matches this Matcher. Or set to null // 35
|
|
// if such document is too hard to find. // 36
|
|
self._matchingDocument = undefined; // 37
|
|
// A clone of the original selector. It may just be a function if the user // 38
|
|
// passed in a function; otherwise is definitely an object (eg, IDs are // 39
|
|
// translated into {_id: ID} first. Used by canBecomeTrueByModifier and // 40
|
|
// Sorter._useWithMatcher. // 41
|
|
self._selector = null; // 42
|
|
self._docMatcher = self._compileSelector(selector); // 43
|
|
}; // 44
|
|
// 45
|
|
_.extend(Minimongo.Matcher.prototype, { // 46
|
|
documentMatches: function (doc) { // 47
|
|
if (!doc || typeof doc !== "object") { // 48
|
|
throw Error("documentMatches needs a document"); // 49
|
|
} // 50
|
|
return this._docMatcher(doc); // 51
|
|
}, // 52
|
|
hasGeoQuery: function () { // 53
|
|
return this._hasGeoQuery; // 54
|
|
}, // 55
|
|
hasWhere: function () { // 56
|
|
return this._hasWhere; // 57
|
|
}, // 58
|
|
isSimple: function () { // 59
|
|
return this._isSimple; // 60
|
|
}, // 61
|
|
// 62
|
|
// Given a selector, return a function that takes one argument, a // 63
|
|
// document. It returns a result object. // 64
|
|
_compileSelector: function (selector) { // 65
|
|
var self = this; // 66
|
|
// you can pass a literal function instead of a selector // 67
|
|
if (selector instanceof Function) { // 68
|
|
self._isSimple = false; // 69
|
|
self._selector = selector; // 70
|
|
self._recordPathUsed(''); // 71
|
|
return function (doc) { // 72
|
|
return {result: !!selector.call(doc)}; // 73
|
|
}; // 74
|
|
} // 75
|
|
// 76
|
|
// shorthand -- scalars match _id // 77
|
|
if (LocalCollection._selectorIsId(selector)) { // 78
|
|
self._selector = {_id: selector}; // 79
|
|
self._recordPathUsed('_id'); // 80
|
|
return function (doc) { // 81
|
|
return {result: EJSON.equals(doc._id, selector)}; // 82
|
|
}; // 83
|
|
} // 84
|
|
// 85
|
|
// protect against dangerous selectors. falsey and {_id: falsey} are both // 86
|
|
// likely programmer error, and not what you want, particularly for // 87
|
|
// destructive operations. // 88
|
|
if (!selector || (('_id' in selector) && !selector._id)) { // 89
|
|
self._isSimple = false; // 90
|
|
return nothingMatcher; // 91
|
|
} // 92
|
|
// 93
|
|
// Top level can't be an array or true or binary. // 94
|
|
if (typeof(selector) === 'boolean' || isArray(selector) || // 95
|
|
EJSON.isBinary(selector)) // 96
|
|
throw new Error("Invalid selector: " + selector); // 97
|
|
// 98
|
|
self._selector = EJSON.clone(selector); // 99
|
|
return compileDocumentSelector(selector, self, {isRoot: true}); // 100
|
|
}, // 101
|
|
_recordPathUsed: function (path) { // 102
|
|
this._paths[path] = true; // 103
|
|
}, // 104
|
|
// Returns a list of key paths the given selector is looking for. It includes // 105
|
|
// the empty string if there is a $where. // 106
|
|
_getPaths: function () { // 107
|
|
return _.keys(this._paths); // 108
|
|
} // 109
|
|
}); // 110
|
|
// 111
|
|
// 112
|
|
// Takes in a selector that could match a full document (eg, the original // 113
|
|
// selector). Returns a function mapping document->result object. // 114
|
|
// // 115
|
|
// matcher is the Matcher object we are compiling. // 116
|
|
// // 117
|
|
// If this is the root document selector (ie, not wrapped in $and or the like), // 118
|
|
// then isRoot is true. (This is used by $near.) // 119
|
|
var compileDocumentSelector = function (docSelector, matcher, options) { // 120
|
|
options = options || {}; // 121
|
|
var docMatchers = []; // 122
|
|
_.each(docSelector, function (subSelector, key) { // 123
|
|
if (key.substr(0, 1) === '$') { // 124
|
|
// Outer operators are either logical operators (they recurse back into // 125
|
|
// this function), or $where. // 126
|
|
if (!_.has(LOGICAL_OPERATORS, key)) // 127
|
|
throw new Error("Unrecognized logical operator: " + key); // 128
|
|
matcher._isSimple = false; // 129
|
|
docMatchers.push(LOGICAL_OPERATORS[key](subSelector, matcher, // 130
|
|
options.inElemMatch)); // 131
|
|
} else { // 132
|
|
// Record this path, but only if we aren't in an elemMatcher, since in an // 133
|
|
// elemMatch this is a path inside an object in an array, not in the doc // 134
|
|
// root. // 135
|
|
if (!options.inElemMatch) // 136
|
|
matcher._recordPathUsed(key); // 137
|
|
var lookUpByIndex = makeLookupFunction(key); // 138
|
|
var valueMatcher = // 139
|
|
compileValueSelector(subSelector, matcher, options.isRoot); // 140
|
|
docMatchers.push(function (doc) { // 141
|
|
var branchValues = lookUpByIndex(doc); // 142
|
|
return valueMatcher(branchValues); // 143
|
|
}); // 144
|
|
} // 145
|
|
}); // 146
|
|
// 147
|
|
return andDocumentMatchers(docMatchers); // 148
|
|
}; // 149
|
|
// 150
|
|
// Takes in a selector that could match a key-indexed value in a document; eg, // 151
|
|
// {$gt: 5, $lt: 9}, or a regular expression, or any non-expression object (to // 152
|
|
// indicate equality). Returns a branched matcher: a function mapping // 153
|
|
// [branched value]->result object. // 154
|
|
var compileValueSelector = function (valueSelector, matcher, isRoot) { // 155
|
|
if (valueSelector instanceof RegExp) { // 156
|
|
matcher._isSimple = false; // 157
|
|
return convertElementMatcherToBranchedMatcher( // 158
|
|
regexpElementMatcher(valueSelector)); // 159
|
|
} else if (isOperatorObject(valueSelector)) { // 160
|
|
return operatorBranchedMatcher(valueSelector, matcher, isRoot); // 161
|
|
} else { // 162
|
|
return convertElementMatcherToBranchedMatcher( // 163
|
|
equalityElementMatcher(valueSelector)); // 164
|
|
} // 165
|
|
}; // 166
|
|
// 167
|
|
// Given an element matcher (which evaluates a single value), returns a branched // 168
|
|
// value (which evaluates the element matcher on all the branches and returns a // 169
|
|
// more structured return value possibly including arrayIndices). // 170
|
|
var convertElementMatcherToBranchedMatcher = function ( // 171
|
|
elementMatcher, options) { // 172
|
|
options = options || {}; // 173
|
|
return function (branches) { // 174
|
|
var expanded = branches; // 175
|
|
if (!options.dontExpandLeafArrays) { // 176
|
|
expanded = expandArraysInBranches( // 177
|
|
branches, options.dontIncludeLeafArrays); // 178
|
|
} // 179
|
|
var ret = {}; // 180
|
|
ret.result = _.any(expanded, function (element) { // 181
|
|
var matched = elementMatcher(element.value); // 182
|
|
// 183
|
|
// Special case for $elemMatch: it means "true, and use this as an array // 184
|
|
// index if I didn't already have one". // 185
|
|
if (typeof matched === 'number') { // 186
|
|
// XXX This code dates from when we only stored a single array index // 187
|
|
// (for the outermost array). Should we be also including deeper array // 188
|
|
// indices from the $elemMatch match? // 189
|
|
if (!element.arrayIndices) // 190
|
|
element.arrayIndices = [matched]; // 191
|
|
matched = true; // 192
|
|
} // 193
|
|
// 194
|
|
// If some element matched, and it's tagged with array indices, include // 195
|
|
// those indices in our result object. // 196
|
|
if (matched && element.arrayIndices) // 197
|
|
ret.arrayIndices = element.arrayIndices; // 198
|
|
// 199
|
|
return matched; // 200
|
|
}); // 201
|
|
return ret; // 202
|
|
}; // 203
|
|
}; // 204
|
|
// 205
|
|
// Takes a RegExp object and returns an element matcher. // 206
|
|
regexpElementMatcher = function (regexp) { // 207
|
|
return function (value) { // 208
|
|
if (value instanceof RegExp) { // 209
|
|
// Comparing two regexps means seeing if the regexps are identical // 210
|
|
// (really!). Underscore knows how. // 211
|
|
return _.isEqual(value, regexp); // 212
|
|
} // 213
|
|
// Regexps only work against strings. // 214
|
|
if (typeof value !== 'string') // 215
|
|
return false; // 216
|
|
// 217
|
|
// Reset regexp's state to avoid inconsistent matching for objects with the // 218
|
|
// same value on consecutive calls of regexp.test. This happens only if the // 219
|
|
// regexp has the 'g' flag. Also note that ES6 introduces a new flag 'y' for // 220
|
|
// which we should *not* change the lastIndex but MongoDB doesn't support // 221
|
|
// either of these flags. // 222
|
|
regexp.lastIndex = 0; // 223
|
|
// 224
|
|
return regexp.test(value); // 225
|
|
}; // 226
|
|
}; // 227
|
|
// 228
|
|
// Takes something that is not an operator object and returns an element matcher // 229
|
|
// for equality with that thing. // 230
|
|
equalityElementMatcher = function (elementSelector) { // 231
|
|
if (isOperatorObject(elementSelector)) // 232
|
|
throw Error("Can't create equalityValueSelector for operator object"); // 233
|
|
// 234
|
|
// Special-case: null and undefined are equal (if you got undefined in there // 235
|
|
// somewhere, or if you got it due to some branch being non-existent in the // 236
|
|
// weird special case), even though they aren't with EJSON.equals. // 237
|
|
if (elementSelector == null) { // undefined or null // 238
|
|
return function (value) { // 239
|
|
return value == null; // undefined or null // 240
|
|
}; // 241
|
|
} // 242
|
|
// 243
|
|
return function (value) { // 244
|
|
return LocalCollection._f._equal(elementSelector, value); // 245
|
|
}; // 246
|
|
}; // 247
|
|
// 248
|
|
// Takes an operator object (an object with $ keys) and returns a branched // 249
|
|
// matcher for it. // 250
|
|
var operatorBranchedMatcher = function (valueSelector, matcher, isRoot) { // 251
|
|
// Each valueSelector works separately on the various branches. So one // 252
|
|
// operator can match one branch and another can match another branch. This // 253
|
|
// is OK. // 254
|
|
// 255
|
|
var operatorMatchers = []; // 256
|
|
_.each(valueSelector, function (operand, operator) { // 257
|
|
// XXX we should actually implement $eq, which is new in 2.6 // 258
|
|
var simpleRange = _.contains(['$lt', '$lte', '$gt', '$gte'], operator) && // 259
|
|
_.isNumber(operand); // 260
|
|
var simpleInequality = operator === '$ne' && !_.isObject(operand); // 261
|
|
var simpleInclusion = _.contains(['$in', '$nin'], operator) && // 262
|
|
_.isArray(operand) && !_.any(operand, _.isObject); // 263
|
|
// 264
|
|
if (! (operator === '$eq' || simpleRange || // 265
|
|
simpleInclusion || simpleInequality)) { // 266
|
|
matcher._isSimple = false; // 267
|
|
} // 268
|
|
// 269
|
|
if (_.has(VALUE_OPERATORS, operator)) { // 270
|
|
operatorMatchers.push( // 271
|
|
VALUE_OPERATORS[operator](operand, valueSelector, matcher, isRoot)); // 272
|
|
} else if (_.has(ELEMENT_OPERATORS, operator)) { // 273
|
|
var options = ELEMENT_OPERATORS[operator]; // 274
|
|
operatorMatchers.push( // 275
|
|
convertElementMatcherToBranchedMatcher( // 276
|
|
options.compileElementSelector( // 277
|
|
operand, valueSelector, matcher), // 278
|
|
options)); // 279
|
|
} else { // 280
|
|
throw new Error("Unrecognized operator: " + operator); // 281
|
|
} // 282
|
|
}); // 283
|
|
// 284
|
|
return andBranchedMatchers(operatorMatchers); // 285
|
|
}; // 286
|
|
// 287
|
|
var compileArrayOfDocumentSelectors = function ( // 288
|
|
selectors, matcher, inElemMatch) { // 289
|
|
if (!isArray(selectors) || _.isEmpty(selectors)) // 290
|
|
throw Error("$and/$or/$nor must be nonempty array"); // 291
|
|
return _.map(selectors, function (subSelector) { // 292
|
|
if (!isPlainObject(subSelector)) // 293
|
|
throw Error("$or/$and/$nor entries need to be full objects"); // 294
|
|
return compileDocumentSelector( // 295
|
|
subSelector, matcher, {inElemMatch: inElemMatch}); // 296
|
|
}); // 297
|
|
}; // 298
|
|
// 299
|
|
// Operators that appear at the top level of a document selector. // 300
|
|
var LOGICAL_OPERATORS = { // 301
|
|
$and: function (subSelector, matcher, inElemMatch) { // 302
|
|
var matchers = compileArrayOfDocumentSelectors( // 303
|
|
subSelector, matcher, inElemMatch); // 304
|
|
return andDocumentMatchers(matchers); // 305
|
|
}, // 306
|
|
// 307
|
|
$or: function (subSelector, matcher, inElemMatch) { // 308
|
|
var matchers = compileArrayOfDocumentSelectors( // 309
|
|
subSelector, matcher, inElemMatch); // 310
|
|
// 311
|
|
// Special case: if there is only one matcher, use it directly, *preserving* // 312
|
|
// any arrayIndices it returns. // 313
|
|
if (matchers.length === 1) // 314
|
|
return matchers[0]; // 315
|
|
// 316
|
|
return function (doc) { // 317
|
|
var result = _.any(matchers, function (f) { // 318
|
|
return f(doc).result; // 319
|
|
}); // 320
|
|
// $or does NOT set arrayIndices when it has multiple // 321
|
|
// sub-expressions. (Tested against MongoDB.) // 322
|
|
return {result: result}; // 323
|
|
}; // 324
|
|
}, // 325
|
|
// 326
|
|
$nor: function (subSelector, matcher, inElemMatch) { // 327
|
|
var matchers = compileArrayOfDocumentSelectors( // 328
|
|
subSelector, matcher, inElemMatch); // 329
|
|
return function (doc) { // 330
|
|
var result = _.all(matchers, function (f) { // 331
|
|
return !f(doc).result; // 332
|
|
}); // 333
|
|
// Never set arrayIndices, because we only match if nothing in particular // 334
|
|
// "matched" (and because this is consistent with MongoDB). // 335
|
|
return {result: result}; // 336
|
|
}; // 337
|
|
}, // 338
|
|
// 339
|
|
$where: function (selectorValue, matcher) { // 340
|
|
// Record that *any* path may be used. // 341
|
|
matcher._recordPathUsed(''); // 342
|
|
matcher._hasWhere = true; // 343
|
|
if (!(selectorValue instanceof Function)) { // 344
|
|
// XXX MongoDB seems to have more complex logic to decide where or or not // 345
|
|
// to add "return"; not sure exactly what it is. // 346
|
|
selectorValue = Function("obj", "return " + selectorValue); // 347
|
|
} // 348
|
|
return function (doc) { // 349
|
|
// We make the document available as both `this` and `obj`. // 350
|
|
// XXX not sure what we should do if this throws // 351
|
|
return {result: selectorValue.call(doc, doc)}; // 352
|
|
}; // 353
|
|
}, // 354
|
|
// 355
|
|
// This is just used as a comment in the query (in MongoDB, it also ends up in // 356
|
|
// query logs); it has no effect on the actual selection. // 357
|
|
$comment: function () { // 358
|
|
return function () { // 359
|
|
return {result: true}; // 360
|
|
}; // 361
|
|
} // 362
|
|
}; // 363
|
|
// 364
|
|
// Returns a branched matcher that matches iff the given matcher does not. // 365
|
|
// Note that this implicitly "deMorganizes" the wrapped function. ie, it // 366
|
|
// means that ALL branch values need to fail to match innerBranchedMatcher. // 367
|
|
var invertBranchedMatcher = function (branchedMatcher) { // 368
|
|
return function (branchValues) { // 369
|
|
var invertMe = branchedMatcher(branchValues); // 370
|
|
// We explicitly choose to strip arrayIndices here: it doesn't make sense to // 371
|
|
// say "update the array element that does not match something", at least // 372
|
|
// in mongo-land. // 373
|
|
return {result: !invertMe.result}; // 374
|
|
}; // 375
|
|
}; // 376
|
|
// 377
|
|
// Operators that (unlike LOGICAL_OPERATORS) pertain to individual paths in a // 378
|
|
// document, but (unlike ELEMENT_OPERATORS) do not have a simple definition as // 379
|
|
// "match each branched value independently and combine with // 380
|
|
// convertElementMatcherToBranchedMatcher". // 381
|
|
var VALUE_OPERATORS = { // 382
|
|
$not: function (operand, valueSelector, matcher) { // 383
|
|
return invertBranchedMatcher(compileValueSelector(operand, matcher)); // 384
|
|
}, // 385
|
|
$ne: function (operand) { // 386
|
|
return invertBranchedMatcher(convertElementMatcherToBranchedMatcher( // 387
|
|
equalityElementMatcher(operand))); // 388
|
|
}, // 389
|
|
$nin: function (operand) { // 390
|
|
return invertBranchedMatcher(convertElementMatcherToBranchedMatcher( // 391
|
|
ELEMENT_OPERATORS.$in.compileElementSelector(operand))); // 392
|
|
}, // 393
|
|
$exists: function (operand) { // 394
|
|
var exists = convertElementMatcherToBranchedMatcher(function (value) { // 395
|
|
return value !== undefined; // 396
|
|
}); // 397
|
|
return operand ? exists : invertBranchedMatcher(exists); // 398
|
|
}, // 399
|
|
// $options just provides options for $regex; its logic is inside $regex // 400
|
|
$options: function (operand, valueSelector) { // 401
|
|
if (!_.has(valueSelector, '$regex')) // 402
|
|
throw Error("$options needs a $regex"); // 403
|
|
return everythingMatcher; // 404
|
|
}, // 405
|
|
// $maxDistance is basically an argument to $near // 406
|
|
$maxDistance: function (operand, valueSelector) { // 407
|
|
if (!valueSelector.$near) // 408
|
|
throw Error("$maxDistance needs a $near"); // 409
|
|
return everythingMatcher; // 410
|
|
}, // 411
|
|
$all: function (operand, valueSelector, matcher) { // 412
|
|
if (!isArray(operand)) // 413
|
|
throw Error("$all requires array"); // 414
|
|
// Not sure why, but this seems to be what MongoDB does. // 415
|
|
if (_.isEmpty(operand)) // 416
|
|
return nothingMatcher; // 417
|
|
// 418
|
|
var branchedMatchers = []; // 419
|
|
_.each(operand, function (criterion) { // 420
|
|
// XXX handle $all/$elemMatch combination // 421
|
|
if (isOperatorObject(criterion)) // 422
|
|
throw Error("no $ expressions in $all"); // 423
|
|
// This is always a regexp or equality selector. // 424
|
|
branchedMatchers.push(compileValueSelector(criterion, matcher)); // 425
|
|
}); // 426
|
|
// andBranchedMatchers does NOT require all selectors to return true on the // 427
|
|
// SAME branch. // 428
|
|
return andBranchedMatchers(branchedMatchers); // 429
|
|
}, // 430
|
|
$near: function (operand, valueSelector, matcher, isRoot) { // 431
|
|
if (!isRoot) // 432
|
|
throw Error("$near can't be inside another $ operator"); // 433
|
|
matcher._hasGeoQuery = true; // 434
|
|
// 435
|
|
// There are two kinds of geodata in MongoDB: coordinate pairs and // 436
|
|
// GeoJSON. They use different distance metrics, too. GeoJSON queries are // 437
|
|
// marked with a $geometry property. // 438
|
|
// 439
|
|
var maxDistance, point, distance; // 440
|
|
if (isPlainObject(operand) && _.has(operand, '$geometry')) { // 441
|
|
// GeoJSON "2dsphere" mode. // 442
|
|
maxDistance = operand.$maxDistance; // 443
|
|
point = operand.$geometry; // 444
|
|
distance = function (value) { // 445
|
|
// XXX: for now, we don't calculate the actual distance between, say, // 446
|
|
// polygon and circle. If people care about this use-case it will get // 447
|
|
// a priority. // 448
|
|
if (!value || !value.type) // 449
|
|
return null; // 450
|
|
if (value.type === "Point") { // 451
|
|
return GeoJSON.pointDistance(point, value); // 452
|
|
} else { // 453
|
|
return GeoJSON.geometryWithinRadius(value, point, maxDistance) // 454
|
|
? 0 : maxDistance + 1; // 455
|
|
} // 456
|
|
}; // 457
|
|
} else { // 458
|
|
maxDistance = valueSelector.$maxDistance; // 459
|
|
if (!isArray(operand) && !isPlainObject(operand)) // 460
|
|
throw Error("$near argument must be coordinate pair or GeoJSON"); // 461
|
|
point = pointToArray(operand); // 462
|
|
distance = function (value) { // 463
|
|
if (!isArray(value) && !isPlainObject(value)) // 464
|
|
return null; // 465
|
|
return distanceCoordinatePairs(point, value); // 466
|
|
}; // 467
|
|
} // 468
|
|
// 469
|
|
return function (branchedValues) { // 470
|
|
// There might be multiple points in the document that match the given // 471
|
|
// field. Only one of them needs to be within $maxDistance, but we need to // 472
|
|
// evaluate all of them and use the nearest one for the implicit sort // 473
|
|
// specifier. (That's why we can't just use ELEMENT_OPERATORS here.) // 474
|
|
// // 475
|
|
// Note: This differs from MongoDB's implementation, where a document will // 476
|
|
// actually show up *multiple times* in the result set, with one entry for // 477
|
|
// each within-$maxDistance branching point. // 478
|
|
branchedValues = expandArraysInBranches(branchedValues); // 479
|
|
var result = {result: false}; // 480
|
|
_.each(branchedValues, function (branch) { // 481
|
|
var curDistance = distance(branch.value); // 482
|
|
// Skip branches that aren't real points or are too far away. // 483
|
|
if (curDistance === null || curDistance > maxDistance) // 484
|
|
return; // 485
|
|
// Skip anything that's a tie. // 486
|
|
if (result.distance !== undefined && result.distance <= curDistance) // 487
|
|
return; // 488
|
|
result.result = true; // 489
|
|
result.distance = curDistance; // 490
|
|
if (!branch.arrayIndices) // 491
|
|
delete result.arrayIndices; // 492
|
|
else // 493
|
|
result.arrayIndices = branch.arrayIndices; // 494
|
|
}); // 495
|
|
return result; // 496
|
|
}; // 497
|
|
} // 498
|
|
}; // 499
|
|
// 500
|
|
// Helpers for $near. // 501
|
|
var distanceCoordinatePairs = function (a, b) { // 502
|
|
a = pointToArray(a); // 503
|
|
b = pointToArray(b); // 504
|
|
var x = a[0] - b[0]; // 505
|
|
var y = a[1] - b[1]; // 506
|
|
if (_.isNaN(x) || _.isNaN(y)) // 507
|
|
return null; // 508
|
|
return Math.sqrt(x * x + y * y); // 509
|
|
}; // 510
|
|
// Makes sure we get 2 elements array and assume the first one to be x and // 511
|
|
// the second one to y no matter what user passes. // 512
|
|
// In case user passes { lon: x, lat: y } returns [x, y] // 513
|
|
var pointToArray = function (point) { // 514
|
|
return _.map(point, _.identity); // 515
|
|
}; // 516
|
|
// 517
|
|
// Helper for $lt/$gt/$lte/$gte. // 518
|
|
var makeInequality = function (cmpValueComparator) { // 519
|
|
return { // 520
|
|
compileElementSelector: function (operand) { // 521
|
|
// Arrays never compare false with non-arrays for any inequality. // 522
|
|
// XXX This was behavior we observed in pre-release MongoDB 2.5, but // 523
|
|
// it seems to have been reverted. // 524
|
|
// See https://jira.mongodb.org/browse/SERVER-11444 // 525
|
|
if (isArray(operand)) { // 526
|
|
return function () { // 527
|
|
return false; // 528
|
|
}; // 529
|
|
} // 530
|
|
// 531
|
|
// Special case: consider undefined and null the same (so true with // 532
|
|
// $gte/$lte). // 533
|
|
if (operand === undefined) // 534
|
|
operand = null; // 535
|
|
// 536
|
|
var operandType = LocalCollection._f._type(operand); // 537
|
|
// 538
|
|
return function (value) { // 539
|
|
if (value === undefined) // 540
|
|
value = null; // 541
|
|
// Comparisons are never true among things of different type (except // 542
|
|
// null vs undefined). // 543
|
|
if (LocalCollection._f._type(value) !== operandType) // 544
|
|
return false; // 545
|
|
return cmpValueComparator(LocalCollection._f._cmp(value, operand)); // 546
|
|
}; // 547
|
|
} // 548
|
|
}; // 549
|
|
}; // 550
|
|
// 551
|
|
// Each element selector contains: // 552
|
|
// - compileElementSelector, a function with args: // 553
|
|
// - operand - the "right hand side" of the operator // 554
|
|
// - valueSelector - the "context" for the operator (so that $regex can find // 555
|
|
// $options) // 556
|
|
// - matcher - the Matcher this is going into (so that $elemMatch can compile // 557
|
|
// more things) // 558
|
|
// returning a function mapping a single value to bool. // 559
|
|
// - dontExpandLeafArrays, a bool which prevents expandArraysInBranches from // 560
|
|
// being called // 561
|
|
// - dontIncludeLeafArrays, a bool which causes an argument to be passed to // 562
|
|
// expandArraysInBranches if it is called // 563
|
|
ELEMENT_OPERATORS = { // 564
|
|
$lt: makeInequality(function (cmpValue) { // 565
|
|
return cmpValue < 0; // 566
|
|
}), // 567
|
|
$gt: makeInequality(function (cmpValue) { // 568
|
|
return cmpValue > 0; // 569
|
|
}), // 570
|
|
$lte: makeInequality(function (cmpValue) { // 571
|
|
return cmpValue <= 0; // 572
|
|
}), // 573
|
|
$gte: makeInequality(function (cmpValue) { // 574
|
|
return cmpValue >= 0; // 575
|
|
}), // 576
|
|
$mod: { // 577
|
|
compileElementSelector: function (operand) { // 578
|
|
if (!(isArray(operand) && operand.length === 2 // 579
|
|
&& typeof(operand[0]) === 'number' // 580
|
|
&& typeof(operand[1]) === 'number')) { // 581
|
|
throw Error("argument to $mod must be an array of two numbers"); // 582
|
|
} // 583
|
|
// XXX could require to be ints or round or something // 584
|
|
var divisor = operand[0]; // 585
|
|
var remainder = operand[1]; // 586
|
|
return function (value) { // 587
|
|
return typeof value === 'number' && value % divisor === remainder; // 588
|
|
}; // 589
|
|
} // 590
|
|
}, // 591
|
|
$in: { // 592
|
|
compileElementSelector: function (operand) { // 593
|
|
if (!isArray(operand)) // 594
|
|
throw Error("$in needs an array"); // 595
|
|
// 596
|
|
var elementMatchers = []; // 597
|
|
_.each(operand, function (option) { // 598
|
|
if (option instanceof RegExp) // 599
|
|
elementMatchers.push(regexpElementMatcher(option)); // 600
|
|
else if (isOperatorObject(option)) // 601
|
|
throw Error("cannot nest $ under $in"); // 602
|
|
else // 603
|
|
elementMatchers.push(equalityElementMatcher(option)); // 604
|
|
}); // 605
|
|
// 606
|
|
return function (value) { // 607
|
|
// Allow {a: {$in: [null]}} to match when 'a' does not exist. // 608
|
|
if (value === undefined) // 609
|
|
value = null; // 610
|
|
return _.any(elementMatchers, function (e) { // 611
|
|
return e(value); // 612
|
|
}); // 613
|
|
}; // 614
|
|
} // 615
|
|
}, // 616
|
|
$size: { // 617
|
|
// {a: [[5, 5]]} must match {a: {$size: 1}} but not {a: {$size: 2}}, so we // 618
|
|
// don't want to consider the element [5,5] in the leaf array [[5,5]] as a // 619
|
|
// possible value. // 620
|
|
dontExpandLeafArrays: true, // 621
|
|
compileElementSelector: function (operand) { // 622
|
|
if (typeof operand === 'string') { // 623
|
|
// Don't ask me why, but by experimentation, this seems to be what Mongo // 624
|
|
// does. // 625
|
|
operand = 0; // 626
|
|
} else if (typeof operand !== 'number') { // 627
|
|
throw Error("$size needs a number"); // 628
|
|
} // 629
|
|
return function (value) { // 630
|
|
return isArray(value) && value.length === operand; // 631
|
|
}; // 632
|
|
} // 633
|
|
}, // 634
|
|
$type: { // 635
|
|
// {a: [5]} must not match {a: {$type: 4}} (4 means array), but it should // 636
|
|
// match {a: {$type: 1}} (1 means number), and {a: [[5]]} must match {$a: // 637
|
|
// {$type: 4}}. Thus, when we see a leaf array, we *should* expand it but // 638
|
|
// should *not* include it itself. // 639
|
|
dontIncludeLeafArrays: true, // 640
|
|
compileElementSelector: function (operand) { // 641
|
|
if (typeof operand !== 'number') // 642
|
|
throw Error("$type needs a number"); // 643
|
|
return function (value) { // 644
|
|
return value !== undefined // 645
|
|
&& LocalCollection._f._type(value) === operand; // 646
|
|
}; // 647
|
|
} // 648
|
|
}, // 649
|
|
$regex: { // 650
|
|
compileElementSelector: function (operand, valueSelector) { // 651
|
|
if (!(typeof operand === 'string' || operand instanceof RegExp)) // 652
|
|
throw Error("$regex has to be a string or RegExp"); // 653
|
|
// 654
|
|
var regexp; // 655
|
|
if (valueSelector.$options !== undefined) { // 656
|
|
// Options passed in $options (even the empty string) always overrides // 657
|
|
// options in the RegExp object itself. (See also // 658
|
|
// Mongo.Collection._rewriteSelector.) // 659
|
|
// 660
|
|
// Be clear that we only support the JS-supported options, not extended // 661
|
|
// ones (eg, Mongo supports x and s). Ideally we would implement x and s // 662
|
|
// by transforming the regexp, but not today... // 663
|
|
if (/[^gim]/.test(valueSelector.$options)) // 664
|
|
throw new Error("Only the i, m, and g regexp options are supported"); // 665
|
|
// 666
|
|
var regexSource = operand instanceof RegExp ? operand.source : operand; // 667
|
|
regexp = new RegExp(regexSource, valueSelector.$options); // 668
|
|
} else if (operand instanceof RegExp) { // 669
|
|
regexp = operand; // 670
|
|
} else { // 671
|
|
regexp = new RegExp(operand); // 672
|
|
} // 673
|
|
return regexpElementMatcher(regexp); // 674
|
|
} // 675
|
|
}, // 676
|
|
$elemMatch: { // 677
|
|
dontExpandLeafArrays: true, // 678
|
|
compileElementSelector: function (operand, valueSelector, matcher) { // 679
|
|
if (!isPlainObject(operand)) // 680
|
|
throw Error("$elemMatch need an object"); // 681
|
|
// 682
|
|
var subMatcher, isDocMatcher; // 683
|
|
if (isOperatorObject(operand, true)) { // 684
|
|
subMatcher = compileValueSelector(operand, matcher); // 685
|
|
isDocMatcher = false; // 686
|
|
} else { // 687
|
|
// This is NOT the same as compileValueSelector(operand), and not just // 688
|
|
// because of the slightly different calling convention. // 689
|
|
// {$elemMatch: {x: 3}} means "an element has a field x:3", not // 690
|
|
// "consists only of a field x:3". Also, regexps and sub-$ are allowed. // 691
|
|
subMatcher = compileDocumentSelector(operand, matcher, // 692
|
|
{inElemMatch: true}); // 693
|
|
isDocMatcher = true; // 694
|
|
} // 695
|
|
// 696
|
|
return function (value) { // 697
|
|
if (!isArray(value)) // 698
|
|
return false; // 699
|
|
for (var i = 0; i < value.length; ++i) { // 700
|
|
var arrayElement = value[i]; // 701
|
|
var arg; // 702
|
|
if (isDocMatcher) { // 703
|
|
// We can only match {$elemMatch: {b: 3}} against objects. // 704
|
|
// (We can also match against arrays, if there's numeric indices, // 705
|
|
// eg {$elemMatch: {'0.b': 3}} or {$elemMatch: {0: 3}}.) // 706
|
|
if (!isPlainObject(arrayElement) && !isArray(arrayElement)) // 707
|
|
return false; // 708
|
|
arg = arrayElement; // 709
|
|
} else { // 710
|
|
// dontIterate ensures that {a: {$elemMatch: {$gt: 5}}} matches // 711
|
|
// {a: [8]} but not {a: [[8]]} // 712
|
|
arg = [{value: arrayElement, dontIterate: true}]; // 713
|
|
} // 714
|
|
// XXX support $near in $elemMatch by propagating $distance? // 715
|
|
if (subMatcher(arg).result) // 716
|
|
return i; // specially understood to mean "use as arrayIndices" // 717
|
|
} // 718
|
|
return false; // 719
|
|
}; // 720
|
|
} // 721
|
|
} // 722
|
|
}; // 723
|
|
// 724
|
|
// makeLookupFunction(key) returns a lookup function. // 725
|
|
// // 726
|
|
// A lookup function takes in a document and returns an array of matching // 727
|
|
// branches. If no arrays are found while looking up the key, this array will // 728
|
|
// have exactly one branches (possibly 'undefined', if some segment of the key // 729
|
|
// was not found). // 730
|
|
// // 731
|
|
// If arrays are found in the middle, this can have more than one element, since // 732
|
|
// we "branch". When we "branch", if there are more key segments to look up, // 733
|
|
// then we only pursue branches that are plain objects (not arrays or scalars). // 734
|
|
// This means we can actually end up with no branches! // 735
|
|
// // 736
|
|
// We do *NOT* branch on arrays that are found at the end (ie, at the last // 737
|
|
// dotted member of the key). We just return that array; if you want to // 738
|
|
// effectively "branch" over the array's values, post-process the lookup // 739
|
|
// function with expandArraysInBranches. // 740
|
|
// // 741
|
|
// Each branch is an object with keys: // 742
|
|
// - value: the value at the branch // 743
|
|
// - dontIterate: an optional bool; if true, it means that 'value' is an array // 744
|
|
// that expandArraysInBranches should NOT expand. This specifically happens // 745
|
|
// when there is a numeric index in the key, and ensures the // 746
|
|
// perhaps-surprising MongoDB behavior where {'a.0': 5} does NOT // 747
|
|
// match {a: [[5]]}. // 748
|
|
// - arrayIndices: if any array indexing was done during lookup (either due to // 749
|
|
// explicit numeric indices or implicit branching), this will be an array of // 750
|
|
// the array indices used, from outermost to innermost; it is falsey or // 751
|
|
// absent if no array index is used. If an explicit numeric index is used, // 752
|
|
// the index will be followed in arrayIndices by the string 'x'. // 753
|
|
// // 754
|
|
// Note: arrayIndices is used for two purposes. First, it is used to // 755
|
|
// implement the '$' modifier feature, which only ever looks at its first // 756
|
|
// element. // 757
|
|
// // 758
|
|
// Second, it is used for sort key generation, which needs to be able to tell // 759
|
|
// the difference between different paths. Moreover, it needs to // 760
|
|
// differentiate between explicit and implicit branching, which is why // 761
|
|
// there's the somewhat hacky 'x' entry: this means that explicit and // 762
|
|
// implicit array lookups will have different full arrayIndices paths. (That // 763
|
|
// code only requires that different paths have different arrayIndices; it // 764
|
|
// doesn't actually "parse" arrayIndices. As an alternative, arrayIndices // 765
|
|
// could contain objects with flags like "implicit", but I think that only // 766
|
|
// makes the code surrounding them more complex.) // 767
|
|
// // 768
|
|
// (By the way, this field ends up getting passed around a lot without // 769
|
|
// cloning, so never mutate any arrayIndices field/var in this package!) // 770
|
|
// // 771
|
|
// // 772
|
|
// At the top level, you may only pass in a plain object or array. // 773
|
|
// // 774
|
|
// See the test 'minimongo - lookup' for some examples of what lookup functions // 775
|
|
// return. // 776
|
|
makeLookupFunction = function (key, options) { // 777
|
|
options = options || {}; // 778
|
|
var parts = key.split('.'); // 779
|
|
var firstPart = parts.length ? parts[0] : ''; // 780
|
|
var firstPartIsNumeric = isNumericKey(firstPart); // 781
|
|
var nextPartIsNumeric = parts.length >= 2 && isNumericKey(parts[1]); // 782
|
|
var lookupRest; // 783
|
|
if (parts.length > 1) { // 784
|
|
lookupRest = makeLookupFunction(parts.slice(1).join('.')); // 785
|
|
} // 786
|
|
// 787
|
|
var omitUnnecessaryFields = function (retVal) { // 788
|
|
if (!retVal.dontIterate) // 789
|
|
delete retVal.dontIterate; // 790
|
|
if (retVal.arrayIndices && !retVal.arrayIndices.length) // 791
|
|
delete retVal.arrayIndices; // 792
|
|
return retVal; // 793
|
|
}; // 794
|
|
// 795
|
|
// Doc will always be a plain object or an array. // 796
|
|
// apply an explicit numeric index, an array. // 797
|
|
return function (doc, arrayIndices) { // 798
|
|
if (!arrayIndices) // 799
|
|
arrayIndices = []; // 800
|
|
// 801
|
|
if (isArray(doc)) { // 802
|
|
// If we're being asked to do an invalid lookup into an array (non-integer // 803
|
|
// or out-of-bounds), return no results (which is different from returning // 804
|
|
// a single undefined result, in that `null` equality checks won't match). // 805
|
|
if (!(firstPartIsNumeric && firstPart < doc.length)) // 806
|
|
return []; // 807
|
|
// 808
|
|
// Remember that we used this array index. Include an 'x' to indicate that // 809
|
|
// the previous index came from being considered as an explicit array // 810
|
|
// index (not branching). // 811
|
|
arrayIndices = arrayIndices.concat(+firstPart, 'x'); // 812
|
|
} // 813
|
|
// 814
|
|
// Do our first lookup. // 815
|
|
var firstLevel = doc[firstPart]; // 816
|
|
// 817
|
|
// If there is no deeper to dig, return what we found. // 818
|
|
// // 819
|
|
// If what we found is an array, most value selectors will choose to treat // 820
|
|
// the elements of the array as matchable values in their own right, but // 821
|
|
// that's done outside of the lookup function. (Exceptions to this are $size // 822
|
|
// and stuff relating to $elemMatch. eg, {a: {$size: 2}} does not match {a: // 823
|
|
// [[1, 2]]}.) // 824
|
|
// // 825
|
|
// That said, if we just did an *explicit* array lookup (on doc) to find // 826
|
|
// firstLevel, and firstLevel is an array too, we do NOT want value // 827
|
|
// selectors to iterate over it. eg, {'a.0': 5} does not match {a: [[5]]}. // 828
|
|
// So in that case, we mark the return value as "don't iterate". // 829
|
|
if (!lookupRest) { // 830
|
|
return [omitUnnecessaryFields({ // 831
|
|
value: firstLevel, // 832
|
|
dontIterate: isArray(doc) && isArray(firstLevel), // 833
|
|
arrayIndices: arrayIndices})]; // 834
|
|
} // 835
|
|
// 836
|
|
// We need to dig deeper. But if we can't, because what we've found is not // 837
|
|
// an array or plain object, we're done. If we just did a numeric index into // 838
|
|
// an array, we return nothing here (this is a change in Mongo 2.5 from // 839
|
|
// Mongo 2.4, where {'a.0.b': null} stopped matching {a: [5]}). Otherwise, // 840
|
|
// return a single `undefined` (which can, for example, match via equality // 841
|
|
// with `null`). // 842
|
|
if (!isIndexable(firstLevel)) { // 843
|
|
if (isArray(doc)) // 844
|
|
return []; // 845
|
|
return [omitUnnecessaryFields({value: undefined, // 846
|
|
arrayIndices: arrayIndices})]; // 847
|
|
} // 848
|
|
// 849
|
|
var result = []; // 850
|
|
var appendToResult = function (more) { // 851
|
|
Array.prototype.push.apply(result, more); // 852
|
|
}; // 853
|
|
// 854
|
|
// Dig deeper: look up the rest of the parts on whatever we've found. // 855
|
|
// (lookupRest is smart enough to not try to do invalid lookups into // 856
|
|
// firstLevel if it's an array.) // 857
|
|
appendToResult(lookupRest(firstLevel, arrayIndices)); // 858
|
|
// 859
|
|
// If we found an array, then in *addition* to potentially treating the next // 860
|
|
// part as a literal integer lookup, we should also "branch": try to look up // 861
|
|
// the rest of the parts on each array element in parallel. // 862
|
|
// // 863
|
|
// In this case, we *only* dig deeper into array elements that are plain // 864
|
|
// objects. (Recall that we only got this far if we have further to dig.) // 865
|
|
// This makes sense: we certainly don't dig deeper into non-indexable // 866
|
|
// objects. And it would be weird to dig into an array: it's simpler to have // 867
|
|
// a rule that explicit integer indexes only apply to an outer array, not to // 868
|
|
// an array you find after a branching search. // 869
|
|
// // 870
|
|
// In the special case of a numeric part in a *sort selector* (not a query // 871
|
|
// selector), we skip the branching: we ONLY allow the numeric part to mean // 872
|
|
// "look up this index" in that case, not "also look up this index in all // 873
|
|
// the elements of the array". // 874
|
|
if (isArray(firstLevel) && !(nextPartIsNumeric && options.forSort)) { // 875
|
|
_.each(firstLevel, function (branch, arrayIndex) { // 876
|
|
if (isPlainObject(branch)) { // 877
|
|
appendToResult(lookupRest( // 878
|
|
branch, // 879
|
|
arrayIndices.concat(arrayIndex))); // 880
|
|
} // 881
|
|
}); // 882
|
|
} // 883
|
|
// 884
|
|
return result; // 885
|
|
}; // 886
|
|
}; // 887
|
|
MinimongoTest.makeLookupFunction = makeLookupFunction; // 888
|
|
// 889
|
|
expandArraysInBranches = function (branches, skipTheArrays) { // 890
|
|
var branchesOut = []; // 891
|
|
_.each(branches, function (branch) { // 892
|
|
var thisIsArray = isArray(branch.value); // 893
|
|
// We include the branch itself, *UNLESS* we it's an array that we're going // 894
|
|
// to iterate and we're told to skip arrays. (That's right, we include some // 895
|
|
// arrays even skipTheArrays is true: these are arrays that were found via // 896
|
|
// explicit numerical indices.) // 897
|
|
if (!(skipTheArrays && thisIsArray && !branch.dontIterate)) { // 898
|
|
branchesOut.push({ // 899
|
|
value: branch.value, // 900
|
|
arrayIndices: branch.arrayIndices // 901
|
|
}); // 902
|
|
} // 903
|
|
if (thisIsArray && !branch.dontIterate) { // 904
|
|
_.each(branch.value, function (leaf, i) { // 905
|
|
branchesOut.push({ // 906
|
|
value: leaf, // 907
|
|
arrayIndices: (branch.arrayIndices || []).concat(i) // 908
|
|
}); // 909
|
|
}); // 910
|
|
} // 911
|
|
}); // 912
|
|
return branchesOut; // 913
|
|
}; // 914
|
|
// 915
|
|
var nothingMatcher = function (docOrBranchedValues) { // 916
|
|
return {result: false}; // 917
|
|
}; // 918
|
|
// 919
|
|
var everythingMatcher = function (docOrBranchedValues) { // 920
|
|
return {result: true}; // 921
|
|
}; // 922
|
|
// 923
|
|
// 924
|
|
// NB: We are cheating and using this function to implement "AND" for both // 925
|
|
// "document matchers" and "branched matchers". They both return result objects // 926
|
|
// but the argument is different: for the former it's a whole doc, whereas for // 927
|
|
// the latter it's an array of "branched values". // 928
|
|
var andSomeMatchers = function (subMatchers) { // 929
|
|
if (subMatchers.length === 0) // 930
|
|
return everythingMatcher; // 931
|
|
if (subMatchers.length === 1) // 932
|
|
return subMatchers[0]; // 933
|
|
// 934
|
|
return function (docOrBranches) { // 935
|
|
var ret = {}; // 936
|
|
ret.result = _.all(subMatchers, function (f) { // 937
|
|
var subResult = f(docOrBranches); // 938
|
|
// Copy a 'distance' number out of the first sub-matcher that has // 939
|
|
// one. Yes, this means that if there are multiple $near fields in a // 940
|
|
// query, something arbitrary happens; this appears to be consistent with // 941
|
|
// Mongo. // 942
|
|
if (subResult.result && subResult.distance !== undefined // 943
|
|
&& ret.distance === undefined) { // 944
|
|
ret.distance = subResult.distance; // 945
|
|
} // 946
|
|
// Similarly, propagate arrayIndices from sub-matchers... but to match // 947
|
|
// MongoDB behavior, this time the *last* sub-matcher with arrayIndices // 948
|
|
// wins. // 949
|
|
if (subResult.result && subResult.arrayIndices) { // 950
|
|
ret.arrayIndices = subResult.arrayIndices; // 951
|
|
} // 952
|
|
return subResult.result; // 953
|
|
}); // 954
|
|
// 955
|
|
// If we didn't actually match, forget any extra metadata we came up with. // 956
|
|
if (!ret.result) { // 957
|
|
delete ret.distance; // 958
|
|
delete ret.arrayIndices; // 959
|
|
} // 960
|
|
return ret; // 961
|
|
}; // 962
|
|
}; // 963
|
|
// 964
|
|
var andDocumentMatchers = andSomeMatchers; // 965
|
|
var andBranchedMatchers = andSomeMatchers; // 966
|
|
// 967
|
|
// 968
|
|
// helpers used by compiled selector code // 969
|
|
LocalCollection._f = { // 970
|
|
// XXX for _all and _in, consider building 'inquery' at compile time.. // 971
|
|
// 972
|
|
_type: function (v) { // 973
|
|
if (typeof v === "number") // 974
|
|
return 1; // 975
|
|
if (typeof v === "string") // 976
|
|
return 2; // 977
|
|
if (typeof v === "boolean") // 978
|
|
return 8; // 979
|
|
if (isArray(v)) // 980
|
|
return 4; // 981
|
|
if (v === null) // 982
|
|
return 10; // 983
|
|
if (v instanceof RegExp) // 984
|
|
// note that typeof(/x/) === "object" // 985
|
|
return 11; // 986
|
|
if (typeof v === "function") // 987
|
|
return 13; // 988
|
|
if (v instanceof Date) // 989
|
|
return 9; // 990
|
|
if (EJSON.isBinary(v)) // 991
|
|
return 5; // 992
|
|
if (v instanceof LocalCollection._ObjectID) // 993
|
|
return 7; // 994
|
|
return 3; // object // 995
|
|
// 996
|
|
// XXX support some/all of these: // 997
|
|
// 14, symbol // 998
|
|
// 15, javascript code with scope // 999
|
|
// 16, 18: 32-bit/64-bit integer // 1000
|
|
// 17, timestamp // 1001
|
|
// 255, minkey // 1002
|
|
// 127, maxkey // 1003
|
|
}, // 1004
|
|
// 1005
|
|
// deep equality test: use for literal document and array matches // 1006
|
|
_equal: function (a, b) { // 1007
|
|
return EJSON.equals(a, b, {keyOrderSensitive: true}); // 1008
|
|
}, // 1009
|
|
// 1010
|
|
// maps a type code to a value that can be used to sort values of // 1011
|
|
// different types // 1012
|
|
_typeorder: function (t) { // 1013
|
|
// http://www.mongodb.org/display/DOCS/What+is+the+Compare+Order+for+BSON+Types // 1014
|
|
// XXX what is the correct sort position for Javascript code? // 1015
|
|
// ('100' in the matrix below) // 1016
|
|
// XXX minkey/maxkey // 1017
|
|
return [-1, // (not a type) // 1018
|
|
1, // number // 1019
|
|
2, // string // 1020
|
|
3, // object // 1021
|
|
4, // array // 1022
|
|
5, // binary // 1023
|
|
-1, // deprecated // 1024
|
|
6, // ObjectID // 1025
|
|
7, // bool // 1026
|
|
8, // Date // 1027
|
|
0, // null // 1028
|
|
9, // RegExp // 1029
|
|
-1, // deprecated // 1030
|
|
100, // JS code // 1031
|
|
2, // deprecated (symbol) // 1032
|
|
100, // JS code // 1033
|
|
1, // 32-bit int // 1034
|
|
8, // Mongo timestamp // 1035
|
|
1 // 64-bit int // 1036
|
|
][t]; // 1037
|
|
}, // 1038
|
|
// 1039
|
|
// compare two values of unknown type according to BSON ordering // 1040
|
|
// semantics. (as an extension, consider 'undefined' to be less than // 1041
|
|
// any other value.) return negative if a is less, positive if b is // 1042
|
|
// less, or 0 if equal // 1043
|
|
_cmp: function (a, b) { // 1044
|
|
if (a === undefined) // 1045
|
|
return b === undefined ? 0 : -1; // 1046
|
|
if (b === undefined) // 1047
|
|
return 1; // 1048
|
|
var ta = LocalCollection._f._type(a); // 1049
|
|
var tb = LocalCollection._f._type(b); // 1050
|
|
var oa = LocalCollection._f._typeorder(ta); // 1051
|
|
var ob = LocalCollection._f._typeorder(tb); // 1052
|
|
if (oa !== ob) // 1053
|
|
return oa < ob ? -1 : 1; // 1054
|
|
if (ta !== tb) // 1055
|
|
// XXX need to implement this if we implement Symbol or integers, or // 1056
|
|
// Timestamp // 1057
|
|
throw Error("Missing type coercion logic in _cmp"); // 1058
|
|
if (ta === 7) { // ObjectID // 1059
|
|
// Convert to string. // 1060
|
|
ta = tb = 2; // 1061
|
|
a = a.toHexString(); // 1062
|
|
b = b.toHexString(); // 1063
|
|
} // 1064
|
|
if (ta === 9) { // Date // 1065
|
|
// Convert to millis. // 1066
|
|
ta = tb = 1; // 1067
|
|
a = a.getTime(); // 1068
|
|
b = b.getTime(); // 1069
|
|
} // 1070
|
|
// 1071
|
|
if (ta === 1) // double // 1072
|
|
return a - b; // 1073
|
|
if (tb === 2) // string // 1074
|
|
return a < b ? -1 : (a === b ? 0 : 1); // 1075
|
|
if (ta === 3) { // Object // 1076
|
|
// this could be much more efficient in the expected case ... // 1077
|
|
var to_array = function (obj) { // 1078
|
|
var ret = []; // 1079
|
|
for (var key in obj) { // 1080
|
|
ret.push(key); // 1081
|
|
ret.push(obj[key]); // 1082
|
|
} // 1083
|
|
return ret; // 1084
|
|
}; // 1085
|
|
return LocalCollection._f._cmp(to_array(a), to_array(b)); // 1086
|
|
} // 1087
|
|
if (ta === 4) { // Array // 1088
|
|
for (var i = 0; ; i++) { // 1089
|
|
if (i === a.length) // 1090
|
|
return (i === b.length) ? 0 : -1; // 1091
|
|
if (i === b.length) // 1092
|
|
return 1; // 1093
|
|
var s = LocalCollection._f._cmp(a[i], b[i]); // 1094
|
|
if (s !== 0) // 1095
|
|
return s; // 1096
|
|
} // 1097
|
|
} // 1098
|
|
if (ta === 5) { // binary // 1099
|
|
// Surprisingly, a small binary blob is always less than a large one in // 1100
|
|
// Mongo. // 1101
|
|
if (a.length !== b.length) // 1102
|
|
return a.length - b.length; // 1103
|
|
for (i = 0; i < a.length; i++) { // 1104
|
|
if (a[i] < b[i]) // 1105
|
|
return -1; // 1106
|
|
if (a[i] > b[i]) // 1107
|
|
return 1; // 1108
|
|
} // 1109
|
|
return 0; // 1110
|
|
} // 1111
|
|
if (ta === 8) { // boolean // 1112
|
|
if (a) return b ? 0 : 1; // 1113
|
|
return b ? -1 : 0; // 1114
|
|
} // 1115
|
|
if (ta === 10) // null // 1116
|
|
return 0; // 1117
|
|
if (ta === 11) // regexp // 1118
|
|
throw Error("Sorting not supported on regular expression"); // XXX // 1119
|
|
// 13: javascript code // 1120
|
|
// 14: symbol // 1121
|
|
// 15: javascript code with scope // 1122
|
|
// 16: 32-bit integer // 1123
|
|
// 17: timestamp // 1124
|
|
// 18: 64-bit integer // 1125
|
|
// 255: minkey // 1126
|
|
// 127: maxkey // 1127
|
|
if (ta === 13) // javascript code // 1128
|
|
throw Error("Sorting not supported on Javascript code"); // XXX // 1129
|
|
throw Error("Unknown type to sort"); // 1130
|
|
} // 1131
|
|
}; // 1132
|
|
// 1133
|
|
// Oddball function used by upsert. // 1134
|
|
LocalCollection._removeDollarOperators = function (selector) { // 1135
|
|
var selectorDoc = {}; // 1136
|
|
for (var k in selector) // 1137
|
|
if (k.substr(0, 1) !== '$') // 1138
|
|
selectorDoc[k] = selector[k]; // 1139
|
|
return selectorDoc; // 1140
|
|
}; // 1141
|
|
// 1142
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/sort.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Give a sort spec, which can be in any of these forms: // 1
|
|
// {"key1": 1, "key2": -1} // 2
|
|
// [["key1", "asc"], ["key2", "desc"]] // 3
|
|
// ["key1", ["key2", "desc"]] // 4
|
|
// // 5
|
|
// (.. with the first form being dependent on the key enumeration // 6
|
|
// behavior of your javascript VM, which usually does what you mean in // 7
|
|
// this case if the key names don't look like integers ..) // 8
|
|
// // 9
|
|
// return a function that takes two objects, and returns -1 if the // 10
|
|
// first object comes first in order, 1 if the second object comes // 11
|
|
// first, or 0 if neither object comes before the other. // 12
|
|
// 13
|
|
Minimongo.Sorter = function (spec, options) { // 14
|
|
var self = this; // 15
|
|
options = options || {}; // 16
|
|
// 17
|
|
self._sortSpecParts = []; // 18
|
|
// 19
|
|
var addSpecPart = function (path, ascending) { // 20
|
|
if (!path) // 21
|
|
throw Error("sort keys must be non-empty"); // 22
|
|
if (path.charAt(0) === '$') // 23
|
|
throw Error("unsupported sort key: " + path); // 24
|
|
self._sortSpecParts.push({ // 25
|
|
path: path, // 26
|
|
lookup: makeLookupFunction(path, {forSort: true}), // 27
|
|
ascending: ascending // 28
|
|
}); // 29
|
|
}; // 30
|
|
// 31
|
|
if (spec instanceof Array) { // 32
|
|
for (var i = 0; i < spec.length; i++) { // 33
|
|
if (typeof spec[i] === "string") { // 34
|
|
addSpecPart(spec[i], true); // 35
|
|
} else { // 36
|
|
addSpecPart(spec[i][0], spec[i][1] !== "desc"); // 37
|
|
} // 38
|
|
} // 39
|
|
} else if (typeof spec === "object") { // 40
|
|
_.each(spec, function (value, key) { // 41
|
|
addSpecPart(key, value >= 0); // 42
|
|
}); // 43
|
|
} else { // 44
|
|
throw Error("Bad sort specification: " + JSON.stringify(spec)); // 45
|
|
} // 46
|
|
// 47
|
|
// To implement affectedByModifier, we piggy-back on top of Matcher's // 48
|
|
// affectedByModifier code; we create a selector that is affected by the same // 49
|
|
// modifiers as this sort order. This is only implemented on the server. // 50
|
|
if (self.affectedByModifier) { // 51
|
|
var selector = {}; // 52
|
|
_.each(self._sortSpecParts, function (spec) { // 53
|
|
selector[spec.path] = 1; // 54
|
|
}); // 55
|
|
self._selectorForAffectedByModifier = new Minimongo.Matcher(selector); // 56
|
|
} // 57
|
|
// 58
|
|
self._keyComparator = composeComparators( // 59
|
|
_.map(self._sortSpecParts, function (spec, i) { // 60
|
|
return self._keyFieldComparator(i); // 61
|
|
})); // 62
|
|
// 63
|
|
// If you specify a matcher for this Sorter, _keyFilter may be set to a // 64
|
|
// function which selects whether or not a given "sort key" (tuple of values // 65
|
|
// for the different sort spec fields) is compatible with the selector. // 66
|
|
self._keyFilter = null; // 67
|
|
options.matcher && self._useWithMatcher(options.matcher); // 68
|
|
}; // 69
|
|
// 70
|
|
// In addition to these methods, sorter_project.js defines combineIntoProjection // 71
|
|
// on the server only. // 72
|
|
_.extend(Minimongo.Sorter.prototype, { // 73
|
|
getComparator: function (options) { // 74
|
|
var self = this; // 75
|
|
// 76
|
|
// If we have no distances, just use the comparator from the source // 77
|
|
// specification (which defaults to "everything is equal". // 78
|
|
if (!options || !options.distances) { // 79
|
|
return self._getBaseComparator(); // 80
|
|
} // 81
|
|
// 82
|
|
var distances = options.distances; // 83
|
|
// 84
|
|
// Return a comparator which first tries the sort specification, and if that // 85
|
|
// says "it's equal", breaks ties using $near distances. // 86
|
|
return composeComparators([self._getBaseComparator(), function (a, b) { // 87
|
|
if (!distances.has(a._id)) // 88
|
|
throw Error("Missing distance for " + a._id); // 89
|
|
if (!distances.has(b._id)) // 90
|
|
throw Error("Missing distance for " + b._id); // 91
|
|
return distances.get(a._id) - distances.get(b._id); // 92
|
|
}]); // 93
|
|
}, // 94
|
|
// 95
|
|
_getPaths: function () { // 96
|
|
var self = this; // 97
|
|
return _.pluck(self._sortSpecParts, 'path'); // 98
|
|
}, // 99
|
|
// 100
|
|
// Finds the minimum key from the doc, according to the sort specs. (We say // 101
|
|
// "minimum" here but this is with respect to the sort spec, so "descending" // 102
|
|
// sort fields mean we're finding the max for that field.) // 103
|
|
// // 104
|
|
// Note that this is NOT "find the minimum value of the first field, the // 105
|
|
// minimum value of the second field, etc"... it's "choose the // 106
|
|
// lexicographically minimum value of the key vector, allowing only keys which // 107
|
|
// you can find along the same paths". ie, for a doc {a: [{x: 0, y: 5}, {x: // 108
|
|
// 1, y: 3}]} with sort spec {'a.x': 1, 'a.y': 1}, the only keys are [0,5] and // 109
|
|
// [1,3], and the minimum key is [0,5]; notably, [0,3] is NOT a key. // 110
|
|
_getMinKeyFromDoc: function (doc) { // 111
|
|
var self = this; // 112
|
|
var minKey = null; // 113
|
|
// 114
|
|
self._generateKeysFromDoc(doc, function (key) { // 115
|
|
if (!self._keyCompatibleWithSelector(key)) // 116
|
|
return; // 117
|
|
// 118
|
|
if (minKey === null) { // 119
|
|
minKey = key; // 120
|
|
return; // 121
|
|
} // 122
|
|
if (self._compareKeys(key, minKey) < 0) { // 123
|
|
minKey = key; // 124
|
|
} // 125
|
|
}); // 126
|
|
// 127
|
|
// This could happen if our key filter somehow filters out all the keys even // 128
|
|
// though somehow the selector matches. // 129
|
|
if (minKey === null) // 130
|
|
throw Error("sort selector found no keys in doc?"); // 131
|
|
return minKey; // 132
|
|
}, // 133
|
|
// 134
|
|
_keyCompatibleWithSelector: function (key) { // 135
|
|
var self = this; // 136
|
|
return !self._keyFilter || self._keyFilter(key); // 137
|
|
}, // 138
|
|
// 139
|
|
// Iterates over each possible "key" from doc (ie, over each branch), calling // 140
|
|
// 'cb' with the key. // 141
|
|
_generateKeysFromDoc: function (doc, cb) { // 142
|
|
var self = this; // 143
|
|
// 144
|
|
if (self._sortSpecParts.length === 0) // 145
|
|
throw new Error("can't generate keys without a spec"); // 146
|
|
// 147
|
|
// maps index -> ({'' -> value} or {path -> value}) // 148
|
|
var valuesByIndexAndPath = []; // 149
|
|
// 150
|
|
var pathFromIndices = function (indices) { // 151
|
|
return indices.join(',') + ','; // 152
|
|
}; // 153
|
|
// 154
|
|
var knownPaths = null; // 155
|
|
// 156
|
|
_.each(self._sortSpecParts, function (spec, whichField) { // 157
|
|
// Expand any leaf arrays that we find, and ignore those arrays // 158
|
|
// themselves. (We never sort based on an array itself.) // 159
|
|
var branches = expandArraysInBranches(spec.lookup(doc), true); // 160
|
|
// 161
|
|
// If there are no values for a key (eg, key goes to an empty array), // 162
|
|
// pretend we found one null value. // 163
|
|
if (!branches.length) // 164
|
|
branches = [{value: null}]; // 165
|
|
// 166
|
|
var usedPaths = false; // 167
|
|
valuesByIndexAndPath[whichField] = {}; // 168
|
|
_.each(branches, function (branch) { // 169
|
|
if (!branch.arrayIndices) { // 170
|
|
// If there are no array indices for a branch, then it must be the // 171
|
|
// only branch, because the only thing that produces multiple branches // 172
|
|
// is the use of arrays. // 173
|
|
if (branches.length > 1) // 174
|
|
throw Error("multiple branches but no array used?"); // 175
|
|
valuesByIndexAndPath[whichField][''] = branch.value; // 176
|
|
return; // 177
|
|
} // 178
|
|
// 179
|
|
usedPaths = true; // 180
|
|
var path = pathFromIndices(branch.arrayIndices); // 181
|
|
if (_.has(valuesByIndexAndPath[whichField], path)) // 182
|
|
throw Error("duplicate path: " + path); // 183
|
|
valuesByIndexAndPath[whichField][path] = branch.value; // 184
|
|
// 185
|
|
// If two sort fields both go into arrays, they have to go into the // 186
|
|
// exact same arrays and we have to find the same paths. This is // 187
|
|
// roughly the same condition that makes MongoDB throw this strange // 188
|
|
// error message. eg, the main thing is that if sort spec is {a: 1, // 189
|
|
// b:1} then a and b cannot both be arrays. // 190
|
|
// // 191
|
|
// (In MongoDB it seems to be OK to have {a: 1, 'a.x.y': 1} where 'a' // 192
|
|
// and 'a.x.y' are both arrays, but we don't allow this for now. // 193
|
|
// #NestedArraySort // 194
|
|
// XXX achieve full compatibility here // 195
|
|
if (knownPaths && !_.has(knownPaths, path)) { // 196
|
|
throw Error("cannot index parallel arrays"); // 197
|
|
} // 198
|
|
}); // 199
|
|
// 200
|
|
if (knownPaths) { // 201
|
|
// Similarly to above, paths must match everywhere, unless this is a // 202
|
|
// non-array field. // 203
|
|
if (!_.has(valuesByIndexAndPath[whichField], '') && // 204
|
|
_.size(knownPaths) !== _.size(valuesByIndexAndPath[whichField])) { // 205
|
|
throw Error("cannot index parallel arrays!"); // 206
|
|
} // 207
|
|
} else if (usedPaths) { // 208
|
|
knownPaths = {}; // 209
|
|
_.each(valuesByIndexAndPath[whichField], function (x, path) { // 210
|
|
knownPaths[path] = true; // 211
|
|
}); // 212
|
|
} // 213
|
|
}); // 214
|
|
// 215
|
|
if (!knownPaths) { // 216
|
|
// Easy case: no use of arrays. // 217
|
|
var soleKey = _.map(valuesByIndexAndPath, function (values) { // 218
|
|
if (!_.has(values, '')) // 219
|
|
throw Error("no value in sole key case?"); // 220
|
|
return values['']; // 221
|
|
}); // 222
|
|
cb(soleKey); // 223
|
|
return; // 224
|
|
} // 225
|
|
// 226
|
|
_.each(knownPaths, function (x, path) { // 227
|
|
var key = _.map(valuesByIndexAndPath, function (values) { // 228
|
|
if (_.has(values, '')) // 229
|
|
return values['']; // 230
|
|
if (!_.has(values, path)) // 231
|
|
throw Error("missing path?"); // 232
|
|
return values[path]; // 233
|
|
}); // 234
|
|
cb(key); // 235
|
|
}); // 236
|
|
}, // 237
|
|
// 238
|
|
// Takes in two keys: arrays whose lengths match the number of spec // 239
|
|
// parts. Returns negative, 0, or positive based on using the sort spec to // 240
|
|
// compare fields. // 241
|
|
_compareKeys: function (key1, key2) { // 242
|
|
var self = this; // 243
|
|
if (key1.length !== self._sortSpecParts.length || // 244
|
|
key2.length !== self._sortSpecParts.length) { // 245
|
|
throw Error("Key has wrong length"); // 246
|
|
} // 247
|
|
// 248
|
|
return self._keyComparator(key1, key2); // 249
|
|
}, // 250
|
|
// 251
|
|
// Given an index 'i', returns a comparator that compares two key arrays based // 252
|
|
// on field 'i'. // 253
|
|
_keyFieldComparator: function (i) { // 254
|
|
var self = this; // 255
|
|
var invert = !self._sortSpecParts[i].ascending; // 256
|
|
return function (key1, key2) { // 257
|
|
var compare = LocalCollection._f._cmp(key1[i], key2[i]); // 258
|
|
if (invert) // 259
|
|
compare = -compare; // 260
|
|
return compare; // 261
|
|
}; // 262
|
|
}, // 263
|
|
// 264
|
|
// Returns a comparator that represents the sort specification (but not // 265
|
|
// including a possible geoquery distance tie-breaker). // 266
|
|
_getBaseComparator: function () { // 267
|
|
var self = this; // 268
|
|
// 269
|
|
// If we're only sorting on geoquery distance and no specs, just say // 270
|
|
// everything is equal. // 271
|
|
if (!self._sortSpecParts.length) { // 272
|
|
return function (doc1, doc2) { // 273
|
|
return 0; // 274
|
|
}; // 275
|
|
} // 276
|
|
// 277
|
|
return function (doc1, doc2) { // 278
|
|
var key1 = self._getMinKeyFromDoc(doc1); // 279
|
|
var key2 = self._getMinKeyFromDoc(doc2); // 280
|
|
return self._compareKeys(key1, key2); // 281
|
|
}; // 282
|
|
}, // 283
|
|
// 284
|
|
// In MongoDB, if you have documents // 285
|
|
// {_id: 'x', a: [1, 10]} and // 286
|
|
// {_id: 'y', a: [5, 15]}, // 287
|
|
// then C.find({}, {sort: {a: 1}}) puts x before y (1 comes before 5). // 288
|
|
// But C.find({a: {$gt: 3}}, {sort: {a: 1}}) puts y before x (1 does not // 289
|
|
// match the selector, and 5 comes before 10). // 290
|
|
// // 291
|
|
// The way this works is pretty subtle! For example, if the documents // 292
|
|
// are instead {_id: 'x', a: [{x: 1}, {x: 10}]}) and // 293
|
|
// {_id: 'y', a: [{x: 5}, {x: 15}]}), // 294
|
|
// then C.find({'a.x': {$gt: 3}}, {sort: {'a.x': 1}}) and // 295
|
|
// C.find({a: {$elemMatch: {x: {$gt: 3}}}}, {sort: {'a.x': 1}}) // 296
|
|
// both follow this rule (y before x). (ie, you do have to apply this // 297
|
|
// through $elemMatch.) // 298
|
|
// // 299
|
|
// So if you pass a matcher to this sorter's constructor, we will attempt to // 300
|
|
// skip sort keys that don't match the selector. The logic here is pretty // 301
|
|
// subtle and undocumented; we've gotten as close as we can figure out based // 302
|
|
// on our understanding of Mongo's behavior. // 303
|
|
_useWithMatcher: function (matcher) { // 304
|
|
var self = this; // 305
|
|
// 306
|
|
if (self._keyFilter) // 307
|
|
throw Error("called _useWithMatcher twice?"); // 308
|
|
// 309
|
|
// If we are only sorting by distance, then we're not going to bother to // 310
|
|
// build a key filter. // 311
|
|
// XXX figure out how geoqueries interact with this stuff // 312
|
|
if (_.isEmpty(self._sortSpecParts)) // 313
|
|
return; // 314
|
|
// 315
|
|
var selector = matcher._selector; // 316
|
|
// 317
|
|
// If the user just passed a literal function to find(), then we can't get a // 318
|
|
// key filter from it. // 319
|
|
if (selector instanceof Function) // 320
|
|
return; // 321
|
|
// 322
|
|
var constraintsByPath = {}; // 323
|
|
_.each(self._sortSpecParts, function (spec, i) { // 324
|
|
constraintsByPath[spec.path] = []; // 325
|
|
}); // 326
|
|
// 327
|
|
_.each(selector, function (subSelector, key) { // 328
|
|
// XXX support $and and $or // 329
|
|
// 330
|
|
var constraints = constraintsByPath[key]; // 331
|
|
if (!constraints) // 332
|
|
return; // 333
|
|
// 334
|
|
// XXX it looks like the real MongoDB implementation isn't "does the // 335
|
|
// regexp match" but "does the value fall into a range named by the // 336
|
|
// literal prefix of the regexp", ie "foo" in /^foo(bar|baz)+/ But // 337
|
|
// "does the regexp match" is a good approximation. // 338
|
|
if (subSelector instanceof RegExp) { // 339
|
|
// As far as we can tell, using either of the options that both we and // 340
|
|
// MongoDB support ('i' and 'm') disables use of the key filter. This // 341
|
|
// makes sense: MongoDB mostly appears to be calculating ranges of an // 342
|
|
// index to use, which means it only cares about regexps that match // 343
|
|
// one range (with a literal prefix), and both 'i' and 'm' prevent the // 344
|
|
// literal prefix of the regexp from actually meaning one range. // 345
|
|
if (subSelector.ignoreCase || subSelector.multiline) // 346
|
|
return; // 347
|
|
constraints.push(regexpElementMatcher(subSelector)); // 348
|
|
return; // 349
|
|
} // 350
|
|
// 351
|
|
if (isOperatorObject(subSelector)) { // 352
|
|
_.each(subSelector, function (operand, operator) { // 353
|
|
if (_.contains(['$lt', '$lte', '$gt', '$gte'], operator)) { // 354
|
|
// XXX this depends on us knowing that these operators don't use any // 355
|
|
// of the arguments to compileElementSelector other than operand. // 356
|
|
constraints.push( // 357
|
|
ELEMENT_OPERATORS[operator].compileElementSelector(operand)); // 358
|
|
} // 359
|
|
// 360
|
|
// See comments in the RegExp block above. // 361
|
|
if (operator === '$regex' && !subSelector.$options) { // 362
|
|
constraints.push( // 363
|
|
ELEMENT_OPERATORS.$regex.compileElementSelector( // 364
|
|
operand, subSelector)); // 365
|
|
} // 366
|
|
// 367
|
|
// XXX support {$exists: true}, $mod, $type, $in, $elemMatch // 368
|
|
}); // 369
|
|
return; // 370
|
|
} // 371
|
|
// 372
|
|
// OK, it's an equality thing. // 373
|
|
constraints.push(equalityElementMatcher(subSelector)); // 374
|
|
}); // 375
|
|
// 376
|
|
// It appears that the first sort field is treated differently from the // 377
|
|
// others; we shouldn't create a key filter unless the first sort field is // 378
|
|
// restricted, though after that point we can restrict the other sort fields // 379
|
|
// or not as we wish. // 380
|
|
if (_.isEmpty(constraintsByPath[self._sortSpecParts[0].path])) // 381
|
|
return; // 382
|
|
// 383
|
|
self._keyFilter = function (key) { // 384
|
|
return _.all(self._sortSpecParts, function (specPart, index) { // 385
|
|
return _.all(constraintsByPath[specPart.path], function (f) { // 386
|
|
return f(key[index]); // 387
|
|
}); // 388
|
|
}); // 389
|
|
}; // 390
|
|
} // 391
|
|
}); // 392
|
|
// 393
|
|
// Given an array of comparators // 394
|
|
// (functions (a,b)->(negative or positive or zero)), returns a single // 395
|
|
// comparator which uses each comparator in order and returns the first // 396
|
|
// non-zero value. // 397
|
|
var composeComparators = function (comparatorArray) { // 398
|
|
return function (a, b) { // 399
|
|
for (var i = 0; i < comparatorArray.length; ++i) { // 400
|
|
var compare = comparatorArray[i](a, b); // 401
|
|
if (compare !== 0) // 402
|
|
return compare; // 403
|
|
} // 404
|
|
return 0; // 405
|
|
}; // 406
|
|
}; // 407
|
|
// 408
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/projection.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Knows how to compile a fields projection to a predicate function. // 1
|
|
// @returns - Function: a closure that filters out an object according to the // 2
|
|
// fields projection rules: // 3
|
|
// @param obj - Object: MongoDB-styled document // 4
|
|
// @returns - Object: a document with the fields filtered out // 5
|
|
// according to projection rules. Doesn't retain subfields // 6
|
|
// of passed argument. // 7
|
|
LocalCollection._compileProjection = function (fields) { // 8
|
|
LocalCollection._checkSupportedProjection(fields); // 9
|
|
// 10
|
|
var _idProjection = _.isUndefined(fields._id) ? true : fields._id; // 11
|
|
var details = projectionDetails(fields); // 12
|
|
// 13
|
|
// returns transformed doc according to ruleTree // 14
|
|
var transform = function (doc, ruleTree) { // 15
|
|
// Special case for "sets" // 16
|
|
if (_.isArray(doc)) // 17
|
|
return _.map(doc, function (subdoc) { return transform(subdoc, ruleTree); }); // 18
|
|
// 19
|
|
var res = details.including ? {} : EJSON.clone(doc); // 20
|
|
_.each(ruleTree, function (rule, key) { // 21
|
|
if (!_.has(doc, key)) // 22
|
|
return; // 23
|
|
if (_.isObject(rule)) { // 24
|
|
// For sub-objects/subsets we branch // 25
|
|
if (_.isObject(doc[key])) // 26
|
|
res[key] = transform(doc[key], rule); // 27
|
|
// Otherwise we don't even touch this subfield // 28
|
|
} else if (details.including) // 29
|
|
res[key] = EJSON.clone(doc[key]); // 30
|
|
else // 31
|
|
delete res[key]; // 32
|
|
}); // 33
|
|
// 34
|
|
return res; // 35
|
|
}; // 36
|
|
// 37
|
|
return function (obj) { // 38
|
|
var res = transform(obj, details.tree); // 39
|
|
// 40
|
|
if (_idProjection && _.has(obj, '_id')) // 41
|
|
res._id = obj._id; // 42
|
|
if (!_idProjection && _.has(res, '_id')) // 43
|
|
delete res._id; // 44
|
|
return res; // 45
|
|
}; // 46
|
|
}; // 47
|
|
// 48
|
|
// Traverses the keys of passed projection and constructs a tree where all // 49
|
|
// leaves are either all True or all False // 50
|
|
// @returns Object: // 51
|
|
// - tree - Object - tree representation of keys involved in projection // 52
|
|
// (exception for '_id' as it is a special case handled separately) // 53
|
|
// - including - Boolean - "take only certain fields" type of projection // 54
|
|
projectionDetails = function (fields) { // 55
|
|
// Find the non-_id keys (_id is handled specially because it is included unless // 56
|
|
// explicitly excluded). Sort the keys, so that our code to detect overlaps // 57
|
|
// like 'foo' and 'foo.bar' can assume that 'foo' comes first. // 58
|
|
var fieldsKeys = _.keys(fields).sort(); // 59
|
|
// 60
|
|
// If there are other rules other than '_id', treat '_id' differently in a // 61
|
|
// separate case. If '_id' is the only rule, use it to understand if it is // 62
|
|
// including/excluding projection. // 63
|
|
if (fieldsKeys.length > 0 && !(fieldsKeys.length === 1 && fieldsKeys[0] === '_id')) // 64
|
|
fieldsKeys = _.reject(fieldsKeys, function (key) { return key === '_id'; }); // 65
|
|
// 66
|
|
var including = null; // Unknown // 67
|
|
// 68
|
|
_.each(fieldsKeys, function (keyPath) { // 69
|
|
var rule = !!fields[keyPath]; // 70
|
|
if (including === null) // 71
|
|
including = rule; // 72
|
|
if (including !== rule) // 73
|
|
// This error message is copies from MongoDB shell // 74
|
|
throw MinimongoError("You cannot currently mix including and excluding fields."); // 75
|
|
}); // 76
|
|
// 77
|
|
// 78
|
|
var projectionRulesTree = pathsToTree( // 79
|
|
fieldsKeys, // 80
|
|
function (path) { return including; }, // 81
|
|
function (node, path, fullPath) { // 82
|
|
// Check passed projection fields' keys: If you have two rules such as // 83
|
|
// 'foo.bar' and 'foo.bar.baz', then the result becomes ambiguous. If // 84
|
|
// that happens, there is a probability you are doing something wrong, // 85
|
|
// framework should notify you about such mistake earlier on cursor // 86
|
|
// compilation step than later during runtime. Note, that real mongo // 87
|
|
// doesn't do anything about it and the later rule appears in projection // 88
|
|
// project, more priority it takes. // 89
|
|
// // 90
|
|
// Example, assume following in mongo shell: // 91
|
|
// > db.coll.insert({ a: { b: 23, c: 44 } }) // 92
|
|
// > db.coll.find({}, { 'a': 1, 'a.b': 1 }) // 93
|
|
// { "_id" : ObjectId("520bfe456024608e8ef24af3"), "a" : { "b" : 23 } } // 94
|
|
// > db.coll.find({}, { 'a.b': 1, 'a': 1 }) // 95
|
|
// { "_id" : ObjectId("520bfe456024608e8ef24af3"), "a" : { "b" : 23, "c" : 44 } } // 96
|
|
// // 97
|
|
// Note, how second time the return set of keys is different. // 98
|
|
// 99
|
|
var currentPath = fullPath; // 100
|
|
var anotherPath = path; // 101
|
|
throw MinimongoError("both " + currentPath + " and " + anotherPath + // 102
|
|
" found in fields option, using both of them may trigger " + // 103
|
|
"unexpected behavior. Did you mean to use only one of them?"); // 104
|
|
}); // 105
|
|
// 106
|
|
return { // 107
|
|
tree: projectionRulesTree, // 108
|
|
including: including // 109
|
|
}; // 110
|
|
}; // 111
|
|
// 112
|
|
// paths - Array: list of mongo style paths // 113
|
|
// newLeafFn - Function: of form function(path) should return a scalar value to // 114
|
|
// put into list created for that path // 115
|
|
// conflictFn - Function: of form function(node, path, fullPath) is called // 116
|
|
// when building a tree path for 'fullPath' node on // 117
|
|
// 'path' was already a leaf with a value. Must return a // 118
|
|
// conflict resolution. // 119
|
|
// initial tree - Optional Object: starting tree. // 120
|
|
// @returns - Object: tree represented as a set of nested objects // 121
|
|
pathsToTree = function (paths, newLeafFn, conflictFn, tree) { // 122
|
|
tree = tree || {}; // 123
|
|
_.each(paths, function (keyPath) { // 124
|
|
var treePos = tree; // 125
|
|
var pathArr = keyPath.split('.'); // 126
|
|
// 127
|
|
// use _.all just for iteration with break // 128
|
|
var success = _.all(pathArr.slice(0, -1), function (key, idx) { // 129
|
|
if (!_.has(treePos, key)) // 130
|
|
treePos[key] = {}; // 131
|
|
else if (!_.isObject(treePos[key])) { // 132
|
|
treePos[key] = conflictFn(treePos[key], // 133
|
|
pathArr.slice(0, idx + 1).join('.'), // 134
|
|
keyPath); // 135
|
|
// break out of loop if we are failing for this path // 136
|
|
if (!_.isObject(treePos[key])) // 137
|
|
return false; // 138
|
|
} // 139
|
|
// 140
|
|
treePos = treePos[key]; // 141
|
|
return true; // 142
|
|
}); // 143
|
|
// 144
|
|
if (success) { // 145
|
|
var lastKey = _.last(pathArr); // 146
|
|
if (!_.has(treePos, lastKey)) // 147
|
|
treePos[lastKey] = newLeafFn(keyPath); // 148
|
|
else // 149
|
|
treePos[lastKey] = conflictFn(treePos[lastKey], keyPath, keyPath); // 150
|
|
} // 151
|
|
}); // 152
|
|
// 153
|
|
return tree; // 154
|
|
}; // 155
|
|
// 156
|
|
LocalCollection._checkSupportedProjection = function (fields) { // 157
|
|
if (!_.isObject(fields) || _.isArray(fields)) // 158
|
|
throw MinimongoError("fields option must be an object"); // 159
|
|
// 160
|
|
_.each(fields, function (val, keyPath) { // 161
|
|
if (_.contains(keyPath.split('.'), '$')) // 162
|
|
throw MinimongoError("Minimongo doesn't support $ operator in projections yet."); // 163
|
|
if (_.indexOf([1, 0, true, false], val) === -1) // 164
|
|
throw MinimongoError("Projection values should be one of 1, 0, true, or false"); // 165
|
|
}); // 166
|
|
}; // 167
|
|
// 168
|
|
// 169
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/modify.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// XXX need a strategy for passing the binding of $ into this // 1
|
|
// function, from the compiled selector // 2
|
|
// // 3
|
|
// maybe just {key.up.to.just.before.dollarsign: array_index} // 4
|
|
// // 5
|
|
// XXX atomicity: if one modification fails, do we roll back the whole // 6
|
|
// change? // 7
|
|
// // 8
|
|
// options: // 9
|
|
// - isInsert is set when _modify is being called to compute the document to // 10
|
|
// insert as part of an upsert operation. We use this primarily to figure // 11
|
|
// out when to set the fields in $setOnInsert, if present. // 12
|
|
LocalCollection._modify = function (doc, mod, options) { // 13
|
|
options = options || {}; // 14
|
|
if (!isPlainObject(mod)) // 15
|
|
throw MinimongoError("Modifier must be an object"); // 16
|
|
var isModifier = isOperatorObject(mod); // 17
|
|
// 18
|
|
var newDoc; // 19
|
|
// 20
|
|
if (!isModifier) { // 21
|
|
if (mod._id && !EJSON.equals(doc._id, mod._id)) // 22
|
|
throw MinimongoError("Cannot change the _id of a document"); // 23
|
|
// 24
|
|
// replace the whole document // 25
|
|
for (var k in mod) { // 26
|
|
if (/\./.test(k)) // 27
|
|
throw MinimongoError( // 28
|
|
"When replacing document, field name may not contain '.'"); // 29
|
|
} // 30
|
|
newDoc = mod; // 31
|
|
} else { // 32
|
|
// apply modifiers to the doc. // 33
|
|
newDoc = EJSON.clone(doc); // 34
|
|
// 35
|
|
_.each(mod, function (operand, op) { // 36
|
|
var modFunc = MODIFIERS[op]; // 37
|
|
// Treat $setOnInsert as $set if this is an insert. // 38
|
|
if (options.isInsert && op === '$setOnInsert') // 39
|
|
modFunc = MODIFIERS['$set']; // 40
|
|
if (!modFunc) // 41
|
|
throw MinimongoError("Invalid modifier specified " + op); // 42
|
|
_.each(operand, function (arg, keypath) { // 43
|
|
if (keypath === '') { // 44
|
|
throw MinimongoError("An empty update path is not valid."); // 45
|
|
} // 46
|
|
// 47
|
|
if (keypath === '_id') { // 48
|
|
throw MinimongoError("Mod on _id not allowed"); // 49
|
|
} // 50
|
|
// 51
|
|
var keyparts = keypath.split('.'); // 52
|
|
// 53
|
|
if (! _.all(keyparts, _.identity)) { // 54
|
|
throw MinimongoError( // 55
|
|
"The update path '" + keypath + // 56
|
|
"' contains an empty field name, which is not allowed."); // 57
|
|
} // 58
|
|
// 59
|
|
var noCreate = _.has(NO_CREATE_MODIFIERS, op); // 60
|
|
var forbidArray = (op === "$rename"); // 61
|
|
var target = findModTarget(newDoc, keyparts, { // 62
|
|
noCreate: NO_CREATE_MODIFIERS[op], // 63
|
|
forbidArray: (op === "$rename"), // 64
|
|
arrayIndices: options.arrayIndices // 65
|
|
}); // 66
|
|
var field = keyparts.pop(); // 67
|
|
modFunc(target, field, arg, keypath, newDoc); // 68
|
|
}); // 69
|
|
}); // 70
|
|
} // 71
|
|
// 72
|
|
// move new document into place. // 73
|
|
_.each(_.keys(doc), function (k) { // 74
|
|
// Note: this used to be for (var k in doc) however, this does not // 75
|
|
// work right in Opera. Deleting from a doc while iterating over it // 76
|
|
// would sometimes cause opera to skip some keys. // 77
|
|
if (k !== '_id') // 78
|
|
delete doc[k]; // 79
|
|
}); // 80
|
|
_.each(newDoc, function (v, k) { // 81
|
|
doc[k] = v; // 82
|
|
}); // 83
|
|
}; // 84
|
|
// 85
|
|
// for a.b.c.2.d.e, keyparts should be ['a', 'b', 'c', '2', 'd', 'e'], // 86
|
|
// and then you would operate on the 'e' property of the returned // 87
|
|
// object. // 88
|
|
// // 89
|
|
// if options.noCreate is falsey, creates intermediate levels of // 90
|
|
// structure as necessary, like mkdir -p (and raises an exception if // 91
|
|
// that would mean giving a non-numeric property to an array.) if // 92
|
|
// options.noCreate is true, return undefined instead. // 93
|
|
// // 94
|
|
// may modify the last element of keyparts to signal to the caller that it needs // 95
|
|
// to use a different value to index into the returned object (for example, // 96
|
|
// ['a', '01'] -> ['a', 1]). // 97
|
|
// // 98
|
|
// if forbidArray is true, return null if the keypath goes through an array. // 99
|
|
// // 100
|
|
// if options.arrayIndices is set, use its first element for the (first) '$' in // 101
|
|
// the path. // 102
|
|
var findModTarget = function (doc, keyparts, options) { // 103
|
|
options = options || {}; // 104
|
|
var usedArrayIndex = false; // 105
|
|
for (var i = 0; i < keyparts.length; i++) { // 106
|
|
var last = (i === keyparts.length - 1); // 107
|
|
var keypart = keyparts[i]; // 108
|
|
var indexable = isIndexable(doc); // 109
|
|
if (!indexable) { // 110
|
|
if (options.noCreate) // 111
|
|
return undefined; // 112
|
|
var e = MinimongoError( // 113
|
|
"cannot use the part '" + keypart + "' to traverse " + doc); // 114
|
|
e.setPropertyError = true; // 115
|
|
throw e; // 116
|
|
} // 117
|
|
if (doc instanceof Array) { // 118
|
|
if (options.forbidArray) // 119
|
|
return null; // 120
|
|
if (keypart === '$') { // 121
|
|
if (usedArrayIndex) // 122
|
|
throw MinimongoError("Too many positional (i.e. '$') elements"); // 123
|
|
if (!options.arrayIndices || !options.arrayIndices.length) { // 124
|
|
throw MinimongoError("The positional operator did not find the " + // 125
|
|
"match needed from the query"); // 126
|
|
} // 127
|
|
keypart = options.arrayIndices[0]; // 128
|
|
usedArrayIndex = true; // 129
|
|
} else if (isNumericKey(keypart)) { // 130
|
|
keypart = parseInt(keypart); // 131
|
|
} else { // 132
|
|
if (options.noCreate) // 133
|
|
return undefined; // 134
|
|
throw MinimongoError( // 135
|
|
"can't append to array using string field name [" // 136
|
|
+ keypart + "]"); // 137
|
|
} // 138
|
|
if (last) // 139
|
|
// handle 'a.01' // 140
|
|
keyparts[i] = keypart; // 141
|
|
if (options.noCreate && keypart >= doc.length) // 142
|
|
return undefined; // 143
|
|
while (doc.length < keypart) // 144
|
|
doc.push(null); // 145
|
|
if (!last) { // 146
|
|
if (doc.length === keypart) // 147
|
|
doc.push({}); // 148
|
|
else if (typeof doc[keypart] !== "object") // 149
|
|
throw MinimongoError("can't modify field '" + keyparts[i + 1] + // 150
|
|
"' of list value " + JSON.stringify(doc[keypart])); // 151
|
|
} // 152
|
|
} else { // 153
|
|
if (keypart.length && keypart.substr(0, 1) === '$') // 154
|
|
throw MinimongoError("can't set field named " + keypart); // 155
|
|
if (!(keypart in doc)) { // 156
|
|
if (options.noCreate) // 157
|
|
return undefined; // 158
|
|
if (!last) // 159
|
|
doc[keypart] = {}; // 160
|
|
} // 161
|
|
} // 162
|
|
// 163
|
|
if (last) // 164
|
|
return doc; // 165
|
|
doc = doc[keypart]; // 166
|
|
} // 167
|
|
// 168
|
|
// notreached // 169
|
|
}; // 170
|
|
// 171
|
|
var NO_CREATE_MODIFIERS = { // 172
|
|
$unset: true, // 173
|
|
$pop: true, // 174
|
|
$rename: true, // 175
|
|
$pull: true, // 176
|
|
$pullAll: true // 177
|
|
}; // 178
|
|
// 179
|
|
var MODIFIERS = { // 180
|
|
$inc: function (target, field, arg) { // 181
|
|
if (typeof arg !== "number") // 182
|
|
throw MinimongoError("Modifier $inc allowed for numbers only"); // 183
|
|
if (field in target) { // 184
|
|
if (typeof target[field] !== "number") // 185
|
|
throw MinimongoError("Cannot apply $inc modifier to non-number"); // 186
|
|
target[field] += arg; // 187
|
|
} else { // 188
|
|
target[field] = arg; // 189
|
|
} // 190
|
|
}, // 191
|
|
$set: function (target, field, arg) { // 192
|
|
if (!_.isObject(target)) { // not an array or an object // 193
|
|
var e = MinimongoError("Cannot set property on non-object field"); // 194
|
|
e.setPropertyError = true; // 195
|
|
throw e; // 196
|
|
} // 197
|
|
if (target === null) { // 198
|
|
var e = MinimongoError("Cannot set property on null"); // 199
|
|
e.setPropertyError = true; // 200
|
|
throw e; // 201
|
|
} // 202
|
|
target[field] = EJSON.clone(arg); // 203
|
|
}, // 204
|
|
$setOnInsert: function (target, field, arg) { // 205
|
|
// converted to `$set` in `_modify` // 206
|
|
}, // 207
|
|
$unset: function (target, field, arg) { // 208
|
|
if (target !== undefined) { // 209
|
|
if (target instanceof Array) { // 210
|
|
if (field in target) // 211
|
|
target[field] = null; // 212
|
|
} else // 213
|
|
delete target[field]; // 214
|
|
} // 215
|
|
}, // 216
|
|
$push: function (target, field, arg) { // 217
|
|
if (target[field] === undefined) // 218
|
|
target[field] = []; // 219
|
|
if (!(target[field] instanceof Array)) // 220
|
|
throw MinimongoError("Cannot apply $push modifier to non-array"); // 221
|
|
// 222
|
|
if (!(arg && arg.$each)) { // 223
|
|
// Simple mode: not $each // 224
|
|
target[field].push(EJSON.clone(arg)); // 225
|
|
return; // 226
|
|
} // 227
|
|
// 228
|
|
// Fancy mode: $each (and maybe $slice and $sort) // 229
|
|
var toPush = arg.$each; // 230
|
|
if (!(toPush instanceof Array)) // 231
|
|
throw MinimongoError("$each must be an array"); // 232
|
|
// 233
|
|
// Parse $slice. // 234
|
|
var slice = undefined; // 235
|
|
if ('$slice' in arg) { // 236
|
|
if (typeof arg.$slice !== "number") // 237
|
|
throw MinimongoError("$slice must be a numeric value"); // 238
|
|
// XXX should check to make sure integer // 239
|
|
if (arg.$slice > 0) // 240
|
|
throw MinimongoError("$slice in $push must be zero or negative"); // 241
|
|
slice = arg.$slice; // 242
|
|
} // 243
|
|
// 244
|
|
// Parse $sort. // 245
|
|
var sortFunction = undefined; // 246
|
|
if (arg.$sort) { // 247
|
|
if (slice === undefined) // 248
|
|
throw MinimongoError("$sort requires $slice to be present"); // 249
|
|
// XXX this allows us to use a $sort whose value is an array, but that's // 250
|
|
// actually an extension of the Node driver, so it won't work // 251
|
|
// server-side. Could be confusing! // 252
|
|
// XXX is it correct that we don't do geo-stuff here? // 253
|
|
sortFunction = new Minimongo.Sorter(arg.$sort).getComparator(); // 254
|
|
for (var i = 0; i < toPush.length; i++) { // 255
|
|
if (LocalCollection._f._type(toPush[i]) !== 3) { // 256
|
|
throw MinimongoError("$push like modifiers using $sort " + // 257
|
|
"require all elements to be objects"); // 258
|
|
} // 259
|
|
} // 260
|
|
} // 261
|
|
// 262
|
|
// Actually push. // 263
|
|
for (var j = 0; j < toPush.length; j++) // 264
|
|
target[field].push(EJSON.clone(toPush[j])); // 265
|
|
// 266
|
|
// Actually sort. // 267
|
|
if (sortFunction) // 268
|
|
target[field].sort(sortFunction); // 269
|
|
// 270
|
|
// Actually slice. // 271
|
|
if (slice !== undefined) { // 272
|
|
if (slice === 0) // 273
|
|
target[field] = []; // differs from Array.slice! // 274
|
|
else // 275
|
|
target[field] = target[field].slice(slice); // 276
|
|
} // 277
|
|
}, // 278
|
|
$pushAll: function (target, field, arg) { // 279
|
|
if (!(typeof arg === "object" && arg instanceof Array)) // 280
|
|
throw MinimongoError("Modifier $pushAll/pullAll allowed for arrays only"); // 281
|
|
var x = target[field]; // 282
|
|
if (x === undefined) // 283
|
|
target[field] = arg; // 284
|
|
else if (!(x instanceof Array)) // 285
|
|
throw MinimongoError("Cannot apply $pushAll modifier to non-array"); // 286
|
|
else { // 287
|
|
for (var i = 0; i < arg.length; i++) // 288
|
|
x.push(arg[i]); // 289
|
|
} // 290
|
|
}, // 291
|
|
$addToSet: function (target, field, arg) { // 292
|
|
var isEach = false; // 293
|
|
if (typeof arg === "object") { // 294
|
|
//check if first key is '$each' // 295
|
|
for (var k in arg) { // 296
|
|
if (k === "$each") // 297
|
|
isEach = true; // 298
|
|
break; // 299
|
|
} // 300
|
|
} // 301
|
|
var values = isEach ? arg["$each"] : [arg]; // 302
|
|
var x = target[field]; // 303
|
|
if (x === undefined) // 304
|
|
target[field] = values; // 305
|
|
else if (!(x instanceof Array)) // 306
|
|
throw MinimongoError("Cannot apply $addToSet modifier to non-array"); // 307
|
|
else { // 308
|
|
_.each(values, function (value) { // 309
|
|
for (var i = 0; i < x.length; i++) // 310
|
|
if (LocalCollection._f._equal(value, x[i])) // 311
|
|
return; // 312
|
|
x.push(EJSON.clone(value)); // 313
|
|
}); // 314
|
|
} // 315
|
|
}, // 316
|
|
$pop: function (target, field, arg) { // 317
|
|
if (target === undefined) // 318
|
|
return; // 319
|
|
var x = target[field]; // 320
|
|
if (x === undefined) // 321
|
|
return; // 322
|
|
else if (!(x instanceof Array)) // 323
|
|
throw MinimongoError("Cannot apply $pop modifier to non-array"); // 324
|
|
else { // 325
|
|
if (typeof arg === 'number' && arg < 0) // 326
|
|
x.splice(0, 1); // 327
|
|
else // 328
|
|
x.pop(); // 329
|
|
} // 330
|
|
}, // 331
|
|
$pull: function (target, field, arg) { // 332
|
|
if (target === undefined) // 333
|
|
return; // 334
|
|
var x = target[field]; // 335
|
|
if (x === undefined) // 336
|
|
return; // 337
|
|
else if (!(x instanceof Array)) // 338
|
|
throw MinimongoError("Cannot apply $pull/pullAll modifier to non-array"); // 339
|
|
else { // 340
|
|
var out = []; // 341
|
|
if (typeof arg === "object" && !(arg instanceof Array)) { // 342
|
|
// XXX would be much nicer to compile this once, rather than // 343
|
|
// for each document we modify.. but usually we're not // 344
|
|
// modifying that many documents, so we'll let it slide for // 345
|
|
// now // 346
|
|
// 347
|
|
// XXX Minimongo.Matcher isn't up for the job, because we need // 348
|
|
// to permit stuff like {$pull: {a: {$gt: 4}}}.. something // 349
|
|
// like {$gt: 4} is not normally a complete selector. // 350
|
|
// same issue as $elemMatch possibly? // 351
|
|
var matcher = new Minimongo.Matcher(arg); // 352
|
|
for (var i = 0; i < x.length; i++) // 353
|
|
if (!matcher.documentMatches(x[i]).result) // 354
|
|
out.push(x[i]); // 355
|
|
} else { // 356
|
|
for (var i = 0; i < x.length; i++) // 357
|
|
if (!LocalCollection._f._equal(x[i], arg)) // 358
|
|
out.push(x[i]); // 359
|
|
} // 360
|
|
target[field] = out; // 361
|
|
} // 362
|
|
}, // 363
|
|
$pullAll: function (target, field, arg) { // 364
|
|
if (!(typeof arg === "object" && arg instanceof Array)) // 365
|
|
throw MinimongoError("Modifier $pushAll/pullAll allowed for arrays only"); // 366
|
|
if (target === undefined) // 367
|
|
return; // 368
|
|
var x = target[field]; // 369
|
|
if (x === undefined) // 370
|
|
return; // 371
|
|
else if (!(x instanceof Array)) // 372
|
|
throw MinimongoError("Cannot apply $pull/pullAll modifier to non-array"); // 373
|
|
else { // 374
|
|
var out = []; // 375
|
|
for (var i = 0; i < x.length; i++) { // 376
|
|
var exclude = false; // 377
|
|
for (var j = 0; j < arg.length; j++) { // 378
|
|
if (LocalCollection._f._equal(x[i], arg[j])) { // 379
|
|
exclude = true; // 380
|
|
break; // 381
|
|
} // 382
|
|
} // 383
|
|
if (!exclude) // 384
|
|
out.push(x[i]); // 385
|
|
} // 386
|
|
target[field] = out; // 387
|
|
} // 388
|
|
}, // 389
|
|
$rename: function (target, field, arg, keypath, doc) { // 390
|
|
if (keypath === arg) // 391
|
|
// no idea why mongo has this restriction.. // 392
|
|
throw MinimongoError("$rename source must differ from target"); // 393
|
|
if (target === null) // 394
|
|
throw MinimongoError("$rename source field invalid"); // 395
|
|
if (typeof arg !== "string") // 396
|
|
throw MinimongoError("$rename target must be a string"); // 397
|
|
if (target === undefined) // 398
|
|
return; // 399
|
|
var v = target[field]; // 400
|
|
delete target[field]; // 401
|
|
// 402
|
|
var keyparts = arg.split('.'); // 403
|
|
var target2 = findModTarget(doc, keyparts, {forbidArray: true}); // 404
|
|
if (target2 === null) // 405
|
|
throw MinimongoError("$rename target field invalid"); // 406
|
|
var field2 = keyparts.pop(); // 407
|
|
target2[field2] = v; // 408
|
|
}, // 409
|
|
$bit: function (target, field, arg) { // 410
|
|
// XXX mongo only supports $bit on integers, and we only support // 411
|
|
// native javascript numbers (doubles) so far, so we can't support $bit // 412
|
|
throw MinimongoError("$bit is not supported"); // 413
|
|
} // 414
|
|
}; // 415
|
|
// 416
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/diff.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ordered: bool. // 1
|
|
// old_results and new_results: collections of documents. // 2
|
|
// if ordered, they are arrays. // 3
|
|
// if unordered, they are IdMaps // 4
|
|
LocalCollection._diffQueryChanges = function (ordered, oldResults, newResults, // 5
|
|
observer, options) { // 6
|
|
if (ordered) // 7
|
|
LocalCollection._diffQueryOrderedChanges( // 8
|
|
oldResults, newResults, observer, options); // 9
|
|
else // 10
|
|
LocalCollection._diffQueryUnorderedChanges( // 11
|
|
oldResults, newResults, observer, options); // 12
|
|
}; // 13
|
|
// 14
|
|
LocalCollection._diffQueryUnorderedChanges = function (oldResults, newResults, // 15
|
|
observer, options) { // 16
|
|
options = options || {}; // 17
|
|
var projectionFn = options.projectionFn || EJSON.clone; // 18
|
|
// 19
|
|
if (observer.movedBefore) { // 20
|
|
throw new Error("_diffQueryUnordered called with a movedBefore observer!"); // 21
|
|
} // 22
|
|
// 23
|
|
newResults.forEach(function (newDoc, id) { // 24
|
|
var oldDoc = oldResults.get(id); // 25
|
|
if (oldDoc) { // 26
|
|
if (observer.changed && !EJSON.equals(oldDoc, newDoc)) { // 27
|
|
var projectedNew = projectionFn(newDoc); // 28
|
|
var projectedOld = projectionFn(oldDoc); // 29
|
|
var changedFields = // 30
|
|
LocalCollection._makeChangedFields(projectedNew, projectedOld); // 31
|
|
if (! _.isEmpty(changedFields)) { // 32
|
|
observer.changed(id, changedFields); // 33
|
|
} // 34
|
|
} // 35
|
|
} else if (observer.added) { // 36
|
|
var fields = projectionFn(newDoc); // 37
|
|
delete fields._id; // 38
|
|
observer.added(newDoc._id, fields); // 39
|
|
} // 40
|
|
}); // 41
|
|
// 42
|
|
if (observer.removed) { // 43
|
|
oldResults.forEach(function (oldDoc, id) { // 44
|
|
if (!newResults.has(id)) // 45
|
|
observer.removed(id); // 46
|
|
}); // 47
|
|
} // 48
|
|
}; // 49
|
|
// 50
|
|
// 51
|
|
LocalCollection._diffQueryOrderedChanges = function (old_results, new_results, // 52
|
|
observer, options) { // 53
|
|
options = options || {}; // 54
|
|
var projectionFn = options.projectionFn || EJSON.clone; // 55
|
|
// 56
|
|
var new_presence_of_id = {}; // 57
|
|
_.each(new_results, function (doc) { // 58
|
|
if (new_presence_of_id[doc._id]) // 59
|
|
Meteor._debug("Duplicate _id in new_results"); // 60
|
|
new_presence_of_id[doc._id] = true; // 61
|
|
}); // 62
|
|
// 63
|
|
var old_index_of_id = {}; // 64
|
|
_.each(old_results, function (doc, i) { // 65
|
|
if (doc._id in old_index_of_id) // 66
|
|
Meteor._debug("Duplicate _id in old_results"); // 67
|
|
old_index_of_id[doc._id] = i; // 68
|
|
}); // 69
|
|
// 70
|
|
// ALGORITHM: // 71
|
|
// // 72
|
|
// To determine which docs should be considered "moved" (and which // 73
|
|
// merely change position because of other docs moving) we run // 74
|
|
// a "longest common subsequence" (LCS) algorithm. The LCS of the // 75
|
|
// old doc IDs and the new doc IDs gives the docs that should NOT be // 76
|
|
// considered moved. // 77
|
|
// 78
|
|
// To actually call the appropriate callbacks to get from the old state to the // 79
|
|
// new state: // 80
|
|
// 81
|
|
// First, we call removed() on all the items that only appear in the old // 82
|
|
// state. // 83
|
|
// 84
|
|
// Then, once we have the items that should not move, we walk through the new // 85
|
|
// results array group-by-group, where a "group" is a set of items that have // 86
|
|
// moved, anchored on the end by an item that should not move. One by one, we // 87
|
|
// move each of those elements into place "before" the anchoring end-of-group // 88
|
|
// item, and fire changed events on them if necessary. Then we fire a changed // 89
|
|
// event on the anchor, and move on to the next group. There is always at // 90
|
|
// least one group; the last group is anchored by a virtual "null" id at the // 91
|
|
// end. // 92
|
|
// 93
|
|
// Asymptotically: O(N k) where k is number of ops, or potentially // 94
|
|
// O(N log N) if inner loop of LCS were made to be binary search. // 95
|
|
// 96
|
|
// 97
|
|
//////// LCS (longest common sequence, with respect to _id) // 98
|
|
// (see Wikipedia article on Longest Increasing Subsequence, // 99
|
|
// where the LIS is taken of the sequence of old indices of the // 100
|
|
// docs in new_results) // 101
|
|
// // 102
|
|
// unmoved: the output of the algorithm; members of the LCS, // 103
|
|
// in the form of indices into new_results // 104
|
|
var unmoved = []; // 105
|
|
// max_seq_len: length of LCS found so far // 106
|
|
var max_seq_len = 0; // 107
|
|
// seq_ends[i]: the index into new_results of the last doc in a // 108
|
|
// common subsequence of length of i+1 <= max_seq_len // 109
|
|
var N = new_results.length; // 110
|
|
var seq_ends = new Array(N); // 111
|
|
// ptrs: the common subsequence ending with new_results[n] extends // 112
|
|
// a common subsequence ending with new_results[ptr[n]], unless // 113
|
|
// ptr[n] is -1. // 114
|
|
var ptrs = new Array(N); // 115
|
|
// virtual sequence of old indices of new results // 116
|
|
var old_idx_seq = function(i_new) { // 117
|
|
return old_index_of_id[new_results[i_new]._id]; // 118
|
|
}; // 119
|
|
// for each item in new_results, use it to extend a common subsequence // 120
|
|
// of length j <= max_seq_len // 121
|
|
for(var i=0; i<N; i++) { // 122
|
|
if (old_index_of_id[new_results[i]._id] !== undefined) { // 123
|
|
var j = max_seq_len; // 124
|
|
// this inner loop would traditionally be a binary search, // 125
|
|
// but scanning backwards we will likely find a subseq to extend // 126
|
|
// pretty soon, bounded for example by the total number of ops. // 127
|
|
// If this were to be changed to a binary search, we'd still want // 128
|
|
// to scan backwards a bit as an optimization. // 129
|
|
while (j > 0) { // 130
|
|
if (old_idx_seq(seq_ends[j-1]) < old_idx_seq(i)) // 131
|
|
break; // 132
|
|
j--; // 133
|
|
} // 134
|
|
// 135
|
|
ptrs[i] = (j === 0 ? -1 : seq_ends[j-1]); // 136
|
|
seq_ends[j] = i; // 137
|
|
if (j+1 > max_seq_len) // 138
|
|
max_seq_len = j+1; // 139
|
|
} // 140
|
|
} // 141
|
|
// 142
|
|
// pull out the LCS/LIS into unmoved // 143
|
|
var idx = (max_seq_len === 0 ? -1 : seq_ends[max_seq_len-1]); // 144
|
|
while (idx >= 0) { // 145
|
|
unmoved.push(idx); // 146
|
|
idx = ptrs[idx]; // 147
|
|
} // 148
|
|
// the unmoved item list is built backwards, so fix that // 149
|
|
unmoved.reverse(); // 150
|
|
// 151
|
|
// the last group is always anchored by the end of the result list, which is // 152
|
|
// an id of "null" // 153
|
|
unmoved.push(new_results.length); // 154
|
|
// 155
|
|
_.each(old_results, function (doc) { // 156
|
|
if (!new_presence_of_id[doc._id]) // 157
|
|
observer.removed && observer.removed(doc._id); // 158
|
|
}); // 159
|
|
// for each group of things in the new_results that is anchored by an unmoved // 160
|
|
// element, iterate through the things before it. // 161
|
|
var startOfGroup = 0; // 162
|
|
_.each(unmoved, function (endOfGroup) { // 163
|
|
var groupId = new_results[endOfGroup] ? new_results[endOfGroup]._id : null; // 164
|
|
var oldDoc, newDoc, fields, projectedNew, projectedOld; // 165
|
|
for (var i = startOfGroup; i < endOfGroup; i++) { // 166
|
|
newDoc = new_results[i]; // 167
|
|
if (!_.has(old_index_of_id, newDoc._id)) { // 168
|
|
fields = projectionFn(newDoc); // 169
|
|
delete fields._id; // 170
|
|
observer.addedBefore && observer.addedBefore(newDoc._id, fields, groupId); // 171
|
|
observer.added && observer.added(newDoc._id, fields); // 172
|
|
} else { // 173
|
|
// moved // 174
|
|
oldDoc = old_results[old_index_of_id[newDoc._id]]; // 175
|
|
projectedNew = projectionFn(newDoc); // 176
|
|
projectedOld = projectionFn(oldDoc); // 177
|
|
fields = LocalCollection._makeChangedFields(projectedNew, projectedOld); // 178
|
|
if (!_.isEmpty(fields)) { // 179
|
|
observer.changed && observer.changed(newDoc._id, fields); // 180
|
|
} // 181
|
|
observer.movedBefore && observer.movedBefore(newDoc._id, groupId); // 182
|
|
} // 183
|
|
} // 184
|
|
if (groupId) { // 185
|
|
newDoc = new_results[endOfGroup]; // 186
|
|
oldDoc = old_results[old_index_of_id[newDoc._id]]; // 187
|
|
projectedNew = projectionFn(newDoc); // 188
|
|
projectedOld = projectionFn(oldDoc); // 189
|
|
fields = LocalCollection._makeChangedFields(projectedNew, projectedOld); // 190
|
|
if (!_.isEmpty(fields)) { // 191
|
|
observer.changed && observer.changed(newDoc._id, fields); // 192
|
|
} // 193
|
|
} // 194
|
|
startOfGroup = endOfGroup+1; // 195
|
|
}); // 196
|
|
// 197
|
|
// 198
|
|
}; // 199
|
|
// 200
|
|
// 201
|
|
// General helper for diff-ing two objects. // 202
|
|
// callbacks is an object like so: // 203
|
|
// { leftOnly: function (key, leftValue) {...}, // 204
|
|
// rightOnly: function (key, rightValue) {...}, // 205
|
|
// both: function (key, leftValue, rightValue) {...}, // 206
|
|
// } // 207
|
|
LocalCollection._diffObjects = function (left, right, callbacks) { // 208
|
|
_.each(left, function (leftValue, key) { // 209
|
|
if (_.has(right, key)) // 210
|
|
callbacks.both && callbacks.both(key, leftValue, right[key]); // 211
|
|
else // 212
|
|
callbacks.leftOnly && callbacks.leftOnly(key, leftValue); // 213
|
|
}); // 214
|
|
if (callbacks.rightOnly) { // 215
|
|
_.each(right, function(rightValue, key) { // 216
|
|
if (!_.has(left, key)) // 217
|
|
callbacks.rightOnly(key, rightValue); // 218
|
|
}); // 219
|
|
} // 220
|
|
}; // 221
|
|
// 222
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/id_map.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
LocalCollection._IdMap = function () { // 1
|
|
var self = this; // 2
|
|
IdMap.call(self, LocalCollection._idStringify, LocalCollection._idParse); // 3
|
|
}; // 4
|
|
// 5
|
|
Meteor._inherits(LocalCollection._IdMap, IdMap); // 6
|
|
// 7
|
|
// 8
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/observe.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// XXX maybe move these into another ObserveHelpers package or something // 1
|
|
// 2
|
|
// _CachingChangeObserver is an object which receives observeChanges callbacks // 3
|
|
// and keeps a cache of the current cursor state up to date in self.docs. Users // 4
|
|
// of this class should read the docs field but not modify it. You should pass // 5
|
|
// the "applyChange" field as the callbacks to the underlying observeChanges // 6
|
|
// call. Optionally, you can specify your own observeChanges callbacks which are // 7
|
|
// invoked immediately before the docs field is updated; this object is made // 8
|
|
// available as `this` to those callbacks. // 9
|
|
LocalCollection._CachingChangeObserver = function (options) { // 10
|
|
var self = this; // 11
|
|
options = options || {}; // 12
|
|
// 13
|
|
var orderedFromCallbacks = options.callbacks && // 14
|
|
LocalCollection._observeChangesCallbacksAreOrdered(options.callbacks); // 15
|
|
if (_.has(options, 'ordered')) { // 16
|
|
self.ordered = options.ordered; // 17
|
|
if (options.callbacks && options.ordered !== orderedFromCallbacks) // 18
|
|
throw Error("ordered option doesn't match callbacks"); // 19
|
|
} else if (options.callbacks) { // 20
|
|
self.ordered = orderedFromCallbacks; // 21
|
|
} else { // 22
|
|
throw Error("must provide ordered or callbacks"); // 23
|
|
} // 24
|
|
var callbacks = options.callbacks || {}; // 25
|
|
// 26
|
|
if (self.ordered) { // 27
|
|
self.docs = new OrderedDict(LocalCollection._idStringify); // 28
|
|
self.applyChange = { // 29
|
|
addedBefore: function (id, fields, before) { // 30
|
|
var doc = EJSON.clone(fields); // 31
|
|
doc._id = id; // 32
|
|
callbacks.addedBefore && callbacks.addedBefore.call( // 33
|
|
self, id, fields, before); // 34
|
|
// This line triggers if we provide added with movedBefore. // 35
|
|
callbacks.added && callbacks.added.call(self, id, fields); // 36
|
|
// XXX could `before` be a falsy ID? Technically // 37
|
|
// idStringify seems to allow for them -- though // 38
|
|
// OrderedDict won't call stringify on a falsy arg. // 39
|
|
self.docs.putBefore(id, doc, before || null); // 40
|
|
}, // 41
|
|
movedBefore: function (id, before) { // 42
|
|
var doc = self.docs.get(id); // 43
|
|
callbacks.movedBefore && callbacks.movedBefore.call(self, id, before); // 44
|
|
self.docs.moveBefore(id, before || null); // 45
|
|
} // 46
|
|
}; // 47
|
|
} else { // 48
|
|
self.docs = new LocalCollection._IdMap; // 49
|
|
self.applyChange = { // 50
|
|
added: function (id, fields) { // 51
|
|
var doc = EJSON.clone(fields); // 52
|
|
callbacks.added && callbacks.added.call(self, id, fields); // 53
|
|
doc._id = id; // 54
|
|
self.docs.set(id, doc); // 55
|
|
} // 56
|
|
}; // 57
|
|
} // 58
|
|
// 59
|
|
// The methods in _IdMap and OrderedDict used by these callbacks are // 60
|
|
// identical. // 61
|
|
self.applyChange.changed = function (id, fields) { // 62
|
|
var doc = self.docs.get(id); // 63
|
|
if (!doc) // 64
|
|
throw new Error("Unknown id for changed: " + id); // 65
|
|
callbacks.changed && callbacks.changed.call( // 66
|
|
self, id, EJSON.clone(fields)); // 67
|
|
LocalCollection._applyChanges(doc, fields); // 68
|
|
}; // 69
|
|
self.applyChange.removed = function (id) { // 70
|
|
callbacks.removed && callbacks.removed.call(self, id); // 71
|
|
self.docs.remove(id); // 72
|
|
}; // 73
|
|
}; // 74
|
|
// 75
|
|
LocalCollection._observeFromObserveChanges = function (cursor, observeCallbacks) { // 76
|
|
var transform = cursor.getTransform() || function (doc) {return doc;}; // 77
|
|
var suppressed = !!observeCallbacks._suppress_initial; // 78
|
|
// 79
|
|
var observeChangesCallbacks; // 80
|
|
if (LocalCollection._observeCallbacksAreOrdered(observeCallbacks)) { // 81
|
|
// The "_no_indices" option sets all index arguments to -1 and skips the // 82
|
|
// linear scans required to generate them. This lets observers that don't // 83
|
|
// need absolute indices benefit from the other features of this API -- // 84
|
|
// relative order, transforms, and applyChanges -- without the speed hit. // 85
|
|
var indices = !observeCallbacks._no_indices; // 86
|
|
observeChangesCallbacks = { // 87
|
|
addedBefore: function (id, fields, before) { // 88
|
|
var self = this; // 89
|
|
if (suppressed || !(observeCallbacks.addedAt || observeCallbacks.added)) // 90
|
|
return; // 91
|
|
var doc = transform(_.extend(fields, {_id: id})); // 92
|
|
if (observeCallbacks.addedAt) { // 93
|
|
var index = indices // 94
|
|
? (before ? self.docs.indexOf(before) : self.docs.size()) : -1; // 95
|
|
observeCallbacks.addedAt(doc, index, before); // 96
|
|
} else { // 97
|
|
observeCallbacks.added(doc); // 98
|
|
} // 99
|
|
}, // 100
|
|
changed: function (id, fields) { // 101
|
|
var self = this; // 102
|
|
if (!(observeCallbacks.changedAt || observeCallbacks.changed)) // 103
|
|
return; // 104
|
|
var doc = EJSON.clone(self.docs.get(id)); // 105
|
|
if (!doc) // 106
|
|
throw new Error("Unknown id for changed: " + id); // 107
|
|
var oldDoc = transform(EJSON.clone(doc)); // 108
|
|
LocalCollection._applyChanges(doc, fields); // 109
|
|
doc = transform(doc); // 110
|
|
if (observeCallbacks.changedAt) { // 111
|
|
var index = indices ? self.docs.indexOf(id) : -1; // 112
|
|
observeCallbacks.changedAt(doc, oldDoc, index); // 113
|
|
} else { // 114
|
|
observeCallbacks.changed(doc, oldDoc); // 115
|
|
} // 116
|
|
}, // 117
|
|
movedBefore: function (id, before) { // 118
|
|
var self = this; // 119
|
|
if (!observeCallbacks.movedTo) // 120
|
|
return; // 121
|
|
var from = indices ? self.docs.indexOf(id) : -1; // 122
|
|
// 123
|
|
var to = indices // 124
|
|
? (before ? self.docs.indexOf(before) : self.docs.size()) : -1; // 125
|
|
// When not moving backwards, adjust for the fact that removing the // 126
|
|
// document slides everything back one slot. // 127
|
|
if (to > from) // 128
|
|
--to; // 129
|
|
observeCallbacks.movedTo(transform(EJSON.clone(self.docs.get(id))), // 130
|
|
from, to, before || null); // 131
|
|
}, // 132
|
|
removed: function (id) { // 133
|
|
var self = this; // 134
|
|
if (!(observeCallbacks.removedAt || observeCallbacks.removed)) // 135
|
|
return; // 136
|
|
// technically maybe there should be an EJSON.clone here, but it's about // 137
|
|
// to be removed from self.docs! // 138
|
|
var doc = transform(self.docs.get(id)); // 139
|
|
if (observeCallbacks.removedAt) { // 140
|
|
var index = indices ? self.docs.indexOf(id) : -1; // 141
|
|
observeCallbacks.removedAt(doc, index); // 142
|
|
} else { // 143
|
|
observeCallbacks.removed(doc); // 144
|
|
} // 145
|
|
} // 146
|
|
}; // 147
|
|
} else { // 148
|
|
observeChangesCallbacks = { // 149
|
|
added: function (id, fields) { // 150
|
|
if (!suppressed && observeCallbacks.added) { // 151
|
|
var doc = _.extend(fields, {_id: id}); // 152
|
|
observeCallbacks.added(transform(doc)); // 153
|
|
} // 154
|
|
}, // 155
|
|
changed: function (id, fields) { // 156
|
|
var self = this; // 157
|
|
if (observeCallbacks.changed) { // 158
|
|
var oldDoc = self.docs.get(id); // 159
|
|
var doc = EJSON.clone(oldDoc); // 160
|
|
LocalCollection._applyChanges(doc, fields); // 161
|
|
observeCallbacks.changed(transform(doc), // 162
|
|
transform(EJSON.clone(oldDoc))); // 163
|
|
} // 164
|
|
}, // 165
|
|
removed: function (id) { // 166
|
|
var self = this; // 167
|
|
if (observeCallbacks.removed) { // 168
|
|
observeCallbacks.removed(transform(self.docs.get(id))); // 169
|
|
} // 170
|
|
} // 171
|
|
}; // 172
|
|
} // 173
|
|
// 174
|
|
var changeObserver = new LocalCollection._CachingChangeObserver( // 175
|
|
{callbacks: observeChangesCallbacks}); // 176
|
|
var handle = cursor.observeChanges(changeObserver.applyChange); // 177
|
|
suppressed = false; // 178
|
|
// 179
|
|
return handle; // 180
|
|
}; // 181
|
|
// 182
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/minimongo/objectid.js //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
LocalCollection._looksLikeObjectID = function (str) { // 1
|
|
return str.length === 24 && str.match(/^[0-9a-f]*$/); // 2
|
|
}; // 3
|
|
// 4
|
|
LocalCollection._ObjectID = function (hexString) { // 5
|
|
//random-based impl of Mongo ObjectID // 6
|
|
var self = this; // 7
|
|
if (hexString) { // 8
|
|
hexString = hexString.toLowerCase(); // 9
|
|
if (!LocalCollection._looksLikeObjectID(hexString)) { // 10
|
|
throw new Error("Invalid hexadecimal string for creating an ObjectID"); // 11
|
|
} // 12
|
|
// meant to work with _.isEqual(), which relies on structural equality // 13
|
|
self._str = hexString; // 14
|
|
} else { // 15
|
|
self._str = Random.hexString(24); // 16
|
|
} // 17
|
|
}; // 18
|
|
// 19
|
|
LocalCollection._ObjectID.prototype.toString = function () { // 20
|
|
var self = this; // 21
|
|
return "ObjectID(\"" + self._str + "\")"; // 22
|
|
}; // 23
|
|
// 24
|
|
LocalCollection._ObjectID.prototype.equals = function (other) { // 25
|
|
var self = this; // 26
|
|
return other instanceof LocalCollection._ObjectID && // 27
|
|
self.valueOf() === other.valueOf(); // 28
|
|
}; // 29
|
|
// 30
|
|
LocalCollection._ObjectID.prototype.clone = function () { // 31
|
|
var self = this; // 32
|
|
return new LocalCollection._ObjectID(self._str); // 33
|
|
}; // 34
|
|
// 35
|
|
LocalCollection._ObjectID.prototype.typeName = function() { // 36
|
|
return "oid"; // 37
|
|
}; // 38
|
|
// 39
|
|
LocalCollection._ObjectID.prototype.getTimestamp = function() { // 40
|
|
var self = this; // 41
|
|
return parseInt(self._str.substr(0, 8), 16); // 42
|
|
}; // 43
|
|
// 44
|
|
LocalCollection._ObjectID.prototype.valueOf = // 45
|
|
LocalCollection._ObjectID.prototype.toJSONValue = // 46
|
|
LocalCollection._ObjectID.prototype.toHexString = // 47
|
|
function () { return this._str; }; // 48
|
|
// 49
|
|
// Is this selector just shorthand for lookup by _id? // 50
|
|
LocalCollection._selectorIsId = function (selector) { // 51
|
|
return (typeof selector === "string") || // 52
|
|
(typeof selector === "number") || // 53
|
|
selector instanceof LocalCollection._ObjectID; // 54
|
|
}; // 55
|
|
// 56
|
|
// Is the selector just lookup by _id (shorthand or not)? // 57
|
|
LocalCollection._selectorIsIdPerhapsAsObject = function (selector) { // 58
|
|
return LocalCollection._selectorIsId(selector) || // 59
|
|
(selector && typeof selector === "object" && // 60
|
|
selector._id && LocalCollection._selectorIsId(selector._id) && // 61
|
|
_.size(selector) === 1); // 62
|
|
}; // 63
|
|
// 64
|
|
// If this is a selector which explicitly constrains the match by ID to a finite // 65
|
|
// number of documents, returns a list of their IDs. Otherwise returns // 66
|
|
// null. Note that the selector may have other restrictions so it may not even // 67
|
|
// match those document! We care about $in and $and since those are generated // 68
|
|
// access-controlled update and remove. // 69
|
|
LocalCollection._idsMatchedBySelector = function (selector) { // 70
|
|
// Is the selector just an ID? // 71
|
|
if (LocalCollection._selectorIsId(selector)) // 72
|
|
return [selector]; // 73
|
|
if (!selector) // 74
|
|
return null; // 75
|
|
// 76
|
|
// Do we have an _id clause? // 77
|
|
if (_.has(selector, '_id')) { // 78
|
|
// Is the _id clause just an ID? // 79
|
|
if (LocalCollection._selectorIsId(selector._id)) // 80
|
|
return [selector._id]; // 81
|
|
// Is the _id clause {_id: {$in: ["x", "y", "z"]}}? // 82
|
|
if (selector._id && selector._id.$in // 83
|
|
&& _.isArray(selector._id.$in) // 84
|
|
&& !_.isEmpty(selector._id.$in) // 85
|
|
&& _.all(selector._id.$in, LocalCollection._selectorIsId)) { // 86
|
|
return selector._id.$in; // 87
|
|
} // 88
|
|
return null; // 89
|
|
} // 90
|
|
// 91
|
|
// If this is a top-level $and, and any of the clauses constrain their // 92
|
|
// documents, then the whole selector is constrained by any one clause's // 93
|
|
// constraint. (Well, by their intersection, but that seems unlikely.) // 94
|
|
if (selector.$and && _.isArray(selector.$and)) { // 95
|
|
for (var i = 0; i < selector.$and.length; ++i) { // 96
|
|
var subIds = LocalCollection._idsMatchedBySelector(selector.$and[i]); // 97
|
|
if (subIds) // 98
|
|
return subIds; // 99
|
|
} // 100
|
|
} // 101
|
|
// 102
|
|
return null; // 103
|
|
}; // 104
|
|
// 105
|
|
EJSON.addType("oid", function (str) { // 106
|
|
return new LocalCollection._ObjectID(str); // 107
|
|
}); // 108
|
|
// 109
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
/* Exports */
|
|
if (typeof Package === 'undefined') Package = {};
|
|
Package.minimongo = {
|
|
LocalCollection: LocalCollection,
|
|
Minimongo: Minimongo,
|
|
MinimongoTest: MinimongoTest
|
|
};
|
|
|
|
})();
|