1191 lines
108 KiB
JavaScript
1191 lines
108 KiB
JavaScript
(function () {
|
|
|
|
/* Imports */
|
|
var Meteor = Package.meteor.Meteor;
|
|
var HTML = Package.htmljs.HTML;
|
|
var HTMLTools = Package['html-tools'].HTMLTools;
|
|
var BlazeTools = Package['blaze-tools'].BlazeTools;
|
|
var _ = Package.underscore._;
|
|
|
|
/* Package-scope variables */
|
|
var SpacebarsCompiler, TemplateTag;
|
|
|
|
(function () {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/spacebars-compiler/templatetag.js //
|
|
// //
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
SpacebarsCompiler = {}; // 1
|
|
// 2
|
|
// A TemplateTag is the result of parsing a single `{{...}}` tag. // 3
|
|
// // 4
|
|
// The `.type` of a TemplateTag is one of: // 5
|
|
// // 6
|
|
// - `"DOUBLE"` - `{{foo}}` // 7
|
|
// - `"TRIPLE"` - `{{{foo}}}` // 8
|
|
// - `"COMMENT"` - `{{! foo}}` // 9
|
|
// - `"BLOCKCOMMENT" - `{{!-- foo--}}` // 10
|
|
// - `"INCLUSION"` - `{{> foo}}` // 11
|
|
// - `"BLOCKOPEN"` - `{{#foo}}` // 12
|
|
// - `"BLOCKCLOSE"` - `{{/foo}}` // 13
|
|
// - `"ELSE"` - `{{else}}` // 14
|
|
// - `"ESCAPE"` - `{{|`, `{{{|`, `{{{{|` and so on // 15
|
|
// // 16
|
|
// Besides `type`, the mandatory properties of a TemplateTag are: // 17
|
|
// // 18
|
|
// - `path` - An array of one or more strings. The path of `{{foo.bar}}` // 19
|
|
// is `["foo", "bar"]`. Applies to DOUBLE, TRIPLE, INCLUSION, BLOCKOPEN, // 20
|
|
// and BLOCKCLOSE. // 21
|
|
// // 22
|
|
// - `args` - An array of zero or more argument specs. An argument spec // 23
|
|
// is a two or three element array, consisting of a type, value, and // 24
|
|
// optional keyword name. For example, the `args` of `{{foo "bar" x=3}}` // 25
|
|
// are `[["STRING", "bar"], ["NUMBER", 3, "x"]]`. Applies to DOUBLE, // 26
|
|
// TRIPLE, INCLUSION, and BLOCKOPEN. // 27
|
|
// // 28
|
|
// - `value` - A string of the comment's text. Applies to COMMENT and // 29
|
|
// BLOCKCOMMENT. // 30
|
|
// // 31
|
|
// These additional are typically set during parsing: // 32
|
|
// // 33
|
|
// - `position` - The HTMLTools.TEMPLATE_TAG_POSITION specifying at what sort // 34
|
|
// of site the TemplateTag was encountered (e.g. at element level or as // 35
|
|
// part of an attribute value). Its absence implies // 36
|
|
// TEMPLATE_TAG_POSITION.ELEMENT. // 37
|
|
// // 38
|
|
// - `content` and `elseContent` - When a BLOCKOPEN tag's contents are // 39
|
|
// parsed, they are put here. `elseContent` will only be present if // 40
|
|
// an `{{else}}` was found. // 41
|
|
// 42
|
|
var TEMPLATE_TAG_POSITION = HTMLTools.TEMPLATE_TAG_POSITION; // 43
|
|
// 44
|
|
TemplateTag = SpacebarsCompiler.TemplateTag = function () { // 45
|
|
HTMLTools.TemplateTag.apply(this, arguments); // 46
|
|
}; // 47
|
|
TemplateTag.prototype = new HTMLTools.TemplateTag; // 48
|
|
TemplateTag.prototype.constructorName = 'SpacebarsCompiler.TemplateTag'; // 49
|
|
// 50
|
|
var makeStacheTagStartRegex = function (r) { // 51
|
|
return new RegExp(r.source + /(?![{>!#/])/.source, // 52
|
|
r.ignoreCase ? 'i' : ''); // 53
|
|
}; // 54
|
|
// 55
|
|
// "starts" regexes are used to see what type of template // 56
|
|
// tag the parser is looking at. They must match a non-empty // 57
|
|
// result, but not the interesting part of the tag. // 58
|
|
var starts = { // 59
|
|
ESCAPE: /^\{\{(?=\{*\|)/, // 60
|
|
ELSE: makeStacheTagStartRegex(/^\{\{\s*else(?=[\s}])/i), // 61
|
|
DOUBLE: makeStacheTagStartRegex(/^\{\{\s*(?!\s)/), // 62
|
|
TRIPLE: makeStacheTagStartRegex(/^\{\{\{\s*(?!\s)/), // 63
|
|
BLOCKCOMMENT: makeStacheTagStartRegex(/^\{\{\s*!--/), // 64
|
|
COMMENT: makeStacheTagStartRegex(/^\{\{\s*!/), // 65
|
|
INCLUSION: makeStacheTagStartRegex(/^\{\{\s*>\s*(?!\s)/), // 66
|
|
BLOCKOPEN: makeStacheTagStartRegex(/^\{\{\s*#\s*(?!\s)/), // 67
|
|
BLOCKCLOSE: makeStacheTagStartRegex(/^\{\{\s*\/\s*(?!\s)/) // 68
|
|
}; // 69
|
|
// 70
|
|
var ends = { // 71
|
|
DOUBLE: /^\s*\}\}/, // 72
|
|
TRIPLE: /^\s*\}\}\}/ // 73
|
|
}; // 74
|
|
// 75
|
|
// Parse a tag from the provided scanner or string. If the input // 76
|
|
// doesn't start with `{{`, returns null. Otherwise, either succeeds // 77
|
|
// and returns a SpacebarsCompiler.TemplateTag, or throws an error (using // 78
|
|
// `scanner.fatal` if a scanner is provided). // 79
|
|
TemplateTag.parse = function (scannerOrString) { // 80
|
|
var scanner = scannerOrString; // 81
|
|
if (typeof scanner === 'string') // 82
|
|
scanner = new HTMLTools.Scanner(scannerOrString); // 83
|
|
// 84
|
|
if (! (scanner.peek() === '{' && // 85
|
|
(scanner.rest()).slice(0, 2) === '{{')) // 86
|
|
return null; // 87
|
|
// 88
|
|
var run = function (regex) { // 89
|
|
// regex is assumed to start with `^` // 90
|
|
var result = regex.exec(scanner.rest()); // 91
|
|
if (! result) // 92
|
|
return null; // 93
|
|
var ret = result[0]; // 94
|
|
scanner.pos += ret.length; // 95
|
|
return ret; // 96
|
|
}; // 97
|
|
// 98
|
|
var advance = function (amount) { // 99
|
|
scanner.pos += amount; // 100
|
|
}; // 101
|
|
// 102
|
|
var scanIdentifier = function (isFirstInPath) { // 103
|
|
var id = BlazeTools.parseIdentifierName(scanner); // 104
|
|
if (! id) // 105
|
|
expected('IDENTIFIER'); // 106
|
|
if (isFirstInPath && // 107
|
|
(id === 'null' || id === 'true' || id === 'false')) // 108
|
|
scanner.fatal("Can't use null, true, or false, as an identifier at start of path"); // 109
|
|
// 110
|
|
return id; // 111
|
|
}; // 112
|
|
// 113
|
|
var scanPath = function () { // 114
|
|
var segments = []; // 115
|
|
// 116
|
|
// handle initial `.`, `..`, `./`, `../`, `../..`, `../../`, etc // 117
|
|
var dots; // 118
|
|
if ((dots = run(/^[\.\/]+/))) { // 119
|
|
var ancestorStr = '.'; // eg `../../..` maps to `....` // 120
|
|
var endsWithSlash = /\/$/.test(dots); // 121
|
|
// 122
|
|
if (endsWithSlash) // 123
|
|
dots = dots.slice(0, -1); // 124
|
|
// 125
|
|
_.each(dots.split('/'), function(dotClause, index) { // 126
|
|
if (index === 0) { // 127
|
|
if (dotClause !== '.' && dotClause !== '..') // 128
|
|
expected("`.`, `..`, `./` or `../`"); // 129
|
|
} else { // 130
|
|
if (dotClause !== '..') // 131
|
|
expected("`..` or `../`"); // 132
|
|
} // 133
|
|
// 134
|
|
if (dotClause === '..') // 135
|
|
ancestorStr += '.'; // 136
|
|
}); // 137
|
|
// 138
|
|
segments.push(ancestorStr); // 139
|
|
// 140
|
|
if (!endsWithSlash) // 141
|
|
return segments; // 142
|
|
} // 143
|
|
// 144
|
|
while (true) { // 145
|
|
// scan a path segment // 146
|
|
// 147
|
|
if (run(/^\[/)) { // 148
|
|
var seg = run(/^[\s\S]*?\]/); // 149
|
|
if (! seg) // 150
|
|
error("Unterminated path segment"); // 151
|
|
seg = seg.slice(0, -1); // 152
|
|
if (! seg && ! segments.length) // 153
|
|
error("Path can't start with empty string"); // 154
|
|
segments.push(seg); // 155
|
|
} else { // 156
|
|
var id = scanIdentifier(! segments.length); // 157
|
|
if (id === 'this') { // 158
|
|
if (! segments.length) { // 159
|
|
// initial `this` // 160
|
|
segments.push('.'); // 161
|
|
} else { // 162
|
|
error("Can only use `this` at the beginning of a path.\nInstead of `foo.this` or `../this`, just write `foo` or `..`.");
|
|
} // 164
|
|
} else { // 165
|
|
segments.push(id); // 166
|
|
} // 167
|
|
} // 168
|
|
// 169
|
|
var sep = run(/^[\.\/]/); // 170
|
|
if (! sep) // 171
|
|
break; // 172
|
|
} // 173
|
|
// 174
|
|
return segments; // 175
|
|
}; // 176
|
|
// 177
|
|
// scan the keyword portion of a keyword argument // 178
|
|
// (the "foo" portion in "foo=bar"). // 179
|
|
// Result is either the keyword matched, or null // 180
|
|
// if we're not at a keyword argument position. // 181
|
|
var scanArgKeyword = function () { // 182
|
|
var match = /^([^\{\}\(\)\>#=\s"'\[\]]+)\s*=\s*/.exec(scanner.rest()); // 183
|
|
if (match) { // 184
|
|
scanner.pos += match[0].length; // 185
|
|
return match[1]; // 186
|
|
} else { // 187
|
|
return null; // 188
|
|
} // 189
|
|
}; // 190
|
|
// 191
|
|
// scan an argument; succeeds or errors. // 192
|
|
// Result is an array of two or three items: // 193
|
|
// type , value, and (indicating a keyword argument) // 194
|
|
// keyword name. // 195
|
|
var scanArg = function () { // 196
|
|
var keyword = scanArgKeyword(); // null if not parsing a kwarg // 197
|
|
var value = scanArgValue(); // 198
|
|
return keyword ? value.concat(keyword) : value; // 199
|
|
}; // 200
|
|
// 201
|
|
// scan an argument value (for keyword or positional arguments); // 202
|
|
// succeeds or errors. Result is an array of type, value. // 203
|
|
var scanArgValue = function () { // 204
|
|
var startPos = scanner.pos; // 205
|
|
var result; // 206
|
|
if ((result = BlazeTools.parseNumber(scanner))) { // 207
|
|
return ['NUMBER', result.value]; // 208
|
|
} else if ((result = BlazeTools.parseStringLiteral(scanner))) { // 209
|
|
return ['STRING', result.value]; // 210
|
|
} else if (/^[\.\[]/.test(scanner.peek())) { // 211
|
|
return ['PATH', scanPath()]; // 212
|
|
} else if ((result = BlazeTools.parseIdentifierName(scanner))) { // 213
|
|
var id = result; // 214
|
|
if (id === 'null') { // 215
|
|
return ['NULL', null]; // 216
|
|
} else if (id === 'true' || id === 'false') { // 217
|
|
return ['BOOLEAN', id === 'true']; // 218
|
|
} else { // 219
|
|
scanner.pos = startPos; // unconsume `id` // 220
|
|
return ['PATH', scanPath()]; // 221
|
|
} // 222
|
|
} else { // 223
|
|
expected('identifier, number, string, boolean, or null'); // 224
|
|
} // 225
|
|
}; // 226
|
|
// 227
|
|
var type; // 228
|
|
// 229
|
|
var error = function (msg) { // 230
|
|
scanner.fatal(msg); // 231
|
|
}; // 232
|
|
// 233
|
|
var expected = function (what) { // 234
|
|
error('Expected ' + what); // 235
|
|
}; // 236
|
|
// 237
|
|
// must do ESCAPE first, immediately followed by ELSE // 238
|
|
// order of others doesn't matter // 239
|
|
if (run(starts.ESCAPE)) type = 'ESCAPE'; // 240
|
|
else if (run(starts.ELSE)) type = 'ELSE'; // 241
|
|
else if (run(starts.DOUBLE)) type = 'DOUBLE'; // 242
|
|
else if (run(starts.TRIPLE)) type = 'TRIPLE'; // 243
|
|
else if (run(starts.BLOCKCOMMENT)) type = 'BLOCKCOMMENT'; // 244
|
|
else if (run(starts.COMMENT)) type = 'COMMENT'; // 245
|
|
else if (run(starts.INCLUSION)) type = 'INCLUSION'; // 246
|
|
else if (run(starts.BLOCKOPEN)) type = 'BLOCKOPEN'; // 247
|
|
else if (run(starts.BLOCKCLOSE)) type = 'BLOCKCLOSE'; // 248
|
|
else // 249
|
|
error('Unknown stache tag'); // 250
|
|
// 251
|
|
var tag = new TemplateTag; // 252
|
|
tag.type = type; // 253
|
|
// 254
|
|
if (type === 'BLOCKCOMMENT') { // 255
|
|
var result = run(/^[\s\S]*?--\s*?\}\}/); // 256
|
|
if (! result) // 257
|
|
error("Unclosed block comment"); // 258
|
|
tag.value = result.slice(0, result.lastIndexOf('--')); // 259
|
|
} else if (type === 'COMMENT') { // 260
|
|
var result = run(/^[\s\S]*?\}\}/); // 261
|
|
if (! result) // 262
|
|
error("Unclosed comment"); // 263
|
|
tag.value = result.slice(0, -2); // 264
|
|
} else if (type === 'BLOCKCLOSE') { // 265
|
|
tag.path = scanPath(); // 266
|
|
if (! run(ends.DOUBLE)) // 267
|
|
expected('`}}`'); // 268
|
|
} else if (type === 'ELSE') { // 269
|
|
if (! run(ends.DOUBLE)) // 270
|
|
expected('`}}`'); // 271
|
|
} else if (type === 'ESCAPE') { // 272
|
|
var result = run(/^\{*\|/); // 273
|
|
tag.value = '{{' + result.slice(0, -1); // 274
|
|
} else { // 275
|
|
// DOUBLE, TRIPLE, BLOCKOPEN, INCLUSION // 276
|
|
tag.path = scanPath(); // 277
|
|
tag.args = []; // 278
|
|
var foundKwArg = false; // 279
|
|
while (true) { // 280
|
|
run(/^\s*/); // 281
|
|
if (type === 'TRIPLE') { // 282
|
|
if (run(ends.TRIPLE)) // 283
|
|
break; // 284
|
|
else if (scanner.peek() === '}') // 285
|
|
expected('`}}}`'); // 286
|
|
} else { // 287
|
|
if (run(ends.DOUBLE)) // 288
|
|
break; // 289
|
|
else if (scanner.peek() === '}') // 290
|
|
expected('`}}`'); // 291
|
|
} // 292
|
|
var newArg = scanArg(); // 293
|
|
if (newArg.length === 3) { // 294
|
|
foundKwArg = true; // 295
|
|
} else { // 296
|
|
if (foundKwArg) // 297
|
|
error("Can't have a non-keyword argument after a keyword argument"); // 298
|
|
} // 299
|
|
tag.args.push(newArg); // 300
|
|
// 301
|
|
if (run(/^(?=[\s}])/) !== '') // 302
|
|
expected('space'); // 303
|
|
} // 304
|
|
} // 305
|
|
// 306
|
|
return tag; // 307
|
|
}; // 308
|
|
// 309
|
|
// Returns a SpacebarsCompiler.TemplateTag parsed from `scanner`, leaving scanner // 310
|
|
// at its original position. // 311
|
|
// // 312
|
|
// An error will still be thrown if there is not a valid template tag at // 313
|
|
// the current position. // 314
|
|
TemplateTag.peek = function (scanner) { // 315
|
|
var startPos = scanner.pos; // 316
|
|
var result = TemplateTag.parse(scanner); // 317
|
|
scanner.pos = startPos; // 318
|
|
return result; // 319
|
|
}; // 320
|
|
// 321
|
|
// Like `TemplateTag.parse`, but in the case of blocks, parse the complete // 322
|
|
// `{{#foo}}...{{/foo}}` with `content` and possible `elseContent`, rather // 323
|
|
// than just the BLOCKOPEN tag. // 324
|
|
// // 325
|
|
// In addition: // 326
|
|
// // 327
|
|
// - Throws an error if `{{else}}` or `{{/foo}}` tag is encountered. // 328
|
|
// // 329
|
|
// - Returns `null` for a COMMENT. (This case is distinguishable from // 330
|
|
// parsing no tag by the fact that the scanner is advanced.) // 331
|
|
// // 332
|
|
// - Takes an HTMLTools.TEMPLATE_TAG_POSITION `position` and sets it as the // 333
|
|
// TemplateTag's `.position` property. // 334
|
|
// // 335
|
|
// - Validates the tag's well-formedness and legality at in its position. // 336
|
|
TemplateTag.parseCompleteTag = function (scannerOrString, position) { // 337
|
|
var scanner = scannerOrString; // 338
|
|
if (typeof scanner === 'string') // 339
|
|
scanner = new HTMLTools.Scanner(scannerOrString); // 340
|
|
// 341
|
|
var startPos = scanner.pos; // for error messages // 342
|
|
var result = TemplateTag.parse(scannerOrString); // 343
|
|
if (! result) // 344
|
|
return result; // 345
|
|
// 346
|
|
if (result.type === 'BLOCKCOMMENT') // 347
|
|
return null; // 348
|
|
// 349
|
|
if (result.type === 'COMMENT') // 350
|
|
return null; // 351
|
|
// 352
|
|
if (result.type === 'ELSE') // 353
|
|
scanner.fatal("Unexpected {{else}}"); // 354
|
|
// 355
|
|
if (result.type === 'BLOCKCLOSE') // 356
|
|
scanner.fatal("Unexpected closing template tag"); // 357
|
|
// 358
|
|
position = (position || TEMPLATE_TAG_POSITION.ELEMENT); // 359
|
|
if (position !== TEMPLATE_TAG_POSITION.ELEMENT) // 360
|
|
result.position = position; // 361
|
|
// 362
|
|
if (result.type === 'BLOCKOPEN') { // 363
|
|
// parse block contents // 364
|
|
// 365
|
|
// Construct a string version of `.path` for comparing start and // 366
|
|
// end tags. For example, `foo/[0]` was parsed into `["foo", "0"]` // 367
|
|
// and now becomes `foo,0`. This form may also show up in error // 368
|
|
// messages. // 369
|
|
var blockName = result.path.join(','); // 370
|
|
// 371
|
|
var textMode = null; // 372
|
|
if (blockName === 'markdown' || // 373
|
|
position === TEMPLATE_TAG_POSITION.IN_RAWTEXT) { // 374
|
|
textMode = HTML.TEXTMODE.STRING; // 375
|
|
} else if (position === TEMPLATE_TAG_POSITION.IN_RCDATA || // 376
|
|
position === TEMPLATE_TAG_POSITION.IN_ATTRIBUTE) { // 377
|
|
textMode = HTML.TEXTMODE.RCDATA; // 378
|
|
} // 379
|
|
var parserOptions = { // 380
|
|
getTemplateTag: TemplateTag.parseCompleteTag, // 381
|
|
shouldStop: isAtBlockCloseOrElse, // 382
|
|
textMode: textMode // 383
|
|
}; // 384
|
|
result.content = HTMLTools.parseFragment(scanner, parserOptions); // 385
|
|
// 386
|
|
if (scanner.rest().slice(0, 2) !== '{{') // 387
|
|
scanner.fatal("Expected {{else}} or block close for " + blockName); // 388
|
|
// 389
|
|
var lastPos = scanner.pos; // save for error messages // 390
|
|
var tmplTag = TemplateTag.parse(scanner); // {{else}} or {{/foo}} // 391
|
|
// 392
|
|
if (tmplTag.type === 'ELSE') { // 393
|
|
// parse {{else}} and content up to close tag // 394
|
|
result.elseContent = HTMLTools.parseFragment(scanner, parserOptions); // 395
|
|
// 396
|
|
if (scanner.rest().slice(0, 2) !== '{{') // 397
|
|
scanner.fatal("Expected block close for " + blockName); // 398
|
|
// 399
|
|
lastPos = scanner.pos; // 400
|
|
tmplTag = TemplateTag.parse(scanner); // 401
|
|
} // 402
|
|
// 403
|
|
if (tmplTag.type === 'BLOCKCLOSE') { // 404
|
|
var blockName2 = tmplTag.path.join(','); // 405
|
|
if (blockName !== blockName2) { // 406
|
|
scanner.pos = lastPos; // 407
|
|
scanner.fatal('Expected tag to close ' + blockName + ', found ' + // 408
|
|
blockName2); // 409
|
|
} // 410
|
|
} else { // 411
|
|
scanner.pos = lastPos; // 412
|
|
scanner.fatal('Expected tag to close ' + blockName + ', found ' + // 413
|
|
tmplTag.type); // 414
|
|
} // 415
|
|
} // 416
|
|
// 417
|
|
var finalPos = scanner.pos; // 418
|
|
scanner.pos = startPos; // 419
|
|
validateTag(result, scanner); // 420
|
|
scanner.pos = finalPos; // 421
|
|
// 422
|
|
return result; // 423
|
|
}; // 424
|
|
// 425
|
|
var isAtBlockCloseOrElse = function (scanner) { // 426
|
|
// Detect `{{else}}` or `{{/foo}}`. // 427
|
|
// // 428
|
|
// We do as much work ourselves before deferring to `TemplateTag.peek`, // 429
|
|
// for efficiency (we're called for every input token) and to be // 430
|
|
// less obtrusive, because `TemplateTag.peek` will throw an error if it // 431
|
|
// sees `{{` followed by a malformed tag. // 432
|
|
var rest, type; // 433
|
|
return (scanner.peek() === '{' && // 434
|
|
(rest = scanner.rest()).slice(0, 2) === '{{' && // 435
|
|
/^\{\{\s*(\/|else\b)/.test(rest) && // 436
|
|
(type = TemplateTag.peek(scanner).type) && // 437
|
|
(type === 'BLOCKCLOSE' || type === 'ELSE')); // 438
|
|
}; // 439
|
|
// 440
|
|
// Validate that `templateTag` is correctly formed and legal for its // 441
|
|
// HTML position. Use `scanner` to report errors. On success, does // 442
|
|
// nothing. // 443
|
|
var validateTag = function (ttag, scanner) { // 444
|
|
// 445
|
|
if (ttag.type === 'INCLUSION' || ttag.type === 'BLOCKOPEN') { // 446
|
|
var args = ttag.args; // 447
|
|
if (args.length > 1 && args[0].length === 2 && args[0][0] !== 'PATH') { // 448
|
|
// we have a positional argument that is not a PATH followed by // 449
|
|
// other arguments // 450
|
|
scanner.fatal("First argument must be a function, to be called on the rest of the arguments; found " + args[0][0]);
|
|
} // 452
|
|
} // 453
|
|
// 454
|
|
var position = ttag.position || TEMPLATE_TAG_POSITION.ELEMENT; // 455
|
|
if (position === TEMPLATE_TAG_POSITION.IN_ATTRIBUTE) { // 456
|
|
if (ttag.type === 'DOUBLE' || ttag.type === 'ESCAPE') { // 457
|
|
return; // 458
|
|
} else if (ttag.type === 'BLOCKOPEN') { // 459
|
|
var path = ttag.path; // 460
|
|
var path0 = path[0]; // 461
|
|
if (! (path.length === 1 && (path0 === 'if' || // 462
|
|
path0 === 'unless' || // 463
|
|
path0 === 'with' || // 464
|
|
path0 === 'each'))) { // 465
|
|
scanner.fatal("Custom block helpers are not allowed in an HTML attribute, only built-in ones like #each and #if");
|
|
} // 467
|
|
} else { // 468
|
|
scanner.fatal(ttag.type + " template tag is not allowed in an HTML attribute"); // 469
|
|
} // 470
|
|
} else if (position === TEMPLATE_TAG_POSITION.IN_START_TAG) { // 471
|
|
if (! (ttag.type === 'DOUBLE')) { // 472
|
|
scanner.fatal("Reactive HTML attributes must either have a constant name or consist of a single {{helper}} providing a dictionary of names and values. A template tag of type " + ttag.type + " is not allowed here.");
|
|
} // 474
|
|
if (scanner.peek() === '=') { // 475
|
|
scanner.fatal("Template tags are not allowed in attribute names, only in attribute values or in the form of a single {{helper}} that evaluates to a dictionary of name=value pairs.");
|
|
} // 477
|
|
} // 478
|
|
// 479
|
|
}; // 480
|
|
// 481
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/spacebars-compiler/optimizer.js //
|
|
// //
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Optimize parts of an HTMLjs tree into raw HTML strings when they don't // 1
|
|
// contain template tags. // 2
|
|
// 3
|
|
var constant = function (value) { // 4
|
|
return function () { return value; }; // 5
|
|
}; // 6
|
|
// 7
|
|
var OPTIMIZABLE = { // 8
|
|
NONE: 0, // 9
|
|
PARTS: 1, // 10
|
|
FULL: 2 // 11
|
|
}; // 12
|
|
// 13
|
|
// We can only turn content into an HTML string if it contains no template // 14
|
|
// tags and no "tricky" HTML tags. If we can optimize the entire content // 15
|
|
// into a string, we return OPTIMIZABLE.FULL. If the we are given an // 16
|
|
// unoptimizable node, we return OPTIMIZABLE.NONE. If we are given a tree // 17
|
|
// that contains an unoptimizable node somewhere, we return OPTIMIZABLE.PARTS. // 18
|
|
// // 19
|
|
// For example, we always create SVG elements programmatically, since SVG // 20
|
|
// doesn't have innerHTML. If we are given an SVG element, we return NONE. // 21
|
|
// However, if we are given a big tree that contains SVG somewhere, we // 22
|
|
// return PARTS so that the optimizer can descend into the tree and optimize // 23
|
|
// other parts of it. // 24
|
|
var CanOptimizeVisitor = HTML.Visitor.extend(); // 25
|
|
CanOptimizeVisitor.def({ // 26
|
|
visitNull: constant(OPTIMIZABLE.FULL), // 27
|
|
visitPrimitive: constant(OPTIMIZABLE.FULL), // 28
|
|
visitComment: constant(OPTIMIZABLE.FULL), // 29
|
|
visitCharRef: constant(OPTIMIZABLE.FULL), // 30
|
|
visitRaw: constant(OPTIMIZABLE.FULL), // 31
|
|
visitObject: constant(OPTIMIZABLE.NONE), // 32
|
|
visitFunction: constant(OPTIMIZABLE.NONE), // 33
|
|
visitArray: function (x) { // 34
|
|
for (var i = 0; i < x.length; i++) // 35
|
|
if (this.visit(x[i]) !== OPTIMIZABLE.FULL) // 36
|
|
return OPTIMIZABLE.PARTS; // 37
|
|
return OPTIMIZABLE.FULL; // 38
|
|
}, // 39
|
|
visitTag: function (tag) { // 40
|
|
var tagName = tag.tagName; // 41
|
|
if (tagName === 'textarea') { // 42
|
|
// optimizing into a TEXTAREA's RCDATA would require being a little // 43
|
|
// more clever. // 44
|
|
return OPTIMIZABLE.NONE; // 45
|
|
} else if (! (HTML.isKnownElement(tagName) && // 46
|
|
! HTML.isKnownSVGElement(tagName))) { // 47
|
|
// foreign elements like SVG can't be stringified for innerHTML. // 48
|
|
return OPTIMIZABLE.NONE; // 49
|
|
} else if (tagName === 'table') { // 50
|
|
// Avoid ever producing HTML containing `<table><tr>...`, because the // 51
|
|
// browser will insert a TBODY. If we just `createElement("table")` and // 52
|
|
// `createElement("tr")`, on the other hand, no TBODY is necessary // 53
|
|
// (assuming IE 8+). // 54
|
|
return OPTIMIZABLE.NONE; // 55
|
|
} // 56
|
|
// 57
|
|
var children = tag.children; // 58
|
|
for (var i = 0; i < children.length; i++) // 59
|
|
if (this.visit(children[i]) !== OPTIMIZABLE.FULL) // 60
|
|
return OPTIMIZABLE.PARTS; // 61
|
|
// 62
|
|
if (this.visitAttributes(tag.attrs) !== OPTIMIZABLE.FULL) // 63
|
|
return OPTIMIZABLE.PARTS; // 64
|
|
// 65
|
|
return OPTIMIZABLE.FULL; // 66
|
|
}, // 67
|
|
visitAttributes: function (attrs) { // 68
|
|
if (attrs) { // 69
|
|
var isArray = HTML.isArray(attrs); // 70
|
|
for (var i = 0; i < (isArray ? attrs.length : 1); i++) { // 71
|
|
var a = (isArray ? attrs[i] : attrs); // 72
|
|
if ((typeof a !== 'object') || (a instanceof HTMLTools.TemplateTag)) // 73
|
|
return OPTIMIZABLE.PARTS; // 74
|
|
for (var k in a) // 75
|
|
if (this.visit(a[k]) !== OPTIMIZABLE.FULL) // 76
|
|
return OPTIMIZABLE.PARTS; // 77
|
|
} // 78
|
|
} // 79
|
|
return OPTIMIZABLE.FULL; // 80
|
|
} // 81
|
|
}); // 82
|
|
// 83
|
|
var getOptimizability = function (content) { // 84
|
|
return (new CanOptimizeVisitor).visit(content); // 85
|
|
}; // 86
|
|
// 87
|
|
var toRaw = function (x) { // 88
|
|
return HTML.Raw(HTML.toHTML(x)); // 89
|
|
}; // 90
|
|
// 91
|
|
var TreeTransformer = HTML.TransformingVisitor.extend(); // 92
|
|
TreeTransformer.def({ // 93
|
|
visitAttributes: function (attrs/*, ...*/) { // 94
|
|
// pass template tags through by default // 95
|
|
if (attrs instanceof HTMLTools.TemplateTag) // 96
|
|
return attrs; // 97
|
|
// 98
|
|
return HTML.TransformingVisitor.prototype.visitAttributes.apply( // 99
|
|
this, arguments); // 100
|
|
} // 101
|
|
}); // 102
|
|
// 103
|
|
// Replace parts of the HTMLjs tree that have no template tags (or // 104
|
|
// tricky HTML tags) with HTML.Raw objects containing raw HTML. // 105
|
|
var OptimizingVisitor = TreeTransformer.extend(); // 106
|
|
OptimizingVisitor.def({ // 107
|
|
visitNull: toRaw, // 108
|
|
visitPrimitive: toRaw, // 109
|
|
visitComment: toRaw, // 110
|
|
visitCharRef: toRaw, // 111
|
|
visitArray: function (array) { // 112
|
|
var optimizability = getOptimizability(array); // 113
|
|
if (optimizability === OPTIMIZABLE.FULL) { // 114
|
|
return toRaw(array); // 115
|
|
} else if (optimizability === OPTIMIZABLE.PARTS) { // 116
|
|
return TreeTransformer.prototype.visitArray.call(this, array); // 117
|
|
} else { // 118
|
|
return array; // 119
|
|
} // 120
|
|
}, // 121
|
|
visitTag: function (tag) { // 122
|
|
var optimizability = getOptimizability(tag); // 123
|
|
if (optimizability === OPTIMIZABLE.FULL) { // 124
|
|
return toRaw(tag); // 125
|
|
} else if (optimizability === OPTIMIZABLE.PARTS) { // 126
|
|
return TreeTransformer.prototype.visitTag.call(this, tag); // 127
|
|
} else { // 128
|
|
return tag; // 129
|
|
} // 130
|
|
}, // 131
|
|
visitChildren: function (children) { // 132
|
|
// don't optimize the children array into a Raw object! // 133
|
|
return TreeTransformer.prototype.visitArray.call(this, children); // 134
|
|
}, // 135
|
|
visitAttributes: function (attrs) { // 136
|
|
return attrs; // 137
|
|
} // 138
|
|
}); // 139
|
|
// 140
|
|
// Combine consecutive HTML.Raws. Remove empty ones. // 141
|
|
var RawCompactingVisitor = TreeTransformer.extend(); // 142
|
|
RawCompactingVisitor.def({ // 143
|
|
visitArray: function (array) { // 144
|
|
var result = []; // 145
|
|
for (var i = 0; i < array.length; i++) { // 146
|
|
var item = array[i]; // 147
|
|
if ((item instanceof HTML.Raw) && // 148
|
|
((! item.value) || // 149
|
|
(result.length && // 150
|
|
(result[result.length - 1] instanceof HTML.Raw)))) { // 151
|
|
// two cases: item is an empty Raw, or previous item is // 152
|
|
// a Raw as well. In the latter case, replace the previous // 153
|
|
// Raw with a longer one that includes the new Raw. // 154
|
|
if (item.value) { // 155
|
|
result[result.length - 1] = HTML.Raw( // 156
|
|
result[result.length - 1].value + item.value); // 157
|
|
} // 158
|
|
} else { // 159
|
|
result.push(item); // 160
|
|
} // 161
|
|
} // 162
|
|
return result; // 163
|
|
} // 164
|
|
}); // 165
|
|
// 166
|
|
// Replace pointless Raws like `HTMl.Raw('foo')` that contain no special // 167
|
|
// characters with simple strings. // 168
|
|
var RawReplacingVisitor = TreeTransformer.extend(); // 169
|
|
RawReplacingVisitor.def({ // 170
|
|
visitRaw: function (raw) { // 171
|
|
var html = raw.value; // 172
|
|
if (html.indexOf('&') < 0 && html.indexOf('<') < 0) { // 173
|
|
return html; // 174
|
|
} else { // 175
|
|
return raw; // 176
|
|
} // 177
|
|
} // 178
|
|
}); // 179
|
|
// 180
|
|
SpacebarsCompiler.optimize = function (tree) { // 181
|
|
tree = (new OptimizingVisitor).visit(tree); // 182
|
|
tree = (new RawCompactingVisitor).visit(tree); // 183
|
|
tree = (new RawReplacingVisitor).visit(tree); // 184
|
|
return tree; // 185
|
|
}; // 186
|
|
// 187
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/spacebars-compiler/codegen.js //
|
|
// //
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ============================================================ // 1
|
|
// Code-generation of template tags // 2
|
|
// 3
|
|
// The `CodeGen` class currently has no instance state, but in theory // 4
|
|
// it could be useful to track per-function state, like whether we // 5
|
|
// need to emit `var self = this` or not. // 6
|
|
var CodeGen = SpacebarsCompiler.CodeGen = function () {}; // 7
|
|
// 8
|
|
var builtInBlockHelpers = SpacebarsCompiler._builtInBlockHelpers = { // 9
|
|
'if': 'Blaze.If', // 10
|
|
'unless': 'Blaze.Unless', // 11
|
|
'with': 'Spacebars.With', // 12
|
|
'each': 'Blaze.Each' // 13
|
|
}; // 14
|
|
// 15
|
|
// 16
|
|
// Mapping of "macros" which, when preceded by `Template.`, expand // 17
|
|
// to special code rather than following the lookup rules for dotted // 18
|
|
// symbols. // 19
|
|
var builtInTemplateMacros = { // 20
|
|
// `view` is a local variable defined in the generated render // 21
|
|
// function for the template in which `Template.contentBlock` or // 22
|
|
// `Template.elseBlock` is invoked. // 23
|
|
'contentBlock': 'view.templateContentBlock', // 24
|
|
'elseBlock': 'view.templateElseBlock', // 25
|
|
// 26
|
|
// Confusingly, this makes `{{> Template.dynamic}}` an alias // 27
|
|
// for `{{> __dynamic}}`, where "__dynamic" is the template that // 28
|
|
// implements the dynamic template feature. // 29
|
|
'dynamic': 'Template.__dynamic', // 30
|
|
// 31
|
|
'subscriptionsReady': 'view.templateInstance().subscriptionsReady()' // 32
|
|
}; // 33
|
|
// 34
|
|
// A "reserved name" can't be used as a <template> name. This // 35
|
|
// function is used by the template file scanner. // 36
|
|
// // 37
|
|
// Note that the runtime imposes additional restrictions, for example // 38
|
|
// banning the name "body" and names of built-in object properties // 39
|
|
// like "toString". // 40
|
|
SpacebarsCompiler.isReservedName = function (name) { // 41
|
|
return builtInBlockHelpers.hasOwnProperty(name) || // 42
|
|
builtInTemplateMacros.hasOwnProperty(name); // 43
|
|
}; // 44
|
|
// 45
|
|
var makeObjectLiteral = function (obj) { // 46
|
|
var parts = []; // 47
|
|
for (var k in obj) // 48
|
|
parts.push(BlazeTools.toObjectLiteralKey(k) + ': ' + obj[k]); // 49
|
|
return '{' + parts.join(', ') + '}'; // 50
|
|
}; // 51
|
|
// 52
|
|
_.extend(CodeGen.prototype, { // 53
|
|
codeGenTemplateTag: function (tag) { // 54
|
|
var self = this; // 55
|
|
if (tag.position === HTMLTools.TEMPLATE_TAG_POSITION.IN_START_TAG) { // 56
|
|
// Special dynamic attributes: `<div {{attrs}}>...` // 57
|
|
// only `tag.type === 'DOUBLE'` allowed (by earlier validation) // 58
|
|
return BlazeTools.EmitCode('function () { return ' + // 59
|
|
self.codeGenMustache(tag.path, tag.args, 'attrMustache') // 60
|
|
+ '; }'); // 61
|
|
} else { // 62
|
|
if (tag.type === 'DOUBLE' || tag.type === 'TRIPLE') { // 63
|
|
var code = self.codeGenMustache(tag.path, tag.args); // 64
|
|
if (tag.type === 'TRIPLE') { // 65
|
|
code = 'Spacebars.makeRaw(' + code + ')'; // 66
|
|
} // 67
|
|
if (tag.position !== HTMLTools.TEMPLATE_TAG_POSITION.IN_ATTRIBUTE) { // 68
|
|
// Reactive attributes are already wrapped in a function, // 69
|
|
// and there's no fine-grained reactivity. // 70
|
|
// Anywhere else, we need to create a View. // 71
|
|
code = 'Blaze.View("lookup:' + tag.path.join('.') + '", ' + // 72
|
|
'function () { return ' + code + '; })'; // 73
|
|
} // 74
|
|
return BlazeTools.EmitCode(code); // 75
|
|
} else if (tag.type === 'INCLUSION' || tag.type === 'BLOCKOPEN') { // 76
|
|
var path = tag.path; // 77
|
|
// 78
|
|
if (tag.type === 'BLOCKOPEN' && // 79
|
|
builtInBlockHelpers.hasOwnProperty(path[0])) { // 80
|
|
// if, unless, with, each. // 81
|
|
// // 82
|
|
// If someone tries to do `{{> if}}`, we don't // 83
|
|
// get here, but an error is thrown when we try to codegen the path. // 84
|
|
// 85
|
|
// Note: If we caught these errors earlier, while scanning, we'd be able to // 86
|
|
// provide nice line numbers. // 87
|
|
if (path.length > 1) // 88
|
|
throw new Error("Unexpected dotted path beginning with " + path[0]); // 89
|
|
if (! tag.args.length) // 90
|
|
throw new Error("#" + path[0] + " requires an argument"); // 91
|
|
// 92
|
|
// `args` must exist (tag.args.length > 0) // 93
|
|
var dataCode = self.codeGenInclusionDataFunc(tag.args) || 'null'; // 94
|
|
// `content` must exist // 95
|
|
var contentBlock = (('content' in tag) ? // 96
|
|
self.codeGenBlock(tag.content) : null); // 97
|
|
// `elseContent` may not exist // 98
|
|
var elseContentBlock = (('elseContent' in tag) ? // 99
|
|
self.codeGenBlock(tag.elseContent) : null); // 100
|
|
// 101
|
|
var callArgs = [dataCode, contentBlock]; // 102
|
|
if (elseContentBlock) // 103
|
|
callArgs.push(elseContentBlock); // 104
|
|
// 105
|
|
return BlazeTools.EmitCode( // 106
|
|
builtInBlockHelpers[path[0]] + '(' + callArgs.join(', ') + ')'); // 107
|
|
// 108
|
|
} else { // 109
|
|
var compCode = self.codeGenPath(path, {lookupTemplate: true}); // 110
|
|
if (path.length > 1) { // 111
|
|
// capture reactivity // 112
|
|
compCode = 'function () { return Spacebars.call(' + compCode + // 113
|
|
'); }'; // 114
|
|
} // 115
|
|
// 116
|
|
var dataCode = self.codeGenInclusionDataFunc(tag.args); // 117
|
|
var content = (('content' in tag) ? // 118
|
|
self.codeGenBlock(tag.content) : null); // 119
|
|
var elseContent = (('elseContent' in tag) ? // 120
|
|
self.codeGenBlock(tag.elseContent) : null); // 121
|
|
// 122
|
|
var includeArgs = [compCode]; // 123
|
|
if (content) { // 124
|
|
includeArgs.push(content); // 125
|
|
if (elseContent) // 126
|
|
includeArgs.push(elseContent); // 127
|
|
} // 128
|
|
// 129
|
|
var includeCode = // 130
|
|
'Spacebars.include(' + includeArgs.join(', ') + ')'; // 131
|
|
// 132
|
|
// calling convention compat -- set the data context around the // 133
|
|
// entire inclusion, so that if the name of the inclusion is // 134
|
|
// a helper function, it gets the data context in `this`. // 135
|
|
// This makes for a pretty confusing calling convention -- // 136
|
|
// In `{{#foo bar}}`, `foo` is evaluated in the context of `bar` // 137
|
|
// -- but it's what we shipped for 0.8.0. The rationale is that // 138
|
|
// `{{#foo bar}}` is sugar for `{{#with bar}}{{#foo}}...`. // 139
|
|
if (dataCode) { // 140
|
|
includeCode = // 141
|
|
'Blaze._TemplateWith(' + dataCode + ', function () { return ' + // 142
|
|
includeCode + '; })'; // 143
|
|
} // 144
|
|
// 145
|
|
// XXX BACK COMPAT - UI is the old name, Template is the new // 146
|
|
if ((path[0] === 'UI' || path[0] === 'Template') && // 147
|
|
(path[1] === 'contentBlock' || path[1] === 'elseBlock')) { // 148
|
|
// Call contentBlock and elseBlock in the appropriate scope // 149
|
|
includeCode = 'Blaze._InOuterTemplateScope(view, function () { return ' // 150
|
|
+ includeCode + '; })'; // 151
|
|
} // 152
|
|
// 153
|
|
return BlazeTools.EmitCode(includeCode); // 154
|
|
} // 155
|
|
} else if (tag.type === 'ESCAPE') { // 156
|
|
return tag.value; // 157
|
|
} else { // 158
|
|
// Can't get here; TemplateTag validation should catch any // 159
|
|
// inappropriate tag types that might come out of the parser. // 160
|
|
throw new Error("Unexpected template tag type: " + tag.type); // 161
|
|
} // 162
|
|
} // 163
|
|
}, // 164
|
|
// 165
|
|
// `path` is an array of at least one string. // 166
|
|
// // 167
|
|
// If `path.length > 1`, the generated code may be reactive // 168
|
|
// (i.e. it may invalidate the current computation). // 169
|
|
// // 170
|
|
// No code is generated to call the result if it's a function. // 171
|
|
// // 172
|
|
// Options: // 173
|
|
// // 174
|
|
// - lookupTemplate {Boolean} If true, generated code also looks in // 175
|
|
// the list of templates. (After helpers, before data context). // 176
|
|
// Used when generating code for `{{> foo}}` or `{{#foo}}`. Only // 177
|
|
// used for non-dotted paths. // 178
|
|
codeGenPath: function (path, opts) { // 179
|
|
if (builtInBlockHelpers.hasOwnProperty(path[0])) // 180
|
|
throw new Error("Can't use the built-in '" + path[0] + "' here"); // 181
|
|
// Let `{{#if Template.contentBlock}}` check whether this template was // 182
|
|
// invoked via inclusion or as a block helper, in addition to supporting // 183
|
|
// `{{> Template.contentBlock}}`. // 184
|
|
// XXX BACK COMPAT - UI is the old name, Template is the new // 185
|
|
if (path.length >= 2 && // 186
|
|
(path[0] === 'UI' || path[0] === 'Template') // 187
|
|
&& builtInTemplateMacros.hasOwnProperty(path[1])) { // 188
|
|
if (path.length > 2) // 189
|
|
throw new Error("Unexpected dotted path beginning with " + // 190
|
|
path[0] + '.' + path[1]); // 191
|
|
return builtInTemplateMacros[path[1]]; // 192
|
|
} // 193
|
|
// 194
|
|
var firstPathItem = BlazeTools.toJSLiteral(path[0]); // 195
|
|
var lookupMethod = 'lookup'; // 196
|
|
if (opts && opts.lookupTemplate && path.length === 1) // 197
|
|
lookupMethod = 'lookupTemplate'; // 198
|
|
var code = 'view.' + lookupMethod + '(' + firstPathItem + ')'; // 199
|
|
// 200
|
|
if (path.length > 1) { // 201
|
|
code = 'Spacebars.dot(' + code + ', ' + // 202
|
|
_.map(path.slice(1), BlazeTools.toJSLiteral).join(', ') + ')'; // 203
|
|
} // 204
|
|
// 205
|
|
return code; // 206
|
|
}, // 207
|
|
// 208
|
|
// Generates code for an `[argType, argValue]` argument spec, // 209
|
|
// ignoring the third element (keyword argument name) if present. // 210
|
|
// // 211
|
|
// The resulting code may be reactive (in the case of a PATH of // 212
|
|
// more than one element) and is not wrapped in a closure. // 213
|
|
codeGenArgValue: function (arg) { // 214
|
|
var self = this; // 215
|
|
// 216
|
|
var argType = arg[0]; // 217
|
|
var argValue = arg[1]; // 218
|
|
// 219
|
|
var argCode; // 220
|
|
switch (argType) { // 221
|
|
case 'STRING': // 222
|
|
case 'NUMBER': // 223
|
|
case 'BOOLEAN': // 224
|
|
case 'NULL': // 225
|
|
argCode = BlazeTools.toJSLiteral(argValue); // 226
|
|
break; // 227
|
|
case 'PATH': // 228
|
|
argCode = self.codeGenPath(argValue); // 229
|
|
break; // 230
|
|
default: // 231
|
|
// can't get here // 232
|
|
throw new Error("Unexpected arg type: " + argType); // 233
|
|
} // 234
|
|
// 235
|
|
return argCode; // 236
|
|
}, // 237
|
|
// 238
|
|
// Generates a call to `Spacebars.fooMustache` on evaluated arguments. // 239
|
|
// The resulting code has no function literals and must be wrapped in // 240
|
|
// one for fine-grained reactivity. // 241
|
|
codeGenMustache: function (path, args, mustacheType) { // 242
|
|
var self = this; // 243
|
|
// 244
|
|
var nameCode = self.codeGenPath(path); // 245
|
|
var argCode = self.codeGenMustacheArgs(args); // 246
|
|
var mustache = (mustacheType || 'mustache'); // 247
|
|
// 248
|
|
return 'Spacebars.' + mustache + '(' + nameCode + // 249
|
|
(argCode ? ', ' + argCode.join(', ') : '') + ')'; // 250
|
|
}, // 251
|
|
// 252
|
|
// returns: array of source strings, or null if no // 253
|
|
// args at all. // 254
|
|
codeGenMustacheArgs: function (tagArgs) { // 255
|
|
var self = this; // 256
|
|
// 257
|
|
var kwArgs = null; // source -> source // 258
|
|
var args = null; // [source] // 259
|
|
// 260
|
|
// tagArgs may be null // 261
|
|
_.each(tagArgs, function (arg) { // 262
|
|
var argCode = self.codeGenArgValue(arg); // 263
|
|
// 264
|
|
if (arg.length > 2) { // 265
|
|
// keyword argument (represented as [type, value, name]) // 266
|
|
kwArgs = (kwArgs || {}); // 267
|
|
kwArgs[arg[2]] = argCode; // 268
|
|
} else { // 269
|
|
// positional argument // 270
|
|
args = (args || []); // 271
|
|
args.push(argCode); // 272
|
|
} // 273
|
|
}); // 274
|
|
// 275
|
|
// put kwArgs in options dictionary at end of args // 276
|
|
if (kwArgs) { // 277
|
|
args = (args || []); // 278
|
|
args.push('Spacebars.kw(' + makeObjectLiteral(kwArgs) + ')'); // 279
|
|
} // 280
|
|
// 281
|
|
return args; // 282
|
|
}, // 283
|
|
// 284
|
|
codeGenBlock: function (content) { // 285
|
|
return SpacebarsCompiler.codeGen(content); // 286
|
|
}, // 287
|
|
// 288
|
|
codeGenInclusionDataFunc: function (args) { // 289
|
|
var self = this; // 290
|
|
// 291
|
|
var dataFuncCode = null; // 292
|
|
// 293
|
|
if (! args.length) { // 294
|
|
// e.g. `{{#foo}}` // 295
|
|
return null; // 296
|
|
} else if (args[0].length === 3) { // 297
|
|
// keyword arguments only, e.g. `{{> point x=1 y=2}}` // 298
|
|
var dataProps = {}; // 299
|
|
_.each(args, function (arg) { // 300
|
|
var argKey = arg[2]; // 301
|
|
dataProps[argKey] = 'Spacebars.call(' + self.codeGenArgValue(arg) + ')'; // 302
|
|
}); // 303
|
|
dataFuncCode = makeObjectLiteral(dataProps); // 304
|
|
} else if (args[0][0] !== 'PATH') { // 305
|
|
// literal first argument, e.g. `{{> foo "blah"}}` // 306
|
|
// // 307
|
|
// tag validation has confirmed, in this case, that there is only // 308
|
|
// one argument (`args.length === 1`) // 309
|
|
dataFuncCode = self.codeGenArgValue(args[0]); // 310
|
|
} else if (args.length === 1) { // 311
|
|
// one argument, must be a PATH // 312
|
|
dataFuncCode = 'Spacebars.call(' + self.codeGenPath(args[0][1]) + ')'; // 313
|
|
} else { // 314
|
|
// Multiple positional arguments; treat them as a nested // 315
|
|
// "data mustache" // 316
|
|
dataFuncCode = self.codeGenMustache(args[0][1], args.slice(1), // 317
|
|
'dataMustache'); // 318
|
|
} // 319
|
|
// 320
|
|
return 'function () { return ' + dataFuncCode + '; }'; // 321
|
|
} // 322
|
|
// 323
|
|
}); // 324
|
|
// 325
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(function () {
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// packages/spacebars-compiler/compiler.js //
|
|
// //
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 1
|
|
SpacebarsCompiler.parse = function (input) { // 2
|
|
// 3
|
|
var tree = HTMLTools.parseFragment( // 4
|
|
input, // 5
|
|
{ getTemplateTag: TemplateTag.parseCompleteTag }); // 6
|
|
// 7
|
|
return tree; // 8
|
|
}; // 9
|
|
// 10
|
|
SpacebarsCompiler.compile = function (input, options) { // 11
|
|
var tree = SpacebarsCompiler.parse(input); // 12
|
|
return SpacebarsCompiler.codeGen(tree, options); // 13
|
|
}; // 14
|
|
// 15
|
|
SpacebarsCompiler._TemplateTagReplacer = HTML.TransformingVisitor.extend(); // 16
|
|
SpacebarsCompiler._TemplateTagReplacer.def({ // 17
|
|
visitObject: function (x) { // 18
|
|
if (x instanceof HTMLTools.TemplateTag) { // 19
|
|
// 20
|
|
// Make sure all TemplateTags in attributes have the right // 21
|
|
// `.position` set on them. This is a bit of a hack // 22
|
|
// (we shouldn't be mutating that here), but it allows // 23
|
|
// cleaner codegen of "synthetic" attributes like TEXTAREA's // 24
|
|
// "value", where the template tags were originally not // 25
|
|
// in an attribute. // 26
|
|
if (this.inAttributeValue) // 27
|
|
x.position = HTMLTools.TEMPLATE_TAG_POSITION.IN_ATTRIBUTE; // 28
|
|
// 29
|
|
return this.codegen.codeGenTemplateTag(x); // 30
|
|
} // 31
|
|
// 32
|
|
return HTML.TransformingVisitor.prototype.visitObject.call(this, x); // 33
|
|
}, // 34
|
|
visitAttributes: function (attrs) { // 35
|
|
if (attrs instanceof HTMLTools.TemplateTag) // 36
|
|
return this.codegen.codeGenTemplateTag(attrs); // 37
|
|
// 38
|
|
// call super (e.g. for case where `attrs` is an array) // 39
|
|
return HTML.TransformingVisitor.prototype.visitAttributes.call(this, attrs); // 40
|
|
}, // 41
|
|
visitAttribute: function (name, value, tag) { // 42
|
|
this.inAttributeValue = true; // 43
|
|
var result = this.visit(value); // 44
|
|
this.inAttributeValue = false; // 45
|
|
// 46
|
|
if (result !== value) { // 47
|
|
// some template tags must have been replaced, because otherwise // 48
|
|
// we try to keep things `===` when transforming. Wrap the code // 49
|
|
// in a function as per the rules. You can't have // 50
|
|
// `{id: Blaze.View(...)}` as an attributes dict because the View // 51
|
|
// would be rendered more than once; you need to wrap it in a function // 52
|
|
// so that it's a different View each time. // 53
|
|
return BlazeTools.EmitCode(this.codegen.codeGenBlock(result)); // 54
|
|
} // 55
|
|
return result; // 56
|
|
} // 57
|
|
}); // 58
|
|
// 59
|
|
SpacebarsCompiler.codeGen = function (parseTree, options) { // 60
|
|
// is this a template, rather than a block passed to // 61
|
|
// a block helper, say // 62
|
|
var isTemplate = (options && options.isTemplate); // 63
|
|
var isBody = (options && options.isBody); // 64
|
|
// 65
|
|
var tree = parseTree; // 66
|
|
// 67
|
|
// The flags `isTemplate` and `isBody` are kind of a hack. // 68
|
|
if (isTemplate || isBody) { // 69
|
|
// optimizing fragments would require being smarter about whether we are // 70
|
|
// in a TEXTAREA, say. // 71
|
|
tree = SpacebarsCompiler.optimize(tree); // 72
|
|
} // 73
|
|
// 74
|
|
var codegen = new SpacebarsCompiler.CodeGen; // 75
|
|
tree = (new SpacebarsCompiler._TemplateTagReplacer( // 76
|
|
{codegen: codegen})).visit(tree); // 77
|
|
// 78
|
|
var code = '(function () { '; // 79
|
|
if (isTemplate || isBody) { // 80
|
|
code += 'var view = this; '; // 81
|
|
} // 82
|
|
code += 'return '; // 83
|
|
code += BlazeTools.toJS(tree); // 84
|
|
code += '; })'; // 85
|
|
// 86
|
|
code = SpacebarsCompiler._beautify(code); // 87
|
|
// 88
|
|
return code; // 89
|
|
}; // 90
|
|
// 91
|
|
SpacebarsCompiler._beautify = function (code) { // 92
|
|
if (Package.minifiers && Package.minifiers.UglifyJSMinify) { // 93
|
|
var result = Package.minifiers.UglifyJSMinify( // 94
|
|
code, // 95
|
|
{ fromString: true, // 96
|
|
mangle: false, // 97
|
|
compress: false, // 98
|
|
output: { beautify: true, // 99
|
|
indent_level: 2, // 100
|
|
width: 80 } }); // 101
|
|
var output = result.code; // 102
|
|
// Uglify interprets our expression as a statement and may add a semicolon. // 103
|
|
// Strip trailing semicolon. // 104
|
|
output = output.replace(/;$/, ''); // 105
|
|
return output; // 106
|
|
} else { // 107
|
|
// don't actually beautify; no UglifyJS // 108
|
|
return code; // 109
|
|
} // 110
|
|
}; // 111
|
|
// 112
|
|
////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
}).call(this);
|
|
|
|
|
|
/* Exports */
|
|
if (typeof Package === 'undefined') Package = {};
|
|
Package['spacebars-compiler'] = {
|
|
SpacebarsCompiler: SpacebarsCompiler
|
|
};
|
|
|
|
})();
|
|
|
|
//# sourceMappingURL=spacebars-compiler.js.map
|