//////////////////////////////////////////////////////////////////////////
// //
// 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 EJSON = Package.ejson.EJSON;
/* Package-scope variables */
var check, Match;
(function () {
///////////////////////////////////////////////////////////////////////////////////
// //
// packages/check/match.js //
// //
///////////////////////////////////////////////////////////////////////////////////
//
// XXX docs // 1
// 2
// Things we explicitly do NOT support: // 3
// - heterogenous arrays // 4
// 5
var currentArgumentChecker = new Meteor.EnvironmentVariable; // 6
// 7
/** // 8
* @summary Check that a value matches a [pattern](#matchpatterns). // 9
* If the value does not match the pattern, throw a `Match.Error`. // 10
* // 11
* Particularly useful to assert that arguments to a function have the right // 12
* types and structure. // 13
* @locus Anywhere // 14
* @param {Any} value The value to check // 15
* @param {MatchPattern} pattern The pattern to match // 16
* `value` against // 17
*/ // 18
check = function (value, pattern) { // 19
// Record that check got called, if somebody cared. // 20
// // 21
// We use getOrNullIfOutsideFiber so that it's OK to call check() // 22
// from non-Fiber server contexts; the downside is that if you forget to // 23
// bindEnvironment on some random callback in your method/publisher, // 24
// it might not find the argumentChecker and you'll get an error about // 25
// not checking an argument that it looks like you're checking (instead // 26
// of just getting a "Node code must run in a Fiber" error). // 27
var argChecker = currentArgumentChecker.getOrNullIfOutsideFiber(); // 28
if (argChecker) // 29
argChecker.checking(value); // 30
try { // 31
checkSubtree(value, pattern); // 32
} catch (err) { // 33
if ((err instanceof Match.Error) && err.path) // 34
err.message += " in field " + err.path; // 35
throw err; // 36
} // 37
}; // 38
// 39
/** // 40
* @namespace Match // 41
* @summary The namespace for all Match types and methods. // 42
*/ // 43
Match = { // 44
Optional: function (pattern) { // 45
return new Optional(pattern); // 46
}, // 47
OneOf: function (/*arguments*/) { // 48
return new OneOf(_.toArray(arguments)); // 49
}, // 50
Any: ['__any__'], // 51
Where: function (condition) { // 52
return new Where(condition); // 53
}, // 54
ObjectIncluding: function (pattern) { // 55
return new ObjectIncluding(pattern); // 56
}, // 57
ObjectWithValues: function (pattern) { // 58
return new ObjectWithValues(pattern); // 59
}, // 60
// Matches only signed 32-bit integers // 61
Integer: ['__integer__'], // 62
// 63
// XXX matchers should know how to describe themselves for errors // 64
Error: Meteor.makeErrorType("Match.Error", function (msg) { // 65
this.message = "Match error: " + msg; // 66
// The path of the value that failed to match. Initially empty, this gets // 67
// populated by catching and rethrowing the exception as it goes back up the // 68
// stack. // 69
// E.g.: "vals[3].entity.created" // 70
this.path = ""; // 71
// If this gets sent over DDP, don't give full internal details but at least // 72
// provide something better than 500 Internal server error. // 73
this.sanitizedError = new Meteor.Error(400, "Match failed"); // 74
}), // 75
// 76
// Tests to see if value matches pattern. Unlike check, it merely returns true // 77
// or false (unless an error other than Match.Error was thrown). It does not // 78
// interact with _failIfArgumentsAreNotAllChecked. // 79
// XXX maybe also implement a Match.match which returns more information about // 80
// failures but without using exception handling or doing what check() // 81
// does with _failIfArgumentsAreNotAllChecked and Meteor.Error conversion // 82
// 83
/** // 84
* @summary Returns true if the value matches the pattern. // 85
* @locus Anywhere // 86
* @param {Any} value The value to check // 87
* @param {MatchPattern} pattern The pattern to match `value` against // 88
*/ // 89
test: function (value, pattern) { // 90
try { // 91
checkSubtree(value, pattern); // 92
return true; // 93
} catch (e) { // 94
if (e instanceof Match.Error) // 95
return false; // 96
// Rethrow other errors. // 97
throw e; // 98
} // 99
}, // 100
// 101
// Runs `f.apply(context, args)`. If check() is not called on every element of // 102
// `args` (either directly or in the first level of an array), throws an error // 103
// (using `description` in the message). // 104
// // 105
_failIfArgumentsAreNotAllChecked: function (f, context, args, description) { // 106
var argChecker = new ArgumentChecker(args, description); // 107
var result = currentArgumentChecker.withValue(argChecker, function () { // 108
return f.apply(context, args); // 109
}); // 110
// If f didn't itself throw, make sure it checked all of its arguments. // 111
argChecker.throwUnlessAllArgumentsHaveBeenChecked(); // 112
return result; // 113
} // 114
}; // 115
// 116
var Optional = function (pattern) { // 117
this.pattern = pattern; // 118
}; // 119
// 120
var OneOf = function (choices) { // 121
if (_.isEmpty(choices)) // 122
throw new Error("Must provide at least one choice to Match.OneOf"); // 123
this.choices = choices; // 124
}; // 125
// 126
var Where = function (condition) { // 127
this.condition = condition; // 128
}; // 129
// 130
var ObjectIncluding = function (pattern) { // 131
this.pattern = pattern; // 132
}; // 133
// 134
var ObjectWithValues = function (pattern) { // 135
this.pattern = pattern; // 136
}; // 137
// 138
var typeofChecks = [ // 139
[String, "string"], // 140
[Number, "number"], // 141
[Boolean, "boolean"], // 142
// While we don't allow undefined in EJSON, this is good for optional // 143
// arguments with OneOf. // 144
[undefined, "undefined"] // 145
]; // 146
// 147
var checkSubtree = function (value, pattern) { // 148
// Match anything! // 149
if (pattern === Match.Any) // 150
return; // 151
// 152
// Basic atomic types. // 153
// Do not match boxed objects (e.g. String, Boolean) // 154
for (var i = 0; i < typeofChecks.length; ++i) { // 155
if (pattern === typeofChecks[i][0]) { // 156
if (typeof value === typeofChecks[i][1]) // 157
return; // 158
throw new Match.Error("Expected " + typeofChecks[i][1] + ", got " + // 159
typeof value); // 160
} // 161
} // 162
if (pattern === null) { // 163
if (value === null) // 164
return; // 165
throw new Match.Error("Expected null, got " + EJSON.stringify(value)); // 166
} // 167
// 168
// Strings and numbers match literally. Goes well with Match.OneOf. // 169
if (typeof pattern === "string" || typeof pattern === "number") { // 170
if (value === pattern) // 171
return; // 172
throw new Match.Error("Expected " + pattern + ", got " + // 173
EJSON.stringify(value)); // 174
} // 175
// 176
// Match.Integer is special type encoded with array // 177
if (pattern === Match.Integer) { // 178
// There is no consistent and reliable way to check if variable is a 64-bit // 179
// integer. One of the popular solutions is to get reminder of division by 1 // 180
// but this method fails on really large floats with big precision. // 181
// E.g.: 1.348192308491824e+23 % 1 === 0 in V8 // 182
// Bitwise operators work consistantly but always cast variable to 32-bit // 183
// signed integer according to JavaScript specs. // 184
if (typeof value === "number" && (value | 0) === value) // 185
return // 186
throw new Match.Error("Expected Integer, got " // 187
+ (value instanceof Object ? EJSON.stringify(value) : value)); // 188
} // 189
// 190
// "Object" is shorthand for Match.ObjectIncluding({}); // 191
if (pattern === Object) // 192
pattern = Match.ObjectIncluding({}); // 193
// 194
// Array (checked AFTER Any, which is implemented as an Array). // 195
if (pattern instanceof Array) { // 196
if (pattern.length !== 1) // 197
throw Error("Bad pattern: arrays must have one type element" + // 198
EJSON.stringify(pattern)); // 199
if (!_.isArray(value) && !_.isArguments(value)) { // 200
throw new Match.Error("Expected array, got " + EJSON.stringify(value)); // 201
} // 202
// 203
_.each(value, function (valueElement, index) { // 204
try { // 205
checkSubtree(valueElement, pattern[0]); // 206
} catch (err) { // 207
if (err instanceof Match.Error) { // 208
err.path = _prependPath(index, err.path); // 209
} // 210
throw err; // 211
} // 212
}); // 213
return; // 214
} // 215
// 216
// Arbitrary validation checks. The condition can return false or throw a // 217
// Match.Error (ie, it can internally use check()) to fail. // 218
if (pattern instanceof Where) { // 219
if (pattern.condition(value)) // 220
return; // 221
// XXX this error is terrible // 222
throw new Match.Error("Failed Match.Where validation"); // 223
} // 224
// 225
// 226
if (pattern instanceof Optional) // 227
pattern = Match.OneOf(undefined, pattern.pattern); // 228
// 229
if (pattern instanceof OneOf) { // 230
for (var i = 0; i < pattern.choices.length; ++i) { // 231
try { // 232
checkSubtree(value, pattern.choices[i]); // 233
// No error? Yay, return. // 234
return; // 235
} catch (err) { // 236
// Other errors should be thrown. Match errors just mean try another // 237
// choice. // 238
if (!(err instanceof Match.Error)) // 239
throw err; // 240
} // 241
} // 242
// XXX this error is terrible // 243
throw new Match.Error("Failed Match.OneOf or Match.Optional validation"); // 244
} // 245
// 246
// A function that isn't something we special-case is assumed to be a // 247
// constructor. // 248
if (pattern instanceof Function) { // 249
if (value instanceof pattern) // 250
return; // 251
throw new Match.Error("Expected " + (pattern.name || // 252
"particular constructor")); // 253
} // 254
// 255
var unknownKeysAllowed = false; // 256
var unknownKeyPattern; // 257
if (pattern instanceof ObjectIncluding) { // 258
unknownKeysAllowed = true; // 259
pattern = pattern.pattern; // 260
} // 261
if (pattern instanceof ObjectWithValues) { // 262
unknownKeysAllowed = true; // 263
unknownKeyPattern = [pattern.pattern]; // 264
pattern = {}; // no required keys // 265
} // 266
// 267
if (typeof pattern !== "object") // 268
throw Error("Bad pattern: unknown pattern type"); // 269
// 270
// An object, with required and optional keys. Note that this does NOT do // 271
// structural matches against objects of special types that happen to match // 272
// the pattern: this really needs to be a plain old {Object}! // 273
if (typeof value !== 'object') // 274
throw new Match.Error("Expected object, got " + typeof value); // 275
if (value === null) // 276
throw new Match.Error("Expected object, got null"); // 277
if (value.constructor !== Object) // 278
throw new Match.Error("Expected plain object"); // 279
// 280
var requiredPatterns = {}; // 281
var optionalPatterns = {}; // 282
_.each(pattern, function (subPattern, key) { // 283
if (subPattern instanceof Optional) // 284
optionalPatterns[key] = subPattern.pattern; // 285
else // 286
requiredPatterns[key] = subPattern; // 287
}); // 288
// 289
_.each(value, function (subValue, key) { // 290
try { // 291
if (_.has(requiredPatterns, key)) { // 292
checkSubtree(subValue, requiredPatterns[key]); // 293
delete requiredPatterns[key]; // 294
} else if (_.has(optionalPatterns, key)) { // 295
checkSubtree(subValue, optionalPatterns[key]); // 296
} else { // 297
if (!unknownKeysAllowed) // 298
throw new Match.Error("Unknown key"); // 299
if (unknownKeyPattern) { // 300
checkSubtree(subValue, unknownKeyPattern[0]); // 301
} // 302
} // 303
} catch (err) { // 304
if (err instanceof Match.Error) // 305
err.path = _prependPath(key, err.path); // 306
throw err; // 307
} // 308
}); // 309
// 310
_.each(requiredPatterns, function (subPattern, key) { // 311
throw new Match.Error("Missing key '" + key + "'"); // 312
}); // 313
}; // 314
// 315
var ArgumentChecker = function (args, description) { // 316
var self = this; // 317
// Make a SHALLOW copy of the arguments. (We'll be doing identity checks // 318
// against its contents.) // 319
self.args = _.clone(args); // 320
// Since the common case will be to check arguments in order, and we splice // 321
// out arguments when we check them, make it so we splice out from the end // 322
// rather than the beginning. // 323
self.args.reverse(); // 324
self.description = description; // 325
}; // 326
// 327
_.extend(ArgumentChecker.prototype, { // 328
checking: function (value) { // 329
var self = this; // 330
if (self._checkingOneValue(value)) // 331
return; // 332
// Allow check(arguments, [String]) or check(arguments.slice(1), [String]) // 333
// or check([foo, bar], [String]) to count... but only if value wasn't // 334
// itself an argument. // 335
if (_.isArray(value) || _.isArguments(value)) { // 336
_.each(value, _.bind(self._checkingOneValue, self)); // 337
} // 338
}, // 339
_checkingOneValue: function (value) { // 340
var self = this; // 341
for (var i = 0; i < self.args.length; ++i) { // 342
// Is this value one of the arguments? (This can have a false positive if // 343
// the argument is an interned primitive, but it's still a good enough // 344
// check.) // 345
// (NaN is not === to itself, so we have to check specially.) // 346
if (value === self.args[i] || (_.isNaN(value) && _.isNaN(self.args[i]))) { // 347
self.args.splice(i, 1); // 348
return true; // 349
} // 350
} // 351
return false; // 352
}, // 353
throwUnlessAllArgumentsHaveBeenChecked: function () { // 354
var self = this; // 355
if (!_.isEmpty(self.args)) // 356
throw new Error("Did not check() all arguments during " + // 357
self.description); // 358
} // 359
}); // 360
// 361
var _jsKeywords = ["do", "if", "in", "for", "let", "new", "try", "var", "case", // 362
"else", "enum", "eval", "false", "null", "this", "true", "void", "with", // 363
"break", "catch", "class", "const", "super", "throw", "while", "yield", // 364
"delete", "export", "import", "public", "return", "static", "switch", // 365
"typeof", "default", "extends", "finally", "package", "private", "continue", // 366
"debugger", "function", "arguments", "interface", "protected", "implements", // 367
"instanceof"]; // 368
// 369
// Assumes the base of path is already escaped properly // 370
// returns key + base // 371
var _prependPath = function (key, base) { // 372
if ((typeof key) === "number" || key.match(/^[0-9]+$/)) // 373
key = "[" + key + "]"; // 374
else if (!key.match(/^[a-z_$][0-9a-z_$]*$/i) || _.contains(_jsKeywords, key)) // 375
key = JSON.stringify([key]); // 376
// 377
if (base && base[0] !== "[") // 378
return key + '.' + base; // 379
return key + base; // 380
}; // 381
// 382
// 383
///////////////////////////////////////////////////////////////////////////////////
}).call(this);
/* Exports */
if (typeof Package === 'undefined') Package = {};
Package.check = {
check: check,
Match: Match
};
})();