| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 | + +1 + + +1 +1 +1 +1 +1 +1 +1 + +1 +1 +504 + +504 +82 + +504 +409 + + +504 +504 +504 +504 +504 + +504 + + +1 +1 + +1 + +1 | "use strict";
+/*globals Handlebars: true */
+var Handlebars = require("./handlebars.runtime")["default"];
+
+// Compiler imports
+var AST = require("./handlebars/compiler/ast")["default"];
+var Parser = require("./handlebars/compiler/base").parser;
+var parse = require("./handlebars/compiler/base").parse;
+var Compiler = require("./handlebars/compiler/compiler").Compiler;
+var compile = require("./handlebars/compiler/compiler").compile;
+var precompile = require("./handlebars/compiler/compiler").precompile;
+var JavaScriptCompiler = require("./handlebars/compiler/javascript-compiler")["default"];
+
+var _create = Handlebars.create;
+var create = function() {
+ var hb = _create();
+
+ hb.compile = function(input, options) {
+ return compile(input, options, hb);
+ };
+ hb.precompile = function (input, options) {
+ return precompile(input, options, hb);
+ };
+
+ hb.AST = AST;
+ hb.Compiler = Compiler;
+ hb.JavaScriptCompiler = JavaScriptCompiler;
+ hb.Parser = Parser;
+ hb.parse = parse;
+
+ return hb;
+};
+
+Handlebars = create();
+Handlebars.create = create;
+
+Handlebars['default'] = Handlebars;
+
+exports["default"] = Handlebars; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 | + +1 + + + +1 +1 +1 +1 + + +1 +505 + +505 +505 +505 +505 +505 + +505 +505 +474 + + +505 + + +1 +1 + +1 + +1 | "use strict";
+/*globals Handlebars: true */
+var base = require("./handlebars/base");
+
+// Each of these augment the Handlebars object. No need to setup here.
+// (This is done to easily share code between commonjs and browse envs)
+var SafeString = require("./handlebars/safe-string")["default"];
+var Exception = require("./handlebars/exception")["default"];
+var Utils = require("./handlebars/utils");
+var runtime = require("./handlebars/runtime");
+
+// For compatibility and usage outside of module systems, make the Handlebars object a namespace
+var create = function() {
+ var hb = new base.HandlebarsEnvironment();
+
+ Utils.extend(hb, base);
+ hb.SafeString = SafeString;
+ hb.Exception = Exception;
+ hb.Utils = Utils;
+ hb.escapeExpression = Utils.escapeExpression;
+
+ hb.VM = runtime;
+ hb.template = function(spec) {
+ return runtime.template(spec, hb);
+ };
+
+ return hb;
+};
+
+var Handlebars = create();
+Handlebars.create = create;
+
+Handlebars['default'] = Handlebars;
+
+exports["default"] = Handlebars; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 | +1 +1 + +1 +1 +1 +1 + + + + + + + +1 +1 + + + + +1 +505 +505 + +505 + + +1 + + + + + + +4059 +2 +1 + +4057 + + + +1 + + + +2 +1 + +1 + + + +1 + + + +1 +505 +24 + +23 + + +1 + + + +505 +145 + + +145 +26 +119 +40 +79 +57 +49 +1 + + +49 + +8 + + +22 +3 +3 +3 + + +22 + + + +505 +83 +1 + + +82 +82 + +82 +82 +5 + + +82 + +82 +76 + + +82 +81 +75 +173 +160 +160 +160 + +160 +5 + + +173 + + +6 +13 +12 +10 +10 +10 + +10 +3 + + +12 +12 + + + + + +82 +4 + + +82 + + +505 +83 + + + + +83 +44 + +39 + + + +505 +2 + + +505 +9 + +9 + +9 +8 +3 +3 +3 + + +8 + +1 + + + +505 +5 +5 + + +505 +4 + + + +1 + + + + + + + + + + + +3 +2 +2 +1 + + + + +1 +1 +1 +1 +109 +109 +109 + +1 | "use strict";
+var Utils = require("./utils");
+var Exception = require("./exception")["default"];
+
+var VERSION = "2.0.0";
+exports.VERSION = VERSION;var COMPILER_REVISION = 6;
+exports.COMPILER_REVISION = COMPILER_REVISION;
+var REVISION_CHANGES = {
+ 1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
+ 2: '== 1.0.0-rc.3',
+ 3: '== 1.0.0-rc.4',
+ 4: '== 1.x.x',
+ 5: '== 2.0.0-alpha.x',
+ 6: '>= 2.0.0-beta.1'
+};
+exports.REVISION_CHANGES = REVISION_CHANGES;
+var isArray = Utils.isArray,
+ isFunction = Utils.isFunction,
+ toString = Utils.toString,
+ objectType = '[object Object]';
+
+function HandlebarsEnvironment(helpers, partials) {
+ this.helpers = helpers || {};
+ this.partials = partials || {};
+
+ registerDefaultHelpers(this);
+}
+
+exports.HandlebarsEnvironment = HandlebarsEnvironment;HandlebarsEnvironment.prototype = {
+ constructor: HandlebarsEnvironment,
+
+ logger: logger,
+ log: log,
+
+ registerHelper: function(name, fn) {
+ if (toString.call(name) === objectType) {
+ if (fn) { throw new Exception('Arg not supported with multiple helpers'); }
+ Utils.extend(this.helpers, name);
+ } else {
+ this.helpers[name] = fn;
+ }
+ },
+ unregisterHelper: function(name) {
+ delete this.helpers[name];
+ },
+
+ registerPartial: function(name, partial) {
+ if (toString.call(name) === objectType) {
+ Utils.extend(this.partials, name);
+ } else {
+ this.partials[name] = partial;
+ }
+ },
+ unregisterPartial: function(name) {
+ delete this.partials[name];
+ }
+};
+
+function registerDefaultHelpers(instance) {
+ instance.registerHelper('helperMissing', function(/* [args, ]options */) {
+ if(arguments.length === 1) {
+ // A missing field in a {{foo}} constuct.
+ return undefined;
+ } else {
+ // Someone is actually trying to call something, blow up.
+ throw new Exception("Missing helper: '" + arguments[arguments.length-1].name + "'");
+ }
+ });
+
+ instance.registerHelper('blockHelperMissing', function(context, options) {
+ var inverse = options.inverse,
+ fn = options.fn;
+
+ if(context === true) {
+ return fn(this);
+ } else if(context === false || context == null) {
+ return inverse(this);
+ } else if (isArray(context)) {
+ if(context.length > 0) {
+ if (options.ids) {
+ options.ids = [options.name];
+ }
+
+ return instance.helpers.each(context, options);
+ } else {
+ return inverse(this);
+ }
+ } else {
+ if (options.data && options.ids) {
+ var data = createFrame(options.data);
+ data.contextPath = Utils.appendContextPath(options.data.contextPath, options.name);
+ options = {data: data};
+ }
+
+ return fn(context, options);
+ }
+ });
+
+ instance.registerHelper('each', function(context, options) {
+ if (!options) {
+ throw new Exception('Must pass iterator to #each');
+ }
+
+ var fn = options.fn, inverse = options.inverse;
+ var i = 0, ret = "", data;
+
+ var contextPath;
+ if (options.data && options.ids) {
+ contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]) + '.';
+ }
+
+ if (isFunction(context)) { context = context.call(this); }
+
+ if (options.data) {
+ data = createFrame(options.data);
+ }
+
+ if(context && typeof context === 'object') {
+ if (isArray(context)) {
+ for(var j = context.length; i<j; i++) {
+ if (data) {
+ data.index = i;
+ data.first = (i === 0);
+ data.last = (i === (context.length-1));
+
+ if (contextPath) {
+ data.contextPath = contextPath + i;
+ }
+ }
+ ret = ret + fn(context[i], { data: data });
+ }
+ } else {
+ for(var key in context) {
+ if(context.hasOwnProperty(key)) {
+ if(data) {
+ data.key = key;
+ data.index = i;
+ data.first = (i === 0);
+
+ if (contextPath) {
+ data.contextPath = contextPath + key;
+ }
+ }
+ ret = ret + fn(context[key], {data: data});
+ i++;
+ }
+ }
+ }
+ }
+
+ if(i === 0){
+ ret = inverse(this);
+ }
+
+ return ret;
+ });
+
+ instance.registerHelper('if', function(conditional, options) {
+ if (isFunction(conditional)) { conditional = conditional.call(this); }
+
+ // Default behavior is to render the positive path if the value is truthy and not empty.
+ // The `includeZero` option may be set to treat the condtional as purely not empty based on the
+ // behavior of isEmpty. Effectively this determines if 0 is handled by the positive path or negative.
+ if ((!options.hash.includeZero && !conditional) || Utils.isEmpty(conditional)) {
+ return options.inverse(this);
+ } else {
+ return options.fn(this);
+ }
+ });
+
+ instance.registerHelper('unless', function(conditional, options) {
+ return instance.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn, hash: options.hash});
+ });
+
+ instance.registerHelper('with', function(context, options) {
+ if (isFunction(context)) { context = context.call(this); }
+
+ var fn = options.fn;
+
+ if (!Utils.isEmpty(context)) {
+ if (options.data && options.ids) {
+ var data = createFrame(options.data);
+ data.contextPath = Utils.appendContextPath(options.data.contextPath, options.ids[0]);
+ options = {data:data};
+ }
+
+ return fn(context, options);
+ } else {
+ return options.inverse(this);
+ }
+ });
+
+ instance.registerHelper('log', function(message, options) {
+ var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
+ instance.log(level, message);
+ });
+
+ instance.registerHelper('lookup', function(obj, field) {
+ return obj && obj[field];
+ });
+}
+
+var logger = {
+ methodMap: { 0: 'debug', 1: 'info', 2: 'warn', 3: 'error' },
+
+ // State enum
+ DEBUG: 0,
+ INFO: 1,
+ WARN: 2,
+ ERROR: 3,
+ level: 3,
+
+ // can be overridden in the host environment
+ log: function(level, message) {
+ if (logger.level <= level) {
+ var method = logger.methodMap[level];
+ if (typeof console !== 'undefined' && console[method]) {
+ console[method].call(console, message);
+ }
+ }
+ }
+};
+exports.logger = logger;
+var log = logger.log;
+exports.log = log;
+var createFrame = function(object) {
+ var frame = Utils.extend({}, object);
+ frame._parent = object;
+ return frame;
+};
+exports.createFrame = createFrame; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 | +1 + +1 +10460 +10460 +10460 +10460 +10460 + + +1 + +1700 +1700 +1700 +1700 + + + +1588 +1588 +1588 + + +1588 + +1584 +1584 + +4 + + +1588 +1569 + + +19 + + + +1588 +1588 +1588 +1588 +1588 + + + +1644 + +1644 +1644 + +1644 +1644 + + + + +1644 + + + +1644 + + + + + + + +96 +96 +96 +96 +96 +96 + +96 + + + +602 + +602 +602 +602 +602 +602 + +602 +80 + + + + +5 + +5 +1 + + +4 + +4 +4 +4 + + + +1617 +1617 +1617 + + + +75 +75 +75 + + + +2756 +2756 + +2756 + + + + +2756 +3091 +3091 + +3091 +163 +11 +152 +67 +67 + +85 + + +2928 + + + +2745 +2745 +2745 +2745 +2745 + + + +2745 + +2745 + + + +96 +96 +96 + + + +75 +75 +75 +75 +75 + + + +58 +58 +58 + + + + + +56 +56 +56 + +56 + + + +55 +55 +55 +55 + + + +37 +37 +37 + +37 + + + + + + + + +1 | "use strict";
+var Exception = require("../exception")["default"];
+
+function LocationInfo(locInfo) {
+ locInfo = locInfo || {};
+ this.firstLine = locInfo.first_line;
+ this.firstColumn = locInfo.first_column;
+ this.lastColumn = locInfo.last_column;
+ this.lastLine = locInfo.last_line;
+}
+
+var AST = {
+ ProgramNode: function(statements, strip, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "program";
+ this.statements = statements;
+ this.strip = strip;
+ },
+
+ MustacheNode: function(rawParams, hash, open, strip, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "mustache";
+ this.strip = strip;
+
+ // Open may be a string parsed from the parser or a passed boolean flag
+ if (open != null && open.charAt) {
+ // Must use charAt to support IE pre-10
+ var escapeFlag = open.charAt(3) || open.charAt(2);
+ this.escaped = escapeFlag !== '{' && escapeFlag !== '&';
+ } else {
+ this.escaped = !!open;
+ }
+
+ if (rawParams instanceof AST.SexprNode) {
+ this.sexpr = rawParams;
+ } else {
+ // Support old AST API
+ this.sexpr = new AST.SexprNode(rawParams, hash);
+ }
+
+ // Support old AST API that stored this info in MustacheNode
+ this.id = this.sexpr.id;
+ this.params = this.sexpr.params;
+ this.hash = this.sexpr.hash;
+ this.eligibleHelper = this.sexpr.eligibleHelper;
+ this.isHelper = this.sexpr.isHelper;
+ },
+
+ SexprNode: function(rawParams, hash, locInfo) {
+ LocationInfo.call(this, locInfo);
+
+ this.type = "sexpr";
+ this.hash = hash;
+
+ var id = this.id = rawParams[0];
+ var params = this.params = rawParams.slice(1);
+
+ // a mustache is definitely a helper if:
+ // * it is an eligible helper, and
+ // * it has at least one parameter or hash segment
+ this.isHelper = !!(params.length || hash);
+
+ // a mustache is an eligible helper if:
+ // * its id is simple (a single part, not `this` or `..`)
+ this.eligibleHelper = this.isHelper || id.isSimple;
+
+ // if a mustache is an eligible helper but not a definite
+ // helper, it is ambiguous, and will be resolved in a later
+ // pass or at runtime.
+ },
+
+ PartialNode: function(partialName, context, hash, strip, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "partial";
+ this.partialName = partialName;
+ this.context = context;
+ this.hash = hash;
+ this.strip = strip;
+
+ this.strip.inlineStandalone = true;
+ },
+
+ BlockNode: function(mustache, program, inverse, strip, locInfo) {
+ LocationInfo.call(this, locInfo);
+
+ this.type = 'block';
+ this.mustache = mustache;
+ this.program = program;
+ this.inverse = inverse;
+ this.strip = strip;
+
+ if (inverse && !program) {
+ this.isInverse = true;
+ }
+ },
+
+ RawBlockNode: function(mustache, content, close, locInfo) {
+ LocationInfo.call(this, locInfo);
+
+ if (mustache.sexpr.id.original !== close) {
+ throw new Exception(mustache.sexpr.id.original + " doesn't match " + close, this);
+ }
+
+ content = new AST.ContentNode(content, locInfo);
+
+ this.type = 'block';
+ this.mustache = mustache;
+ this.program = new AST.ProgramNode([content], {}, locInfo);
+ },
+
+ ContentNode: function(string, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "content";
+ this.original = this.string = string;
+ },
+
+ HashNode: function(pairs, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "hash";
+ this.pairs = pairs;
+ },
+
+ IdNode: function(parts, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "ID";
+
+ var original = "",
+ dig = [],
+ depth = 0,
+ depthString = '';
+
+ for(var i=0,l=parts.length; i<l; i++) {
+ var part = parts[i].part;
+ original += (parts[i].separator || '') + part;
+
+ if (part === ".." || part === "." || part === "this") {
+ if (dig.length > 0) {
+ throw new Exception("Invalid path: " + original, this);
+ } else if (part === "..") {
+ depth++;
+ depthString += '../';
+ } else {
+ this.isScoped = true;
+ }
+ } else {
+ dig.push(part);
+ }
+ }
+
+ this.original = original;
+ this.parts = dig;
+ this.string = dig.join('.');
+ this.depth = depth;
+ this.idName = depthString + this.string;
+
+ // an ID is simple if it only has one part, and that part is not
+ // `..` or `this`.
+ this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
+
+ this.stringModeValue = this.string;
+ },
+
+ PartialNameNode: function(name, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "PARTIAL_NAME";
+ this.name = name.original;
+ },
+
+ DataNode: function(id, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "DATA";
+ this.id = id;
+ this.stringModeValue = id.stringModeValue;
+ this.idName = '@' + id.stringModeValue;
+ },
+
+ StringNode: function(string, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "STRING";
+ this.original =
+ this.string =
+ this.stringModeValue = string;
+ },
+
+ NumberNode: function(number, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "NUMBER";
+ this.original =
+ this.number = number;
+ this.stringModeValue = Number(number);
+ },
+
+ BooleanNode: function(bool, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "BOOLEAN";
+ this.bool = bool;
+ this.stringModeValue = bool === "true";
+ },
+
+ CommentNode: function(comment, locInfo) {
+ LocationInfo.call(this, locInfo);
+ this.type = "comment";
+ this.comment = comment;
+
+ this.strip = {
+ inlineStandalone: true
+ };
+ }
+};
+
+
+// Must be exported as an object rather than the root of the module as the jison lexer
+// most modify the object to operate properly.
+exports["default"] = AST; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 | +1 +1 +1 +1 + +1 + +1 +1 + +1 + +1052 + +1049 + +1049 + + +1 | "use strict";
+var parser = require("./parser")["default"];
+var AST = require("./ast")["default"];
+var Helpers = require("./helpers");
+var extend = require("../utils").extend;
+
+exports.parser = parser;
+
+var yy = {};
+extend(yy, Helpers, AST);
+
+function parse(input) {
+ // Just return if an already-compile AST was passed in.
+ if (input.constructor === AST.ProgramNode) { return input; }
+
+ parser.yy = yy;
+
+ return parser.parse(input);
+}
+
+exports.parse = parse; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 | +1 +1 + +1 + +1 + +1 + + + + +1 + + + +129 +129 +45 + + +84 +279 + +279 +68 + + + + + +16 +16 +4 +3 + + + +13 + + + + + +1595 +1595 +1595 +1595 +1595 +1595 + + +1595 +1595 + + + + + + + + + +1595 +646 +5054 + + + +1595 + + + +5302 + + + +1595 + +1595 +3165 + +1593 + +1593 +2 + + +1593 + + + +631 +631 + +631 + +631 + +631 +52 + +52 +2 + + +631 + + + +583 + + + +583 +505 + + +583 +126 + + +583 +583 + +583 +232 +351 +32 + + + +32 +32 +32 +32 + +319 + + + +319 +319 +319 +319 + + +583 + + + +60 + +60 + +60 +96 + +60 +96 + +60 + + + +86 +86 + +86 +2 + +84 + + +86 +4 + +82 +82 + + +86 +86 + + + +1553 +1419 + + + + +913 + +911 +851 + +60 + + + + +894 + + + +894 + +894 +894 + +894 + +894 + + + +186 + +186 +38 +148 +108 + + +40 +40 +40 + + +186 + + + +468 + + + +468 +210 +258 +2 + +256 + +256 +256 + + + + +965 + +965 +154 +811 +236 + +575 + + + + +1588 +1588 + +1588 +1588 + +16 + +1572 + + + + +68 +68 + + + +42 + + + +50 + + + +40 + + + + + + +14161 + + + +1636 + +56 +54 +54 + + + + +1548 +1548 +1548 + + + +1548 +912 + +912 +10 +902 +8 + + + +1548 +1080 +186 + + + +468 +502 + + + + +598 +62 +6 + +62 +62 + +62 + + +4 + + +536 +54 + +536 + + + + +468 +468 + +468 +468 + +468 +58 + +410 + + +468 + + + +1 +801 +2 + + +799 +799 +767 + +799 +180 + + +799 +785 +783 + + +1 +155 +2 + + +153 + +153 +71 + +153 +48 + + +153 + +1 +153 +153 +153 +153 + + + +153 +174 +150 + +174 + +153 +2 +1 + +2 + +153 +4 +2 + +4 + +153 + + +1 +621 +241 + + +380 +312 +342 +81 + + +231 + + | "use strict";
+var Exception = require("../exception")["default"];
+var isArray = require("../utils").isArray;
+
+var slice = [].slice;
+
+function Compiler() {}
+
+exports.Compiler = Compiler;// the foundHelper register will disambiguate helper lookup from finding a
+// function in a context. This is necessary for mustache compatibility, which
+// requires that context functions in blocks are evaluated by blockHelperMissing,
+// and then proceed as if the resulting value was provided to blockHelperMissing.
+
+Compiler.prototype = {
+ compiler: Compiler,
+
+ equals: function(other) {
+ var len = this.opcodes.length;
+ if (other.opcodes.length !== len) {
+ return false;
+ }
+
+ for (var i = 0; i < len; i++) {
+ var opcode = this.opcodes[i],
+ otherOpcode = other.opcodes[i];
+ if (opcode.opcode !== otherOpcode.opcode || !argEquals(opcode.args, otherOpcode.args)) {
+ return false;
+ }
+ }
+
+ // We know that length is the same between the two arrays because they are directly tied
+ // to the opcode behavior above.
+ len = this.children.length;
+ for (i = 0; i < len; i++) {
+ if (!this.children[i].equals(other.children[i])) {
+ return false;
+ }
+ }
+
+ return true;
+ },
+
+ guid: 0,
+
+ compile: function(program, options) {
+ this.opcodes = [];
+ this.children = [];
+ this.depths = {list: []};
+ this.options = options;
+ this.stringParams = options.stringParams;
+ this.trackIds = options.trackIds;
+
+ // These changes will propagate to the other compiler components
+ var knownHelpers = this.options.knownHelpers;
+ this.options.knownHelpers = {
+ 'helperMissing': true,
+ 'blockHelperMissing': true,
+ 'each': true,
+ 'if': true,
+ 'unless': true,
+ 'with': true,
+ 'log': true,
+ 'lookup': true
+ };
+ if (knownHelpers) {
+ for (var name in knownHelpers) {
+ this.options.knownHelpers[name] = knownHelpers[name];
+ }
+ }
+
+ return this.accept(program);
+ },
+
+ accept: function(node) {
+ return this[node.type](node);
+ },
+
+ program: function(program) {
+ var statements = program.statements;
+
+ for(var i=0, l=statements.length; i<l; i++) {
+ this.accept(statements[i]);
+ }
+ this.isSimple = l === 1;
+
+ this.depths.list = this.depths.list.sort(function(a, b) {
+ return a - b;
+ });
+
+ return this;
+ },
+
+ compileProgram: function(program) {
+ var result = new this.compiler().compile(program, this.options);
+ var guid = this.guid++, depth;
+
+ this.usePartial = this.usePartial || result.usePartial;
+
+ this.children[guid] = result;
+
+ for(var i=0, l=result.depths.list.length; i<l; i++) {
+ depth = result.depths.list[i];
+
+ if(depth < 2) { continue; }
+ else { this.addDepth(depth - 1); }
+ }
+
+ return guid;
+ },
+
+ block: function(block) {
+ var mustache = block.mustache,
+ program = block.program,
+ inverse = block.inverse;
+
+ if (program) {
+ program = this.compileProgram(program);
+ }
+
+ if (inverse) {
+ inverse = this.compileProgram(inverse);
+ }
+
+ var sexpr = mustache.sexpr;
+ var type = this.classifySexpr(sexpr);
+
+ if (type === "helper") {
+ this.helperSexpr(sexpr, program, inverse);
+ } else if (type === "simple") {
+ this.simpleSexpr(sexpr);
+
+ // now that the simple mustache is resolved, we need to
+ // evaluate it by executing `blockHelperMissing`
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+ this.opcode('emptyHash');
+ this.opcode('blockValue', sexpr.id.original);
+ } else {
+ this.ambiguousSexpr(sexpr, program, inverse);
+
+ // now that the simple mustache is resolved, we need to
+ // evaluate it by executing `blockHelperMissing`
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+ this.opcode('emptyHash');
+ this.opcode('ambiguousBlockValue');
+ }
+
+ this.opcode('append');
+ },
+
+ hash: function(hash) {
+ var pairs = hash.pairs, i, l;
+
+ this.opcode('pushHash');
+
+ for(i=0, l=pairs.length; i<l; i++) {
+ this.pushParam(pairs[i][1]);
+ }
+ while(i--) {
+ this.opcode('assignToHash', pairs[i][0]);
+ }
+ this.opcode('popHash');
+ },
+
+ partial: function(partial) {
+ var partialName = partial.partialName;
+ this.usePartial = true;
+
+ if (partial.hash) {
+ this.accept(partial.hash);
+ } else {
+ this.opcode('push', 'undefined');
+ }
+
+ if (partial.context) {
+ this.accept(partial.context);
+ } else {
+ this.opcode('getContext', 0);
+ this.opcode('pushContext');
+ }
+
+ this.opcode('invokePartial', partialName.name, partial.indent || '');
+ this.opcode('append');
+ },
+
+ content: function(content) {
+ if (content.string) {
+ this.opcode('appendContent', content.string);
+ }
+ },
+
+ mustache: function(mustache) {
+ this.sexpr(mustache.sexpr);
+
+ if(mustache.escaped && !this.options.noEscape) {
+ this.opcode('appendEscaped');
+ } else {
+ this.opcode('append');
+ }
+ },
+
+ ambiguousSexpr: function(sexpr, program, inverse) {
+ var id = sexpr.id,
+ name = id.parts[0],
+ isBlock = program != null || inverse != null;
+
+ this.opcode('getContext', id.depth);
+
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+
+ this.ID(id);
+
+ this.opcode('invokeAmbiguous', name, isBlock);
+ },
+
+ simpleSexpr: function(sexpr) {
+ var id = sexpr.id;
+
+ if (id.type === 'DATA') {
+ this.DATA(id);
+ } else if (id.parts.length) {
+ this.ID(id);
+ } else {
+ // Simplified ID for `this`
+ this.addDepth(id.depth);
+ this.opcode('getContext', id.depth);
+ this.opcode('pushContext');
+ }
+
+ this.opcode('resolvePossibleLambda');
+ },
+
+ helperSexpr: function(sexpr, program, inverse) {
+ var params = this.setupFullMustacheParams(sexpr, program, inverse),
+ id = sexpr.id,
+ name = id.parts[0];
+
+ if (this.options.knownHelpers[name]) {
+ this.opcode('invokeKnownHelper', params.length, name);
+ } else if (this.options.knownHelpersOnly) {
+ throw new Exception("You specified knownHelpersOnly, but used the unknown helper " + name, sexpr);
+ } else {
+ id.falsy = true;
+
+ this.ID(id);
+ this.opcode('invokeHelper', params.length, id.original, id.isSimple);
+ }
+ },
+
+ sexpr: function(sexpr) {
+ var type = this.classifySexpr(sexpr);
+
+ if (type === "simple") {
+ this.simpleSexpr(sexpr);
+ } else if (type === "helper") {
+ this.helperSexpr(sexpr);
+ } else {
+ this.ambiguousSexpr(sexpr);
+ }
+ },
+
+ ID: function(id) {
+ this.addDepth(id.depth);
+ this.opcode('getContext', id.depth);
+
+ var name = id.parts[0];
+ if (!name) {
+ // Context reference, i.e. `{{foo .}}` or `{{foo ..}}`
+ this.opcode('pushContext');
+ } else {
+ this.opcode('lookupOnContext', id.parts, id.falsy, id.isScoped);
+ }
+ },
+
+ DATA: function(data) {
+ this.options.data = true;
+ this.opcode('lookupData', data.id.depth, data.id.parts);
+ },
+
+ STRING: function(string) {
+ this.opcode('pushString', string.string);
+ },
+
+ NUMBER: function(number) {
+ this.opcode('pushLiteral', number.number);
+ },
+
+ BOOLEAN: function(bool) {
+ this.opcode('pushLiteral', bool.bool);
+ },
+
+ comment: function() {},
+
+ // HELPERS
+ opcode: function(name) {
+ this.opcodes.push({ opcode: name, args: slice.call(arguments, 1) });
+ },
+
+ addDepth: function(depth) {
+ if(depth === 0) { return; }
+
+ if(!this.depths[depth]) {
+ this.depths[depth] = true;
+ this.depths.list.push(depth);
+ }
+ },
+
+ classifySexpr: function(sexpr) {
+ var isHelper = sexpr.isHelper;
+ var isEligible = sexpr.eligibleHelper;
+ var options = this.options;
+
+ // if ambiguous, we can possibly resolve the ambiguity now
+ // An eligible helper is one that does not have a complex path, i.e. `this.foo`, `../foo` etc.
+ if (isEligible && !isHelper) {
+ var name = sexpr.id.parts[0];
+
+ if (options.knownHelpers[name]) {
+ isHelper = true;
+ } else if (options.knownHelpersOnly) {
+ isEligible = false;
+ }
+ }
+
+ if (isHelper) { return "helper"; }
+ else if (isEligible) { return "ambiguous"; }
+ else { return "simple"; }
+ },
+
+ pushParams: function(params) {
+ for(var i=0, l=params.length; i<l; i++) {
+ this.pushParam(params[i]);
+ }
+ },
+
+ pushParam: function(val) {
+ if (this.stringParams) {
+ if(val.depth) {
+ this.addDepth(val.depth);
+ }
+ this.opcode('getContext', val.depth || 0);
+ this.opcode('pushStringParam', val.stringModeValue, val.type);
+
+ if (val.type === 'sexpr') {
+ // Subexpressions get evaluated and passed in
+ // in string params mode.
+ this.sexpr(val);
+ }
+ } else {
+ if (this.trackIds) {
+ this.opcode('pushId', val.type, val.idName || val.stringModeValue);
+ }
+ this.accept(val);
+ }
+ },
+
+ setupFullMustacheParams: function(sexpr, program, inverse) {
+ var params = sexpr.params;
+ this.pushParams(params);
+
+ this.opcode('pushProgram', program);
+ this.opcode('pushProgram', inverse);
+
+ if (sexpr.hash) {
+ this.hash(sexpr.hash);
+ } else {
+ this.opcode('emptyHash');
+ }
+
+ return params;
+ }
+};
+
+function precompile(input, options, env) {
+ if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) {
+ throw new Exception("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input);
+ }
+
+ options = options || {};
+ if (!('data' in options)) {
+ options.data = true;
+ }
+ if (options.compat) {
+ options.useDepths = true;
+ }
+
+ var ast = env.parse(input);
+ var environment = new env.Compiler().compile(ast, options);
+ return new env.JavaScriptCompiler().compile(environment, options);
+}
+
+exports.precompile = precompile;function compile(input, options, env) {
+ if (input == null || (typeof input !== 'string' && input.constructor !== env.AST.ProgramNode)) {
+ throw new Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
+ }
+
+ options = options || {};
+
+ if (!('data' in options)) {
+ options.data = true;
+ }
+ if (options.compat) {
+ options.useDepths = true;
+ }
+
+ var compiled;
+
+ function compileInput() {
+ var ast = env.parse(input);
+ var environment = new env.Compiler().compile(ast, options);
+ var templateSpec = new env.JavaScriptCompiler().compile(environment, options, undefined, true);
+ return env.template(templateSpec);
+ }
+
+ // Template is only compiled on first use and cached after that point.
+ var ret = function(context, options) {
+ if (!compiled) {
+ compiled = compileInput();
+ }
+ return compiled.call(this, context, options);
+ };
+ ret._setup = function(options) {
+ if (!compiled) {
+ compiled = compileInput();
+ }
+ return compiled._setup(options);
+ };
+ ret._child = function(i, data, depths) {
+ if (!compiled) {
+ compiled = compileInput();
+ }
+ return compiled._child(i, data, depths);
+ };
+ return ret;
+}
+
+exports.compile = compile;function argEquals(a, b) {
+ if (a === b) {
+ return true;
+ }
+
+ if (isArray(a) && isArray(b) && a.length === b.length) {
+ for (var i = 0; i < a.length; i++) {
+ if (!argEquals(a[i], b[i])) {
+ return false;
+ }
+ }
+ return true;
+ }
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 | +1 + +1 +2323 + + + + + +1 +1 + +603 +2 + + +601 + +601 + + + + + + + + + +601 +34 + + +601 +62 + +62 +22 + +62 +22 + +62 +18 + + + +62 + + +17 +17 + + +539 +14 + + + +601 +80 + +521 + + + +1 +1 +2718 +5434 + + +5434 +2583 + + +2851 + + + + + + +2851 +72 + +2851 +64 + + +2851 +63 + +63 + +20 +11 + + + +2851 +109 + + +109 + +2851 + +115 + +115 + + + +2718 + + +1 +3514 +663 + + + + +3514 + +3514 +1480 + + +2034 +1712 + + +1 +3469 +618 + + +3469 + +3469 +1401 + + +2068 +1729 + + + + + + + + + + +1 +432 +432 +150 + + +282 +282 +282 + + + + + + + + + +1 +422 +422 +90 + + + +332 +332 +332 +332 + | "use strict";
+var Exception = require("../exception")["default"];
+
+function stripFlags(open, close) {
+ return {
+ left: open.charAt(2) === '~',
+ right: close.charAt(close.length-3) === '~'
+ };
+}
+
+exports.stripFlags = stripFlags;
+function prepareBlock(mustache, program, inverseAndProgram, close, inverted, locInfo) {
+ /*jshint -W040 */
+ if (mustache.sexpr.id.original !== close.path.original) {
+ throw new Exception(mustache.sexpr.id.original + ' doesn\'t match ' + close.path.original, mustache);
+ }
+
+ var inverse = inverseAndProgram && inverseAndProgram.program;
+
+ var strip = {
+ left: mustache.strip.left,
+ right: close.strip.right,
+
+ // Determine the standalone candiacy. Basically flag our content as being possibly standalone
+ // so our parent can determine if we actually are standalone
+ openStandalone: isNextWhitespace(program.statements),
+ closeStandalone: isPrevWhitespace((inverse || program).statements)
+ };
+
+ if (mustache.strip.right) {
+ omitRight(program.statements, null, true);
+ }
+
+ if (inverse) {
+ var inverseStrip = inverseAndProgram.strip;
+
+ if (inverseStrip.left) {
+ omitLeft(program.statements, null, true);
+ }
+ if (inverseStrip.right) {
+ omitRight(inverse.statements, null, true);
+ }
+ if (close.strip.left) {
+ omitLeft(inverse.statements, null, true);
+ }
+
+ // Find standalone else statments
+ if (isPrevWhitespace(program.statements)
+ && isNextWhitespace(inverse.statements)) {
+
+ omitLeft(program.statements);
+ omitRight(inverse.statements);
+ }
+ } else {
+ if (close.strip.left) {
+ omitLeft(program.statements, null, true);
+ }
+ }
+
+ if (inverted) {
+ return new this.BlockNode(mustache, inverse, program, strip, locInfo);
+ } else {
+ return new this.BlockNode(mustache, program, inverse, strip, locInfo);
+ }
+}
+
+exports.prepareBlock = prepareBlock;
+function prepareProgram(statements, isRoot) {
+ for (var i = 0, l = statements.length; i < l; i++) {
+ var current = statements[i],
+ strip = current.strip;
+
+ if (!strip) {
+ continue;
+ }
+
+ var _isPrevWhitespace = isPrevWhitespace(statements, i, isRoot, current.type === 'partial'),
+ _isNextWhitespace = isNextWhitespace(statements, i, isRoot),
+
+ openStandalone = strip.openStandalone && _isPrevWhitespace,
+ closeStandalone = strip.closeStandalone && _isNextWhitespace,
+ inlineStandalone = strip.inlineStandalone && _isPrevWhitespace && _isNextWhitespace;
+
+ if (strip.right) {
+ omitRight(statements, i, true);
+ }
+ if (strip.left) {
+ omitLeft(statements, i, true);
+ }
+
+ if (inlineStandalone) {
+ omitRight(statements, i);
+
+ if (omitLeft(statements, i)) {
+ // If we are on a standalone node, save the indent info for partials
+ if (current.type === 'partial') {
+ current.indent = (/([ \t]+$)/).exec(statements[i-1].original) ? RegExp.$1 : '';
+ }
+ }
+ }
+ if (openStandalone) {
+ omitRight((current.program || current.inverse).statements);
+
+ // Strip out the previous content node if it's whitespace only
+ omitLeft(statements, i);
+ }
+ if (closeStandalone) {
+ // Always strip the next node
+ omitRight(statements, i);
+
+ omitLeft((current.inverse || current.program).statements);
+ }
+ }
+
+ return statements;
+}
+
+exports.prepareProgram = prepareProgram;function isPrevWhitespace(statements, i, isRoot) {
+ if (i === undefined) {
+ i = statements.length;
+ }
+
+ // Nodes that end with newlines are considered whitespace (but are special
+ // cased for strip operations)
+ var prev = statements[i-1],
+ sibling = statements[i-2];
+ if (!prev) {
+ return isRoot;
+ }
+
+ if (prev.type === 'content') {
+ return (sibling || !isRoot ? (/\r?\n\s*?$/) : (/(^|\r?\n)\s*?$/)).test(prev.original);
+ }
+}
+function isNextWhitespace(statements, i, isRoot) {
+ if (i === undefined) {
+ i = -1;
+ }
+
+ var next = statements[i+1],
+ sibling = statements[i+2];
+ if (!next) {
+ return isRoot;
+ }
+
+ if (next.type === 'content') {
+ return (sibling || !isRoot ? (/^\s*?\r?\n/) : (/^\s*?(\r?\n|$)/)).test(next.original);
+ }
+}
+
+// Marks the node to the right of the position as omitted.
+// I.e. {{foo}}' ' will mark the ' ' node as omitted.
+//
+// If i is undefined, then the first child will be marked as such.
+//
+// If mulitple is truthy then all whitespace will be stripped out until non-whitespace
+// content is met.
+function omitRight(statements, i, multiple) {
+ var current = statements[i == null ? 0 : i + 1];
+ if (!current || current.type !== 'content' || (!multiple && current.rightStripped)) {
+ return;
+ }
+
+ var original = current.string;
+ current.string = current.string.replace(multiple ? (/^\s+/) : (/^[ \t]*\r?\n?/), '');
+ current.rightStripped = current.string !== original;
+}
+
+// Marks the node to the left of the position as omitted.
+// I.e. ' '{{foo}} will mark the ' ' node as omitted.
+//
+// If i is undefined then the last child will be marked as such.
+//
+// If mulitple is truthy then all whitespace will be stripped out until non-whitespace
+// content is met.
+function omitLeft(statements, i, multiple) {
+ var current = statements[i == null ? statements.length - 1 : i - 1];
+ if (!current || current.type !== 'content' || (!multiple && current.leftStripped)) {
+ return;
+ }
+
+ // We omit the last node if it's whitespace only and not preceeded by a non-content node.
+ var original = current.string;
+ current.string = current.string.replace(multiple ? (/\s+$/) : (/[ \t]+$/), '');
+ current.leftStripped = current.string !== original;
+ return current.leftStripped;
+} |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| ast.js | ++ | 100% | +(107 / 107) | +100% | +(36 / 36) | +100% | +(16 / 16) | +100% | +(107 / 107) | +
| base.js | ++ | 100% | +(13 / 13) | +100% | +(2 / 2) | +100% | +(1 / 1) | +100% | +(12 / 12) | +
| compiler.js | ++ | 100% | +(221 / 221) | +100% | +(117 / 117) | +100% | +(35 / 35) | +100% | +(215 / 215) | +
| helpers.js | ++ | 100% | +(82 / 82) | +98.92% | +(92 / 93) | +100% | +(7 / 7) | +100% | +(81 / 81) | +
| javascript-compiler.js | ++ | 99.45% | +(362 / 364) | +98.46% | +(192 / 195) | +100% | +(59 / 59) | +99.45% | +(361 / 363) | +
| parser.js | ++ | 100% | +(396 / 396) | +100% | +(205 / 205) | +100% | +(27 / 27) | +100% | +(369 / 369) | +
| printer.js | ++ | 100% | +(84 / 84) | +100% | +(16 / 16) | +100% | +(17 / 17) | +100% | +(80 / 80) | +
| visitor.js | ++ | 100% | +(4 / 4) | +100% | +(0 / 0) | +100% | +(2 / 2) | +100% | +(4 / 4) | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 +622 +623 +624 +625 +626 +627 +628 +629 +630 +631 +632 +633 +634 +635 +636 +637 +638 +639 +640 +641 +642 +643 +644 +645 +646 +647 +648 +649 +650 +651 +652 +653 +654 +655 +656 +657 +658 +659 +660 +661 +662 +663 +664 +665 +666 +667 +668 +669 +670 +671 +672 +673 +674 +675 +676 +677 +678 +679 +680 +681 +682 +683 +684 +685 +686 +687 +688 +689 +690 +691 +692 +693 +694 +695 +696 +697 +698 +699 +700 +701 +702 +703 +704 +705 +706 +707 +708 +709 +710 +711 +712 +713 +714 +715 +716 +717 +718 +719 +720 +721 +722 +723 +724 +725 +726 +727 +728 +729 +730 +731 +732 +733 +734 +735 +736 +737 +738 +739 +740 +741 +742 +743 +744 +745 +746 +747 +748 +749 +750 +751 +752 +753 +754 +755 +756 +757 +758 +759 +760 +761 +762 +763 +764 +765 +766 +767 +768 +769 +770 +771 +772 +773 +774 +775 +776 +777 +778 +779 +780 +781 +782 +783 +784 +785 +786 +787 +788 +789 +790 +791 +792 +793 +794 +795 +796 +797 +798 +799 +800 +801 +802 +803 +804 +805 +806 +807 +808 +809 +810 +811 +812 +813 +814 +815 +816 +817 +818 +819 +820 +821 +822 +823 +824 +825 +826 +827 +828 +829 +830 +831 +832 +833 +834 +835 +836 +837 +838 +839 +840 +841 +842 +843 +844 +845 +846 +847 +848 +849 +850 +851 +852 +853 +854 +855 +856 +857 +858 +859 +860 +861 +862 +863 +864 +865 +866 +867 +868 +869 +870 +871 +872 +873 +874 +875 +876 +877 +878 +879 +880 +881 +882 +883 +884 +885 +886 +887 +888 +889 +890 +891 +892 +893 +894 +895 +896 +897 +898 +899 +900 +901 +902 +903 +904 +905 +906 +907 +908 +909 +910 +911 +912 +913 +914 +915 +916 +917 +918 +919 +920 +921 +922 +923 +924 +925 +926 +927 +928 +929 +930 +931 +932 +933 +934 +935 +936 +937 +938 +939 +940 +941 +942 +943 +944 +945 +946 +947 +948 +949 +950 +951 +952 +953 +954 +955 +956 +957 +958 +959 +960 +961 +962 +963 +964 | +1 +1 +1 + +1 +6739 + + +1 + +1 + + + +3716 +3428 + +288 + + + +332 + +332 + + + +935 + +935 + + + +3199 +1085 + +2114 + + +458 + + + + + +147 + + + + + + +1555 +1555 +1555 +1555 +1555 + +1555 +1555 +1555 + + + + +1555 + +1555 +1555 +1555 +1555 +1555 +1555 +1555 + +1555 + +1555 + +1555 + + + + +1555 +13864 + +13864 + + + +1555 + + +1555 +1 + + +1555 +1555 +936 + + + +936 +936 +1154 +619 + + + +936 +82 + +936 +922 + +936 +278 + +936 +228 + + +936 +783 +783 + + +936 + +619 + + + + + + +1555 +1555 + + + +1555 + +1555 +1555 +1023 + + + +1555 +2891 +2889 + + + +1555 + +1555 +472 + + + +1555 + +1555 +184 + +184 + +1371 + + + +1555 + + + + +1555 +4235 +4235 +1656 +796 + +860 + + +2579 +292 +264 +264 + +28 + +292 + +2579 + +2579 +1140 + + + + +1555 +1143 +324 + + +412 +412 +269 + +143 + + + +1555 +1207 + + +1555 + + + + + + + + + + + + +32 + +32 +32 + +32 +32 + +32 + + + + + + + + + +313 + + +313 +313 + +313 + +313 +313 + +313 + + + + + + + + + +1409 +26 + + +1409 + + + + + + + + + + + + + + +723 +723 +723 +723 +265 + + + + + + + + + + +828 + +828 + + + + + + + + + + +2610 + + + + + + + + + +1401 + + + + + + + + + + + +1533 + + +1533 + + +332 + +1201 + + +1533 +1345 +1345 + + +1345 +1095 + + +250 + + + + + + + + + + + + + +68 +64 + +4 + + +68 +68 +80 +80 + + + + + + + + + + + + +182 + +182 + + + + + + + + + + + +62 +62 + + + +62 +58 +50 + +8 + + + + + +1626 + +1626 +56 + +1626 +30 +30 + + + +52 +2 + +52 + + +52 +52 + +52 +4 + +52 +10 +10 + + +52 + + + + + + + + + +198 + + + + + + + + + +10559 +10559 + + + + + + + + + + + +78 + + + + + + + + + + + +3352 +952 + +2400 + + + + + + + + + + + + + +244 + +244 +244 + +244 +244 + + + + + + + + + + +210 +210 + + + + + + + + + + + + + + + +877 +877 +877 + +877 + +877 +877 + +877 + +877 + + + + + + + + + + + + + +86 + +86 +82 +4 +2 + +86 +26 + + +86 + + + + + + + + + +88 + + + + +88 +6 + +88 +18 +18 + + +88 +88 +18 + +88 +18 + +88 +6 + +88 + + + +54 +46 +8 +2 + +6 + + + + + + + + +1555 + +1555 +625 +625 + +625 + +625 +619 +619 +619 +619 +619 +619 + +619 + +6 +6 + + + + +625 +222 +222 +6 + + + + + +952 + + + + +952 + +952 +376 + + +952 + + + +1503 +966 +966 + + + + +6739 + + + +4407 +1383 +1383 + + +4407 +2852 + + + + +723 + +723 +723 +723 +723 + + + +1425 + + + + + + +1425 +1 + + + +1425 + +1425 + +1269 +1269 + + +156 +156 + +156 +156 + + +1425 + +1425 +156 + +1425 +156 + +1425 + + + +879 +879 +879 + + +879 + + +1759 +1759 +723 +723 +723 +723 + + +723 + + + + + +13878 + + + +10559 + + +10559 +5470 + +5089 + +723 +1 + +723 + +5089 + + + + +469 + + +469 + + +469 + + + + +3259 +54 + +3205 + + + + +13802 + + + + + + + + + +2459 + +2459 +10401 +10397 + + + +2459 + + + +1331 + +1331 + +1331 + + + + + + + + +1676 + +1676 +1676 + +1676 +60 + +1676 +40 +40 + + +1676 +1676 + + + +1676 +890 +138 + + +890 +690 + + +890 +890 + + + + +1676 +1676 +486 +486 + +486 +48 + +486 +44 +44 + + + +1676 +60 + +1676 +40 +40 + + +1676 +1640 + + +1676 + + + + + +1676 + +1676 +626 +626 +626 + +1050 +1050 + + + + +1 + + + + + + + + + + + + + + + + + +1 + +1 +58 + + +1 +3716 + + +1 | "use strict";
+var COMPILER_REVISION = require("../base").COMPILER_REVISION;
+var REVISION_CHANGES = require("../base").REVISION_CHANGES;
+var Exception = require("../exception")["default"];
+
+function Literal(value) {
+ this.value = value;
+}
+
+function JavaScriptCompiler() {}
+
+JavaScriptCompiler.prototype = {
+ // PUBLIC API: You can override these methods in a subclass to provide
+ // alternative compiled forms for name lookup and buffering semantics
+ nameLookup: function(parent, name /* , type*/) {
+ if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
+ return parent + "." + name;
+ } else {
+ return parent + "['" + name + "']";
+ }
+ },
+ depthedLookup: function(name) {
+ this.aliases.lookup = 'this.lookup';
+
+ return 'lookup(depths, "' + name + '")';
+ },
+
+ compilerInfo: function() {
+ var revision = COMPILER_REVISION,
+ versions = REVISION_CHANGES[revision];
+ return [revision, versions];
+ },
+
+ appendToBuffer: function(string) {
+ if (this.environment.isSimple) {
+ return "return " + string + ";";
+ } else {
+ return {
+ appendToBuffer: true,
+ content: string,
+ toString: function() { return "buffer += " + string + ";"; }
+ };
+ }
+ },
+
+ initializeBuffer: function() {
+ return this.quotedString("");
+ },
+
+ namespace: "Handlebars",
+ // END PUBLIC API
+
+ compile: function(environment, options, context, asObject) {
+ this.environment = environment;
+ this.options = options;
+ this.stringParams = this.options.stringParams;
+ this.trackIds = this.options.trackIds;
+ this.precompile = !asObject;
+
+ this.name = this.environment.name;
+ this.isChild = !!context;
+ this.context = context || {
+ programs: [],
+ environments: []
+ };
+
+ this.preamble();
+
+ this.stackSlot = 0;
+ this.stackVars = [];
+ this.aliases = {};
+ this.registers = { list: [] };
+ this.hashes = [];
+ this.compileStack = [];
+ this.inlineStack = [];
+
+ this.compileChildren(environment, options);
+
+ this.useDepths = this.useDepths || environment.depths.list.length || this.options.compat;
+
+ var opcodes = environment.opcodes,
+ opcode,
+ i,
+ l;
+
+ for (i = 0, l = opcodes.length; i < l; i++) {
+ opcode = opcodes[i];
+
+ this[opcode.opcode].apply(this, opcode.args);
+ }
+
+ // Flush any trailing content that might be pending.
+ this.pushSource('');
+
+ /* istanbul ignore next */
+ Iif (this.stackSlot || this.inlineStack.length || this.compileStack.length) {
+ throw new Exception('Compile completed with content left on stack');
+ }
+
+ var fn = this.createFunctionContext(asObject);
+ if (!this.isChild) {
+ var ret = {
+ compiler: this.compilerInfo(),
+ main: fn
+ };
+ var programs = this.context.programs;
+ for (i = 0, l = programs.length; i < l; i++) {
+ if (programs[i]) {
+ ret[i] = programs[i];
+ }
+ }
+
+ if (this.environment.usePartial) {
+ ret.usePartial = true;
+ }
+ if (this.options.data) {
+ ret.useData = true;
+ }
+ if (this.useDepths) {
+ ret.useDepths = true;
+ }
+ if (this.options.compat) {
+ ret.compat = true;
+ }
+
+ if (!asObject) {
+ ret.compiler = JSON.stringify(ret.compiler);
+ ret = this.objectLiteral(ret);
+ }
+
+ return ret;
+ } else {
+ return fn;
+ }
+ },
+
+ preamble: function() {
+ // track the last context pushed into place to allow skipping the
+ // getContext opcode when it would be a noop
+ this.lastContext = 0;
+ this.source = [];
+ },
+
+ createFunctionContext: function(asObject) {
+ var varDeclarations = '';
+
+ var locals = this.stackVars.concat(this.registers.list);
+ if(locals.length > 0) {
+ varDeclarations += ", " + locals.join(", ");
+ }
+
+ // Generate minimizer alias mappings
+ for (var alias in this.aliases) {
+ if (this.aliases.hasOwnProperty(alias)) {
+ varDeclarations += ', ' + alias + '=' + this.aliases[alias];
+ }
+ }
+
+ var params = ["depth0", "helpers", "partials", "data"];
+
+ if (this.useDepths) {
+ params.push('depths');
+ }
+
+ // Perform a second pass over the output to merge content when possible
+ var source = this.mergeSource(varDeclarations);
+
+ if (asObject) {
+ params.push(source);
+
+ return Function.apply(this, params);
+ } else {
+ return 'function(' + params.join(',') + ') {\n ' + source + '}';
+ }
+ },
+ mergeSource: function(varDeclarations) {
+ var source = '',
+ buffer,
+ appendOnly = !this.forceBuffer,
+ appendFirst;
+
+ for (var i = 0, len = this.source.length; i < len; i++) {
+ var line = this.source[i];
+ if (line.appendToBuffer) {
+ if (buffer) {
+ buffer = buffer + '\n + ' + line.content;
+ } else {
+ buffer = line.content;
+ }
+ } else {
+ if (buffer) {
+ if (!source) {
+ appendFirst = true;
+ source = buffer + ';\n ';
+ } else {
+ source += 'buffer += ' + buffer + ';\n ';
+ }
+ buffer = undefined;
+ }
+ source += line + '\n ';
+
+ if (!this.environment.isSimple) {
+ appendOnly = false;
+ }
+ }
+ }
+
+ if (appendOnly) {
+ if (buffer || !source) {
+ source += 'return ' + (buffer || '""') + ';\n';
+ }
+ } else {
+ varDeclarations += ", buffer = " + (appendFirst ? '' : this.initializeBuffer());
+ if (buffer) {
+ source += 'return buffer + ' + buffer + ';\n';
+ } else {
+ source += 'return buffer;\n';
+ }
+ }
+
+ if (varDeclarations) {
+ source = 'var ' + varDeclarations.substring(2) + (appendFirst ? '' : ';\n ') + source;
+ }
+
+ return source;
+ },
+
+ // [blockValue]
+ //
+ // On stack, before: hash, inverse, program, value
+ // On stack, after: return value of blockHelperMissing
+ //
+ // The purpose of this opcode is to take a block of the form
+ // `{{#this.foo}}...{{/this.foo}}`, resolve the value of `foo`, and
+ // replace it on the stack with the result of properly
+ // invoking blockHelperMissing.
+ blockValue: function(name) {
+ this.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
+
+ var params = [this.contextName(0)];
+ this.setupParams(name, 0, params);
+
+ var blockName = this.popStack();
+ params.splice(1, 0, blockName);
+
+ this.push('blockHelperMissing.call(' + params.join(', ') + ')');
+ },
+
+ // [ambiguousBlockValue]
+ //
+ // On stack, before: hash, inverse, program, value
+ // Compiler value, before: lastHelper=value of last found helper, if any
+ // On stack, after, if no lastHelper: same as [blockValue]
+ // On stack, after, if lastHelper: value
+ ambiguousBlockValue: function() {
+ this.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
+
+ // We're being a bit cheeky and reusing the options value from the prior exec
+ var params = [this.contextName(0)];
+ this.setupParams('', 0, params, true);
+
+ this.flushInline();
+
+ var current = this.topStack();
+ params.splice(1, 0, current);
+
+ this.pushSource("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
+ },
+
+ // [appendContent]
+ //
+ // On stack, before: ...
+ // On stack, after: ...
+ //
+ // Appends the string value of `content` to the current buffer
+ appendContent: function(content) {
+ if (this.pendingContent) {
+ content = this.pendingContent + content;
+ }
+
+ this.pendingContent = content;
+ },
+
+ // [append]
+ //
+ // On stack, before: value, ...
+ // On stack, after: ...
+ //
+ // Coerces `value` to a String and appends it to the current buffer.
+ //
+ // If `value` is truthy, or 0, it is coerced into a string and appended
+ // Otherwise, the empty string is appended
+ append: function() {
+ // Force anything that is inlined onto the stack so we don't have duplication
+ // when we examine local
+ this.flushInline();
+ var local = this.popStack();
+ this.pushSource('if (' + local + ' != null) { ' + this.appendToBuffer(local) + ' }');
+ if (this.environment.isSimple) {
+ this.pushSource("else { " + this.appendToBuffer("''") + " }");
+ }
+ },
+
+ // [appendEscaped]
+ //
+ // On stack, before: value, ...
+ // On stack, after: ...
+ //
+ // Escape `value` and append it to the buffer
+ appendEscaped: function() {
+ this.aliases.escapeExpression = 'this.escapeExpression';
+
+ this.pushSource(this.appendToBuffer("escapeExpression(" + this.popStack() + ")"));
+ },
+
+ // [getContext]
+ //
+ // On stack, before: ...
+ // On stack, after: ...
+ // Compiler value, after: lastContext=depth
+ //
+ // Set the value of the `lastContext` compiler value to the depth
+ getContext: function(depth) {
+ this.lastContext = depth;
+ },
+
+ // [pushContext]
+ //
+ // On stack, before: ...
+ // On stack, after: currentContext, ...
+ //
+ // Pushes the value of the current context onto the stack.
+ pushContext: function() {
+ this.pushStackLiteral(this.contextName(this.lastContext));
+ },
+
+ // [lookupOnContext]
+ //
+ // On stack, before: ...
+ // On stack, after: currentContext[name], ...
+ //
+ // Looks up the value of `name` on the current context and pushes
+ // it onto the stack.
+ lookupOnContext: function(parts, falsy, scoped) {
+ /*jshint -W083 */
+ var i = 0,
+ len = parts.length;
+
+ if (!scoped && this.options.compat && !this.lastContext) {
+ // The depthed query is expected to handle the undefined logic for the root level that
+ // is implemented below, so we evaluate that directly in compat mode
+ this.push(this.depthedLookup(parts[i++]));
+ } else {
+ this.pushContext();
+ }
+
+ for (; i < len; i++) {
+ this.replaceStack(function(current) {
+ var lookup = this.nameLookup(current, parts[i], 'context');
+ // We want to ensure that zero and false are handled properly if the context (falsy flag)
+ // needs to have the special handling for these values.
+ if (!falsy) {
+ return ' != null ? ' + lookup + ' : ' + current;
+ } else {
+ // Otherwise we can use generic falsy handling
+ return ' && ' + lookup;
+ }
+ });
+ }
+ },
+
+ // [lookupData]
+ //
+ // On stack, before: ...
+ // On stack, after: data, ...
+ //
+ // Push the data lookup operator
+ lookupData: function(depth, parts) {
+ /*jshint -W083 */
+ if (!depth) {
+ this.pushStackLiteral('data');
+ } else {
+ this.pushStackLiteral('this.data(data, ' + depth + ')');
+ }
+
+ var len = parts.length;
+ for (var i = 0; i < len; i++) {
+ this.replaceStack(function(current) {
+ return ' && ' + this.nameLookup(current, parts[i], 'data');
+ });
+ }
+ },
+
+ // [resolvePossibleLambda]
+ //
+ // On stack, before: value, ...
+ // On stack, after: resolved value, ...
+ //
+ // If the `value` is a lambda, replace it on the stack by
+ // the return value of the lambda
+ resolvePossibleLambda: function() {
+ this.aliases.lambda = 'this.lambda';
+
+ this.push('lambda(' + this.popStack() + ', ' + this.contextName(0) + ')');
+ },
+
+ // [pushStringParam]
+ //
+ // On stack, before: ...
+ // On stack, after: string, currentContext, ...
+ //
+ // This opcode is designed for use in string mode, which
+ // provides the string value of a parameter along with its
+ // depth rather than resolving it immediately.
+ pushStringParam: function(string, type) {
+ this.pushContext();
+ this.pushString(type);
+
+ // If it's a subexpression, the string result
+ // will be pushed after this opcode.
+ if (type !== 'sexpr') {
+ if (typeof string === 'string') {
+ this.pushString(string);
+ } else {
+ this.pushStackLiteral(string);
+ }
+ }
+ },
+
+ emptyHash: function() {
+ this.pushStackLiteral('{}');
+
+ if (this.trackIds) {
+ this.push('{}'); // hashIds
+ }
+ if (this.stringParams) {
+ this.push('{}'); // hashContexts
+ this.push('{}'); // hashTypes
+ }
+ },
+ pushHash: function() {
+ if (this.hash) {
+ this.hashes.push(this.hash);
+ }
+ this.hash = {values: [], types: [], contexts: [], ids: []};
+ },
+ popHash: function() {
+ var hash = this.hash;
+ this.hash = this.hashes.pop();
+
+ if (this.trackIds) {
+ this.push('{' + hash.ids.join(',') + '}');
+ }
+ if (this.stringParams) {
+ this.push('{' + hash.contexts.join(',') + '}');
+ this.push('{' + hash.types.join(',') + '}');
+ }
+
+ this.push('{\n ' + hash.values.join(',\n ') + '\n }');
+ },
+
+ // [pushString]
+ //
+ // On stack, before: ...
+ // On stack, after: quotedString(string), ...
+ //
+ // Push a quoted version of `string` onto the stack
+ pushString: function(string) {
+ this.pushStackLiteral(this.quotedString(string));
+ },
+
+ // [push]
+ //
+ // On stack, before: ...
+ // On stack, after: expr, ...
+ //
+ // Push an expression onto the stack
+ push: function(expr) {
+ this.inlineStack.push(expr);
+ return expr;
+ },
+
+ // [pushLiteral]
+ //
+ // On stack, before: ...
+ // On stack, after: value, ...
+ //
+ // Pushes a value onto the stack. This operation prevents
+ // the compiler from creating a temporary variable to hold
+ // it.
+ pushLiteral: function(value) {
+ this.pushStackLiteral(value);
+ },
+
+ // [pushProgram]
+ //
+ // On stack, before: ...
+ // On stack, after: program(guid), ...
+ //
+ // Push a program expression onto the stack. This takes
+ // a compile-time guid and converts it into a runtime-accessible
+ // expression.
+ pushProgram: function(guid) {
+ if (guid != null) {
+ this.pushStackLiteral(this.programExpression(guid));
+ } else {
+ this.pushStackLiteral(null);
+ }
+ },
+
+ // [invokeHelper]
+ //
+ // On stack, before: hash, inverse, program, params..., ...
+ // On stack, after: result of helper invocation
+ //
+ // Pops off the helper's parameters, invokes the helper,
+ // and pushes the helper's return value onto the stack.
+ //
+ // If the helper is not found, `helperMissing` is called.
+ invokeHelper: function(paramSize, name, isSimple) {
+ this.aliases.helperMissing = 'helpers.helperMissing';
+
+ var nonHelper = this.popStack();
+ var helper = this.setupHelper(paramSize, name);
+
+ var lookup = (isSimple ? helper.name + ' || ' : '') + nonHelper + ' || helperMissing';
+ this.push('((' + lookup + ').call(' + helper.callParams + '))');
+ },
+
+ // [invokeKnownHelper]
+ //
+ // On stack, before: hash, inverse, program, params..., ...
+ // On stack, after: result of helper invocation
+ //
+ // This operation is used when the helper is known to exist,
+ // so a `helperMissing` fallback is not required.
+ invokeKnownHelper: function(paramSize, name) {
+ var helper = this.setupHelper(paramSize, name);
+ this.push(helper.name + ".call(" + helper.callParams + ")");
+ },
+
+ // [invokeAmbiguous]
+ //
+ // On stack, before: hash, inverse, program, params..., ...
+ // On stack, after: result of disambiguation
+ //
+ // This operation is used when an expression like `{{foo}}`
+ // is provided, but we don't know at compile-time whether it
+ // is a helper or a path.
+ //
+ // This operation emits more code than the other options,
+ // and can be avoided by passing the `knownHelpers` and
+ // `knownHelpersOnly` flags at compile-time.
+ invokeAmbiguous: function(name, helperCall) {
+ this.aliases.functionType = '"function"';
+ this.aliases.helperMissing = 'helpers.helperMissing';
+ this.useRegister('helper');
+
+ var nonHelper = this.popStack();
+
+ this.emptyHash();
+ var helper = this.setupHelper(0, name, helperCall);
+
+ var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
+
+ this.push(
+ '((helper = (helper = ' + helperName + ' || ' + nonHelper + ') != null ? helper : helperMissing'
+ + (helper.paramsInit ? '),(' + helper.paramsInit : '') + '),'
+ + '(typeof helper === functionType ? helper.call(' + helper.callParams + ') : helper))');
+ },
+
+ // [invokePartial]
+ //
+ // On stack, before: context, ...
+ // On stack after: result of partial invocation
+ //
+ // This operation pops off a context, invokes a partial with that context,
+ // and pushes the result of the invocation back.
+ invokePartial: function(name, indent) {
+ var params = [this.nameLookup('partials', name, 'partial'), "'" + indent + "'", "'" + name + "'", this.popStack(), this.popStack(), "helpers", "partials"];
+
+ if (this.options.data) {
+ params.push("data");
+ } else if (this.options.compat) {
+ params.push('undefined');
+ }
+ if (this.options.compat) {
+ params.push('depths');
+ }
+
+ this.push("this.invokePartial(" + params.join(", ") + ")");
+ },
+
+ // [assignToHash]
+ //
+ // On stack, before: value, ..., hash, ...
+ // On stack, after: ..., hash, ...
+ //
+ // Pops a value off the stack and assigns it to the current hash
+ assignToHash: function(key) {
+ var value = this.popStack(),
+ context,
+ type,
+ id;
+
+ if (this.trackIds) {
+ id = this.popStack();
+ }
+ if (this.stringParams) {
+ type = this.popStack();
+ context = this.popStack();
+ }
+
+ var hash = this.hash;
+ if (context) {
+ hash.contexts.push("'" + key + "': " + context);
+ }
+ if (type) {
+ hash.types.push("'" + key + "': " + type);
+ }
+ if (id) {
+ hash.ids.push("'" + key + "': " + id);
+ }
+ hash.values.push("'" + key + "': (" + value + ")");
+ },
+
+ pushId: function(type, name) {
+ if (type === 'ID' || type === 'DATA') {
+ this.pushString(name);
+ } else if (type === 'sexpr') {
+ this.pushStackLiteral('true');
+ } else {
+ this.pushStackLiteral('null');
+ }
+ },
+
+ // HELPERS
+
+ compiler: JavaScriptCompiler,
+
+ compileChildren: function(environment, options) {
+ var children = environment.children, child, compiler;
+
+ for(var i=0, l=children.length; i<l; i++) {
+ child = children[i];
+ compiler = new this.compiler();
+
+ var index = this.matchExistingProgram(child);
+
+ if (index == null) {
+ this.context.programs.push(''); // Placeholder to prevent name conflicts for nested children
+ index = this.context.programs.length;
+ child.index = index;
+ child.name = 'program' + index;
+ this.context.programs[index] = compiler.compile(child, options, this.context, !this.precompile);
+ this.context.environments[index] = child;
+
+ this.useDepths = this.useDepths || compiler.useDepths;
+ } else {
+ child.index = index;
+ child.name = 'program' + index;
+ }
+ }
+ },
+ matchExistingProgram: function(child) {
+ for (var i = 0, len = this.context.environments.length; i < len; i++) {
+ var environment = this.context.environments[i];
+ if (environment && environment.equals(child)) {
+ return i;
+ }
+ }
+ },
+
+ programExpression: function(guid) {
+ var child = this.environment.children[guid],
+ depths = child.depths.list,
+ useDepths = this.useDepths,
+ depth;
+
+ var programParams = [child.index, 'data'];
+
+ if (useDepths) {
+ programParams.push('depths');
+ }
+
+ return 'this.program(' + programParams.join(', ') + ')';
+ },
+
+ useRegister: function(name) {
+ if(!this.registers[name]) {
+ this.registers[name] = true;
+ this.registers.list.push(name);
+ }
+ },
+
+ pushStackLiteral: function(item) {
+ return this.push(new Literal(item));
+ },
+
+ pushSource: function(source) {
+ if (this.pendingContent) {
+ this.source.push(this.appendToBuffer(this.quotedString(this.pendingContent)));
+ this.pendingContent = undefined;
+ }
+
+ if (source) {
+ this.source.push(source);
+ }
+ },
+
+ pushStack: function(item) {
+ this.flushInline();
+
+ var stack = this.incrStack();
+ this.pushSource(stack + " = " + item + ";");
+ this.compileStack.push(stack);
+ return stack;
+ },
+
+ replaceStack: function(callback) {
+ var prefix = '',
+ inline = this.isInline(),
+ stack,
+ createdStack,
+ usedLiteral;
+
+ /* istanbul ignore next */
+ Iif (!this.isInline()) {
+ throw new Exception('replaceStack on non-inline');
+ }
+
+ // We want to merge the inline statement into the replacement statement via ','
+ var top = this.popStack(true);
+
+ if (top instanceof Literal) {
+ // Literals do not need to be inlined
+ prefix = stack = top.value;
+ usedLiteral = true;
+ } else {
+ // Get or create the current stack name for use by the inline
+ createdStack = !this.stackSlot;
+ var name = !createdStack ? this.topStackName() : this.incrStack();
+
+ prefix = '(' + this.push(name) + ' = ' + top + ')';
+ stack = this.topStack();
+ }
+
+ var item = callback.call(this, stack);
+
+ if (!usedLiteral) {
+ this.popStack();
+ }
+ if (createdStack) {
+ this.stackSlot--;
+ }
+ this.push('(' + prefix + item + ')');
+ },
+
+ incrStack: function() {
+ this.stackSlot++;
+ if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
+ return this.topStackName();
+ },
+ topStackName: function() {
+ return "stack" + this.stackSlot;
+ },
+ flushInline: function() {
+ var inlineStack = this.inlineStack;
+ if (inlineStack.length) {
+ this.inlineStack = [];
+ for (var i = 0, len = inlineStack.length; i < len; i++) {
+ var entry = inlineStack[i];
+ Iif (entry instanceof Literal) {
+ this.compileStack.push(entry);
+ } else {
+ this.pushStack(entry);
+ }
+ }
+ }
+ },
+ isInline: function() {
+ return this.inlineStack.length;
+ },
+
+ popStack: function(wrapped) {
+ var inline = this.isInline(),
+ item = (inline ? this.inlineStack : this.compileStack).pop();
+
+ if (!wrapped && (item instanceof Literal)) {
+ return item.value;
+ } else {
+ if (!inline) {
+ /* istanbul ignore next */
+ Iif (!this.stackSlot) {
+ throw new Exception('Invalid stack pop');
+ }
+ this.stackSlot--;
+ }
+ return item;
+ }
+ },
+
+ topStack: function() {
+ var stack = (this.isInline() ? this.inlineStack : this.compileStack),
+ item = stack[stack.length - 1];
+
+ Iif (item instanceof Literal) {
+ return item.value;
+ } else {
+ return item;
+ }
+ },
+
+ contextName: function(context) {
+ if (this.useDepths && context) {
+ return 'depths[' + context + ']';
+ } else {
+ return 'depth' + context;
+ }
+ },
+
+ quotedString: function(str) {
+ return '"' + str
+ .replace(/\\/g, '\\\\')
+ .replace(/"/g, '\\"')
+ .replace(/\n/g, '\\n')
+ .replace(/\r/g, '\\r')
+ .replace(/\u2028/g, '\\u2028') // Per Ecma-262 7.3 + 7.8.4
+ .replace(/\u2029/g, '\\u2029') + '"';
+ },
+
+ objectLiteral: function(obj) {
+ var pairs = [];
+
+ for (var key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ pairs.push(this.quotedString(key) + ':' + obj[key]);
+ }
+ }
+
+ return '{' + pairs.join(',') + '}';
+ },
+
+ setupHelper: function(paramSize, name, blockHelper) {
+ var params = [],
+ paramsInit = this.setupParams(name, paramSize, params, blockHelper);
+ var foundHelper = this.nameLookup('helpers', name, 'helper');
+
+ return {
+ params: params,
+ paramsInit: paramsInit,
+ name: foundHelper,
+ callParams: [this.contextName(0)].concat(params).join(", ")
+ };
+ },
+
+ setupOptions: function(helper, paramSize, params) {
+ var options = {}, contexts = [], types = [], ids = [], param, inverse, program;
+
+ options.name = this.quotedString(helper);
+ options.hash = this.popStack();
+
+ if (this.trackIds) {
+ options.hashIds = this.popStack();
+ }
+ if (this.stringParams) {
+ options.hashTypes = this.popStack();
+ options.hashContexts = this.popStack();
+ }
+
+ inverse = this.popStack();
+ program = this.popStack();
+
+ // Avoid setting fn and inverse if neither are set. This allows
+ // helpers to do a check for `if (options.fn)`
+ if (program || inverse) {
+ if (!program) {
+ program = 'this.noop';
+ }
+
+ if (!inverse) {
+ inverse = 'this.noop';
+ }
+
+ options.fn = program;
+ options.inverse = inverse;
+ }
+
+ // The parameters go on to the stack in order (making sure that they are evaluated in order)
+ // so we need to pop them off the stack in reverse order
+ var i = paramSize;
+ while (i--) {
+ param = this.popStack();
+ params[i] = param;
+
+ if (this.trackIds) {
+ ids[i] = this.popStack();
+ }
+ if (this.stringParams) {
+ types[i] = this.popStack();
+ contexts[i] = this.popStack();
+ }
+ }
+
+ if (this.trackIds) {
+ options.ids = "[" + ids.join(",") + "]";
+ }
+ if (this.stringParams) {
+ options.types = "[" + types.join(",") + "]";
+ options.contexts = "[" + contexts.join(",") + "]";
+ }
+
+ if (this.options.data) {
+ options.data = "data";
+ }
+
+ return options;
+ },
+
+ // the params and contexts arguments are passed in arrays
+ // to fill in
+ setupParams: function(helperName, paramSize, params, useRegister) {
+ var options = this.objectLiteral(this.setupOptions(helperName, paramSize, params));
+
+ if (useRegister) {
+ this.useRegister('options');
+ params.push('options');
+ return 'options=' + options;
+ } else {
+ params.push(options);
+ return '';
+ }
+ }
+};
+
+var reservedWords = (
+ "break else new var" +
+ " case finally return void" +
+ " catch for switch while" +
+ " continue function this with" +
+ " default if throw" +
+ " delete in try" +
+ " do instanceof typeof" +
+ " abstract enum int short" +
+ " boolean export interface static" +
+ " byte extends long super" +
+ " char final native synchronized" +
+ " class float package throws" +
+ " const goto private transient" +
+ " debugger implements protected volatile" +
+ " double import public let yield"
+).split(" ");
+
+var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
+
+for(var i=0, l=reservedWords.length; i<l; i++) {
+ compilerWords[reservedWords[i]] = true;
+}
+
+JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
+ return !JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(name);
+};
+
+exports["default"] = JavaScriptCompiler; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 | + + + +1 +1 + + + + + + +26939 +26939 +1026 +1 +1692 +1692 +952 +952 +601 +601 +4 +4 +95 +95 +1609 +1609 +36 +36 +5 +4 +5 +5 +523 +521 +80 +80 +531 +531 +80 +80 +62 +62 +603 +603 +914 +914 +38 +38 +6 +6 +89 +89 +1584 +1584 +40 +40 +390 +390 +55 +55 +53 +53 +54 +54 +34 +34 +52 +52 +74 +74 +119 +119 +91 +91 +2 +2 +2 +2 +74 +74 +2752 +2744 +341 +341 +2752 +2752 +1722 +1722 +3297 +3297 +1586 +1586 +513 +513 +74 +74 +45 +45 + + + + + +12 + + +1049 +1049 +1049 +1049 +1049 +1049 +1 +1049 +1049 +1049 +1049 +1 +1 +1 +1 +1 + +1 +11342 +11342 +11342 +7 + +11342 + +1049 +1049 +38270 +38270 +1159 + +37111 +11342 + +37111 + +38270 +12 +12 +12 +12 +82 +82 + +12 +12 + +1 + +12 + + +38258 +1 + +38258 + +11319 +11319 +11319 +11319 +11319 +11319 +11319 +11319 +11319 +11319 +11319 +1 + +1 +1 + +11319 + +26939 +26939 +26939 +26939 +1 + +26939 +26928 +1026 + +25902 +20448 +20448 +20448 + +25902 +25902 +25902 +25902 +25902 +25902 + +1 + + +1 + + + +1 +1 + +1 +1 + +1 + + + +1116 +1116 +1116 +1116 +1116 +1116 +1116 +1116 +1116 + + +1 +1 +1 +1 +1 +1 +1 +1 +1 +1 + +1 + +1 + +1 +1 + + +1 +1 + +1 +1 + +1 +1 +1 +1 + +1 +1 + +1 + + + + + + + +1 +1 + +1 + + +1 +1 + + +1 + + +12 +12 + + +12 +12 +12 + +12 + + +12 +12 +12 + + +13951 +1 + +13951 + +13951 + + + + + +13951 +13951 +13951 + +13951 +13951 +221226 +221226 +13951 +13951 +13951 + + +13951 +13951 +13951 +13951 + + + +13951 +13951 +13951 +13951 +13951 +1 + +13951 +13951 +13951 +13951 +13951 +13951 +2151 + +1 +1 + +1 + + + + +13951 +13951 +11800 + +2151 + + + +2483 + + +2474 + + +13951 + + +1 + + +1 + +1 +1 + + +1 +141 + + + +13951 +13951 + +2476 +10 +10 +2466 +10 +10 + +2456 + +2476 + +1275 +426 +1 + +10 +10 + +1 + +5 +5 +5 + +1 +5 +1 +2 +1 +62 +1 +62 +1 +5 +1 + +5 +5 +5 + +1 +100 +1 +532 +1 +604 +1 +44 +1 +22 +1 +81 +1 +1 +1 +42 +1 +23 +1 +2 +2 +37 +1 +973 +1 +131 +1 +73 +1 +59 +1 +355 +1 + +874 +42 +1 +2305 +1 +61 +1 +6 +1 +79 +1 +42 +1 +18 +1 +61 +1 +3208 +1 +15 +1 +9 +1 +1094 +1 + + +1 +1 +1 +1 +1 +1 +1 + | "use strict";
+/* jshint ignore:start */
+/* istanbul ignore next */
+/* Jison generated parser */
+var handlebars = (function(){
+var parser = {trace: function trace() { },
+yy: {},
+symbols_: {"error":2,"root":3,"program":4,"EOF":5,"program_repetition0":6,"statement":7,"mustache":8,"block":9,"rawBlock":10,"partial":11,"CONTENT":12,"COMMENT":13,"openRawBlock":14,"END_RAW_BLOCK":15,"OPEN_RAW_BLOCK":16,"sexpr":17,"CLOSE_RAW_BLOCK":18,"openBlock":19,"block_option0":20,"closeBlock":21,"openInverse":22,"block_option1":23,"OPEN_BLOCK":24,"CLOSE":25,"OPEN_INVERSE":26,"inverseAndProgram":27,"INVERSE":28,"OPEN_ENDBLOCK":29,"path":30,"OPEN":31,"OPEN_UNESCAPED":32,"CLOSE_UNESCAPED":33,"OPEN_PARTIAL":34,"partialName":35,"param":36,"partial_option0":37,"partial_option1":38,"sexpr_repetition0":39,"sexpr_option0":40,"dataName":41,"STRING":42,"NUMBER":43,"BOOLEAN":44,"OPEN_SEXPR":45,"CLOSE_SEXPR":46,"hash":47,"hash_repetition_plus0":48,"hashSegment":49,"ID":50,"EQUALS":51,"DATA":52,"pathSegments":53,"SEP":54,"$accept":0,"$end":1},
+terminals_: {2:"error",5:"EOF",12:"CONTENT",13:"COMMENT",15:"END_RAW_BLOCK",16:"OPEN_RAW_BLOCK",18:"CLOSE_RAW_BLOCK",24:"OPEN_BLOCK",25:"CLOSE",26:"OPEN_INVERSE",28:"INVERSE",29:"OPEN_ENDBLOCK",31:"OPEN",32:"OPEN_UNESCAPED",33:"CLOSE_UNESCAPED",34:"OPEN_PARTIAL",42:"STRING",43:"NUMBER",44:"BOOLEAN",45:"OPEN_SEXPR",46:"CLOSE_SEXPR",50:"ID",51:"EQUALS",52:"DATA",54:"SEP"},
+productions_: [0,[3,2],[4,1],[7,1],[7,1],[7,1],[7,1],[7,1],[7,1],[10,3],[14,3],[9,4],[9,4],[19,3],[22,3],[27,2],[21,3],[8,3],[8,3],[11,5],[11,4],[17,3],[17,1],[36,1],[36,1],[36,1],[36,1],[36,1],[36,3],[47,1],[49,3],[35,1],[35,1],[35,1],[41,2],[30,1],[53,3],[53,1],[6,0],[6,2],[20,0],[20,1],[23,0],[23,1],[37,0],[37,1],[38,0],[38,1],[39,0],[39,2],[40,0],[40,1],[48,1],[48,2]],
+performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) {
+
+var $0 = $$.length - 1;
+switch (yystate) {
+case 1: yy.prepareProgram($$[$0-1].statements, true); return $$[$0-1];
+break;
+case 2:this.$ = new yy.ProgramNode(yy.prepareProgram($$[$0]), {}, this._$);
+break;
+case 3:this.$ = $$[$0];
+break;
+case 4:this.$ = $$[$0];
+break;
+case 5:this.$ = $$[$0];
+break;
+case 6:this.$ = $$[$0];
+break;
+case 7:this.$ = new yy.ContentNode($$[$0], this._$);
+break;
+case 8:this.$ = new yy.CommentNode($$[$0], this._$);
+break;
+case 9:this.$ = new yy.RawBlockNode($$[$0-2], $$[$0-1], $$[$0], this._$);
+break;
+case 10:this.$ = new yy.MustacheNode($$[$0-1], null, '', '', this._$);
+break;
+case 11:this.$ = yy.prepareBlock($$[$0-3], $$[$0-2], $$[$0-1], $$[$0], false, this._$);
+break;
+case 12:this.$ = yy.prepareBlock($$[$0-3], $$[$0-2], $$[$0-1], $$[$0], true, this._$);
+break;
+case 13:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], yy.stripFlags($$[$0-2], $$[$0]), this._$);
+break;
+case 14:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], yy.stripFlags($$[$0-2], $$[$0]), this._$);
+break;
+case 15:this.$ = { strip: yy.stripFlags($$[$0-1], $$[$0-1]), program: $$[$0] };
+break;
+case 16:this.$ = {path: $$[$0-1], strip: yy.stripFlags($$[$0-2], $$[$0])};
+break;
+case 17:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], yy.stripFlags($$[$0-2], $$[$0]), this._$);
+break;
+case 18:this.$ = new yy.MustacheNode($$[$0-1], null, $$[$0-2], yy.stripFlags($$[$0-2], $$[$0]), this._$);
+break;
+case 19:this.$ = new yy.PartialNode($$[$0-3], $$[$0-2], $$[$0-1], yy.stripFlags($$[$0-4], $$[$0]), this._$);
+break;
+case 20:this.$ = new yy.PartialNode($$[$0-2], undefined, $$[$0-1], yy.stripFlags($$[$0-3], $$[$0]), this._$);
+break;
+case 21:this.$ = new yy.SexprNode([$$[$0-2]].concat($$[$0-1]), $$[$0], this._$);
+break;
+case 22:this.$ = new yy.SexprNode([$$[$0]], null, this._$);
+break;
+case 23:this.$ = $$[$0];
+break;
+case 24:this.$ = new yy.StringNode($$[$0], this._$);
+break;
+case 25:this.$ = new yy.NumberNode($$[$0], this._$);
+break;
+case 26:this.$ = new yy.BooleanNode($$[$0], this._$);
+break;
+case 27:this.$ = $$[$0];
+break;
+case 28:$$[$0-1].isHelper = true; this.$ = $$[$0-1];
+break;
+case 29:this.$ = new yy.HashNode($$[$0], this._$);
+break;
+case 30:this.$ = [$$[$0-2], $$[$0]];
+break;
+case 31:this.$ = new yy.PartialNameNode($$[$0], this._$);
+break;
+case 32:this.$ = new yy.PartialNameNode(new yy.StringNode($$[$0], this._$), this._$);
+break;
+case 33:this.$ = new yy.PartialNameNode(new yy.NumberNode($$[$0], this._$));
+break;
+case 34:this.$ = new yy.DataNode($$[$0], this._$);
+break;
+case 35:this.$ = new yy.IdNode($$[$0], this._$);
+break;
+case 36: $$[$0-2].push({part: $$[$0], separator: $$[$0-1]}); this.$ = $$[$0-2];
+break;
+case 37:this.$ = [{part: $$[$0]}];
+break;
+case 38:this.$ = [];
+break;
+case 39:$$[$0-1].push($$[$0]);
+break;
+case 48:this.$ = [];
+break;
+case 49:$$[$0-1].push($$[$0]);
+break;
+case 52:this.$ = [$$[$0]];
+break;
+case 53:$$[$0-1].push($$[$0]);
+break;
+}
+},
+table: [{3:1,4:2,5:[2,38],6:3,12:[2,38],13:[2,38],16:[2,38],24:[2,38],26:[2,38],31:[2,38],32:[2,38],34:[2,38]},{1:[3]},{5:[1,4]},{5:[2,2],7:5,8:6,9:7,10:8,11:9,12:[1,10],13:[1,11],14:16,16:[1,20],19:14,22:15,24:[1,18],26:[1,19],28:[2,2],29:[2,2],31:[1,12],32:[1,13],34:[1,17]},{1:[2,1]},{5:[2,39],12:[2,39],13:[2,39],16:[2,39],24:[2,39],26:[2,39],28:[2,39],29:[2,39],31:[2,39],32:[2,39],34:[2,39]},{5:[2,3],12:[2,3],13:[2,3],16:[2,3],24:[2,3],26:[2,3],28:[2,3],29:[2,3],31:[2,3],32:[2,3],34:[2,3]},{5:[2,4],12:[2,4],13:[2,4],16:[2,4],24:[2,4],26:[2,4],28:[2,4],29:[2,4],31:[2,4],32:[2,4],34:[2,4]},{5:[2,5],12:[2,5],13:[2,5],16:[2,5],24:[2,5],26:[2,5],28:[2,5],29:[2,5],31:[2,5],32:[2,5],34:[2,5]},{5:[2,6],12:[2,6],13:[2,6],16:[2,6],24:[2,6],26:[2,6],28:[2,6],29:[2,6],31:[2,6],32:[2,6],34:[2,6]},{5:[2,7],12:[2,7],13:[2,7],16:[2,7],24:[2,7],26:[2,7],28:[2,7],29:[2,7],31:[2,7],32:[2,7],34:[2,7]},{5:[2,8],12:[2,8],13:[2,8],16:[2,8],24:[2,8],26:[2,8],28:[2,8],29:[2,8],31:[2,8],32:[2,8],34:[2,8]},{17:21,30:22,41:23,50:[1,26],52:[1,25],53:24},{17:27,30:22,41:23,50:[1,26],52:[1,25],53:24},{4:28,6:3,12:[2,38],13:[2,38],16:[2,38],24:[2,38],26:[2,38],28:[2,38],29:[2,38],31:[2,38],32:[2,38],34:[2,38]},{4:29,6:3,12:[2,38],13:[2,38],16:[2,38],24:[2,38],26:[2,38],28:[2,38],29:[2,38],31:[2,38],32:[2,38],34:[2,38]},{12:[1,30]},{30:32,35:31,42:[1,33],43:[1,34],50:[1,26],53:24},{17:35,30:22,41:23,50:[1,26],52:[1,25],53:24},{17:36,30:22,41:23,50:[1,26],52:[1,25],53:24},{17:37,30:22,41:23,50:[1,26],52:[1,25],53:24},{25:[1,38]},{18:[2,48],25:[2,48],33:[2,48],39:39,42:[2,48],43:[2,48],44:[2,48],45:[2,48],46:[2,48],50:[2,48],52:[2,48]},{18:[2,22],25:[2,22],33:[2,22],46:[2,22]},{18:[2,35],25:[2,35],33:[2,35],42:[2,35],43:[2,35],44:[2,35],45:[2,35],46:[2,35],50:[2,35],52:[2,35],54:[1,40]},{30:41,50:[1,26],53:24},{18:[2,37],25:[2,37],33:[2,37],42:[2,37],43:[2,37],44:[2,37],45:[2,37],46:[2,37],50:[2,37],52:[2,37],54:[2,37]},{33:[1,42]},{20:43,27:44,28:[1,45],29:[2,40]},{23:46,27:47,28:[1,45],29:[2,42]},{15:[1,48]},{25:[2,46],30:51,36:49,38:50,41:55,42:[1,52],43:[1,53],44:[1,54],45:[1,56],47:57,48:58,49:60,50:[1,59],52:[1,25],53:24},{25:[2,31],42:[2,31],43:[2,31],44:[2,31],45:[2,31],50:[2,31],52:[2,31]},{25:[2,32],42:[2,32],43:[2,32],44:[2,32],45:[2,32],50:[2,32],52:[2,32]},{25:[2,33],42:[2,33],43:[2,33],44:[2,33],45:[2,33],50:[2,33],52:[2,33]},{25:[1,61]},{25:[1,62]},{18:[1,63]},{5:[2,17],12:[2,17],13:[2,17],16:[2,17],24:[2,17],26:[2,17],28:[2,17],29:[2,17],31:[2,17],32:[2,17],34:[2,17]},{18:[2,50],25:[2,50],30:51,33:[2,50],36:65,40:64,41:55,42:[1,52],43:[1,53],44:[1,54],45:[1,56],46:[2,50],47:66,48:58,49:60,50:[1,59],52:[1,25],53:24},{50:[1,67]},{18:[2,34],25:[2,34],33:[2,34],42:[2,34],43:[2,34],44:[2,34],45:[2,34],46:[2,34],50:[2,34],52:[2,34]},{5:[2,18],12:[2,18],13:[2,18],16:[2,18],24:[2,18],26:[2,18],28:[2,18],29:[2,18],31:[2,18],32:[2,18],34:[2,18]},{21:68,29:[1,69]},{29:[2,41]},{4:70,6:3,12:[2,38],13:[2,38],16:[2,38],24:[2,38],26:[2,38],29:[2,38],31:[2,38],32:[2,38],34:[2,38]},{21:71,29:[1,69]},{29:[2,43]},{5:[2,9],12:[2,9],13:[2,9],16:[2,9],24:[2,9],26:[2,9],28:[2,9],29:[2,9],31:[2,9],32:[2,9],34:[2,9]},{25:[2,44],37:72,47:73,48:58,49:60,50:[1,74]},{25:[1,75]},{18:[2,23],25:[2,23],33:[2,23],42:[2,23],43:[2,23],44:[2,23],45:[2,23],46:[2,23],50:[2,23],52:[2,23]},{18:[2,24],25:[2,24],33:[2,24],42:[2,24],43:[2,24],44:[2,24],45:[2,24],46:[2,24],50:[2,24],52:[2,24]},{18:[2,25],25:[2,25],33:[2,25],42:[2,25],43:[2,25],44:[2,25],45:[2,25],46:[2,25],50:[2,25],52:[2,25]},{18:[2,26],25:[2,26],33:[2,26],42:[2,26],43:[2,26],44:[2,26],45:[2,26],46:[2,26],50:[2,26],52:[2,26]},{18:[2,27],25:[2,27],33:[2,27],42:[2,27],43:[2,27],44:[2,27],45:[2,27],46:[2,27],50:[2,27],52:[2,27]},{17:76,30:22,41:23,50:[1,26],52:[1,25],53:24},{25:[2,47]},{18:[2,29],25:[2,29],33:[2,29],46:[2,29],49:77,50:[1,74]},{18:[2,37],25:[2,37],33:[2,37],42:[2,37],43:[2,37],44:[2,37],45:[2,37],46:[2,37],50:[2,37],51:[1,78],52:[2,37],54:[2,37]},{18:[2,52],25:[2,52],33:[2,52],46:[2,52],50:[2,52]},{12:[2,13],13:[2,13],16:[2,13],24:[2,13],26:[2,13],28:[2,13],29:[2,13],31:[2,13],32:[2,13],34:[2,13]},{12:[2,14],13:[2,14],16:[2,14],24:[2,14],26:[2,14],28:[2,14],29:[2,14],31:[2,14],32:[2,14],34:[2,14]},{12:[2,10]},{18:[2,21],25:[2,21],33:[2,21],46:[2,21]},{18:[2,49],25:[2,49],33:[2,49],42:[2,49],43:[2,49],44:[2,49],45:[2,49],46:[2,49],50:[2,49],52:[2,49]},{18:[2,51],25:[2,51],33:[2,51],46:[2,51]},{18:[2,36],25:[2,36],33:[2,36],42:[2,36],43:[2,36],44:[2,36],45:[2,36],46:[2,36],50:[2,36],52:[2,36],54:[2,36]},{5:[2,11],12:[2,11],13:[2,11],16:[2,11],24:[2,11],26:[2,11],28:[2,11],29:[2,11],31:[2,11],32:[2,11],34:[2,11]},{30:79,50:[1,26],53:24},{29:[2,15]},{5:[2,12],12:[2,12],13:[2,12],16:[2,12],24:[2,12],26:[2,12],28:[2,12],29:[2,12],31:[2,12],32:[2,12],34:[2,12]},{25:[1,80]},{25:[2,45]},{51:[1,78]},{5:[2,20],12:[2,20],13:[2,20],16:[2,20],24:[2,20],26:[2,20],28:[2,20],29:[2,20],31:[2,20],32:[2,20],34:[2,20]},{46:[1,81]},{18:[2,53],25:[2,53],33:[2,53],46:[2,53],50:[2,53]},{30:51,36:82,41:55,42:[1,52],43:[1,53],44:[1,54],45:[1,56],50:[1,26],52:[1,25],53:24},{25:[1,83]},{5:[2,19],12:[2,19],13:[2,19],16:[2,19],24:[2,19],26:[2,19],28:[2,19],29:[2,19],31:[2,19],32:[2,19],34:[2,19]},{18:[2,28],25:[2,28],33:[2,28],42:[2,28],43:[2,28],44:[2,28],45:[2,28],46:[2,28],50:[2,28],52:[2,28]},{18:[2,30],25:[2,30],33:[2,30],46:[2,30],50:[2,30]},{5:[2,16],12:[2,16],13:[2,16],16:[2,16],24:[2,16],26:[2,16],28:[2,16],29:[2,16],31:[2,16],32:[2,16],34:[2,16]}],
+defaultActions: {4:[2,1],44:[2,41],47:[2,43],57:[2,47],63:[2,10],70:[2,15],73:[2,45]},
+parseError: function parseError(str, hash) {
+ throw new Error(str);
+},
+parse: function parse(input) {
+ var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
+ this.lexer.setInput(input);
+ this.lexer.yy = this.yy;
+ this.yy.lexer = this.lexer;
+ this.yy.parser = this;
+ Iif (typeof this.lexer.yylloc == "undefined")
+ this.lexer.yylloc = {};
+ var yyloc = this.lexer.yylloc;
+ lstack.push(yyloc);
+ var ranges = this.lexer.options && this.lexer.options.ranges;
+ Iif (typeof this.yy.parseError === "function")
+ this.parseError = this.yy.parseError;
+ function popStack(n) {
+ stack.length = stack.length - 2 * n;
+ vstack.length = vstack.length - n;
+ lstack.length = lstack.length - n;
+ }
+ function lex() {
+ var token;
+ token = self.lexer.lex() || 1;
+ if (typeof token !== "number") {
+ token = self.symbols_[token] || token;
+ }
+ return token;
+ }
+ var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
+ while (true) {
+ state = stack[stack.length - 1];
+ if (this.defaultActions[state]) {
+ action = this.defaultActions[state];
+ } else {
+ if (symbol === null || typeof symbol == "undefined") {
+ symbol = lex();
+ }
+ action = table[state] && table[state][symbol];
+ }
+ if (typeof action === "undefined" || !action.length || !action[0]) {
+ var errStr = "";
+ Eif (!recovering) {
+ expected = [];
+ for (p in table[state])
+ Eif (this.terminals_[p] && p > 2) {
+ expected.push("'" + this.terminals_[p] + "'");
+ }
+ Eif (this.lexer.showPosition) {
+ errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
+ } else {
+ errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'");
+ }
+ this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected});
+ }
+ }
+ Iif (action[0] instanceof Array && action.length > 1) {
+ throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
+ }
+ switch (action[0]) {
+ case 1:
+ stack.push(symbol);
+ vstack.push(this.lexer.yytext);
+ lstack.push(this.lexer.yylloc);
+ stack.push(action[1]);
+ symbol = null;
+ Eif (!preErrorSymbol) {
+ yyleng = this.lexer.yyleng;
+ yytext = this.lexer.yytext;
+ yylineno = this.lexer.yylineno;
+ yyloc = this.lexer.yylloc;
+ Iif (recovering > 0)
+ recovering--;
+ } else {
+ symbol = preErrorSymbol;
+ preErrorSymbol = null;
+ }
+ break;
+ case 2:
+ len = this.productions_[action[1]][1];
+ yyval.$ = vstack[vstack.length - len];
+ yyval._$ = {first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column};
+ Iif (ranges) {
+ yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
+ }
+ r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
+ if (typeof r !== "undefined") {
+ return r;
+ }
+ if (len) {
+ stack = stack.slice(0, -1 * len * 2);
+ vstack = vstack.slice(0, -1 * len);
+ lstack = lstack.slice(0, -1 * len);
+ }
+ stack.push(this.productions_[action[1]][0]);
+ vstack.push(yyval.$);
+ lstack.push(yyval._$);
+ newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
+ stack.push(newState);
+ break;
+ case 3:
+ return true;
+ }
+ }
+ return true;
+}
+};
+/* Jison generated lexer */
+var lexer = (function(){
+var lexer = ({EOF:1,
+parseError:function parseError(str, hash) {
+ if (this.yy.parser) {
+ this.yy.parser.parseError(str, hash);
+ } else {
+ throw new Error(str);
+ }
+ },
+setInput:function (input) {
+ this._input = input;
+ this._more = this._less = this.done = false;
+ this.yylineno = this.yyleng = 0;
+ this.yytext = this.matched = this.match = '';
+ this.conditionStack = ['INITIAL'];
+ this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0};
+ Iif (this.options.ranges) this.yylloc.range = [0,0];
+ this.offset = 0;
+ return this;
+ },
+input:function () {
+ var ch = this._input[0];
+ this.yytext += ch;
+ this.yyleng++;
+ this.offset++;
+ this.match += ch;
+ this.matched += ch;
+ var lines = ch.match(/(?:\r\n?|\n).*/g);
+ if (lines) {
+ this.yylineno++;
+ this.yylloc.last_line++;
+ } else {
+ this.yylloc.last_column++;
+ }
+ if (this.options.ranges) this.yylloc.range[1]++;
+
+ this._input = this._input.slice(1);
+ return ch;
+ },
+unput:function (ch) {
+ var len = ch.length;
+ var lines = ch.split(/(?:\r\n?|\n)/g);
+
+ this._input = ch + this._input;
+ this.yytext = this.yytext.substr(0, this.yytext.length-len-1);
+ //this.yyleng -= len;
+ this.offset -= len;
+ var oldLines = this.match.split(/(?:\r\n?|\n)/g);
+ this.match = this.match.substr(0, this.match.length-1);
+ this.matched = this.matched.substr(0, this.matched.length-1);
+
+ if (lines.length-1) this.yylineno -= lines.length-1;
+ var r = this.yylloc.range;
+
+ this.yylloc = {first_line: this.yylloc.first_line,
+ last_line: this.yylineno+1,
+ first_column: this.yylloc.first_column,
+ last_column: lines ?
+ (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length:
+ this.yylloc.first_column - len
+ };
+
+ if (this.options.ranges) {
+ this.yylloc.range = [r[0], r[0] + this.yyleng - len];
+ }
+ return this;
+ },
+more:function () {
+ this._more = true;
+ return this;
+ },
+less:function (n) {
+ this.unput(this.match.slice(n));
+ },
+pastInput:function () {
+ var past = this.matched.substr(0, this.matched.length - this.match.length);
+ return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
+ },
+upcomingInput:function () {
+ var next = this.match;
+ Eif (next.length < 20) {
+ next += this._input.substr(0, 20-next.length);
+ }
+ return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, "");
+ },
+showPosition:function () {
+ var pre = this.pastInput();
+ var c = new Array(pre.length + 1).join("-");
+ return pre + this.upcomingInput() + "\n" + c+"^";
+ },
+next:function () {
+ Iif (this.done) {
+ return this.EOF;
+ }
+ if (!this._input) this.done = true;
+
+ var token,
+ match,
+ tempMatch,
+ index,
+ col,
+ lines;
+ Eif (!this._more) {
+ this.yytext = '';
+ this.match = '';
+ }
+ var rules = this._currentRules();
+ for (var i=0;i < rules.length; i++) {
+ tempMatch = this._input.match(this.rules[rules[i]]);
+ if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
+ match = tempMatch;
+ index = i;
+ Eif (!this.options.flex) break;
+ }
+ }
+ Eif (match) {
+ lines = match[0].match(/(?:\r\n?|\n).*/g);
+ if (lines) this.yylineno += lines.length;
+ this.yylloc = {first_line: this.yylloc.last_line,
+ last_line: this.yylineno+1,
+ first_column: this.yylloc.last_column,
+ last_column: lines ? lines[lines.length-1].length-lines[lines.length-1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length};
+ this.yytext += match[0];
+ this.match += match[0];
+ this.matches = match;
+ this.yyleng = this.yytext.length;
+ Iif (this.options.ranges) {
+ this.yylloc.range = [this.offset, this.offset += this.yyleng];
+ }
+ this._more = false;
+ this._input = this._input.slice(match[0].length);
+ this.matched += match[0];
+ token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]);
+ Iif (this.done && this._input) this.done = false;
+ if (token) return token;
+ else return;
+ }
+ if (this._input === "") {
+ return this.EOF;
+ } else {
+ return this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(),
+ {text: "", token: null, line: this.yylineno});
+ }
+ },
+lex:function lex() {
+ var r = this.next();
+ if (typeof r !== 'undefined') {
+ return r;
+ } else {
+ return this.lex();
+ }
+ },
+begin:function begin(condition) {
+ this.conditionStack.push(condition);
+ },
+popState:function popState() {
+ return this.conditionStack.pop();
+ },
+_currentRules:function _currentRules() {
+ return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules;
+ },
+topState:function () {
+ return this.conditionStack[this.conditionStack.length-2];
+ },
+pushState:function begin(condition) {
+ this.begin(condition);
+ }});
+lexer.options = {};
+lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
+
+
+function strip(start, end) {
+ return yy_.yytext = yy_.yytext.substr(start, yy_.yyleng-end);
+}
+
+
+var YYSTATE=YY_START
+switch($avoiding_name_collisions) {
+case 0:
+ if(yy_.yytext.slice(-2) === "\\\\") {
+ strip(0,1);
+ this.begin("mu");
+ } else if(yy_.yytext.slice(-1) === "\\") {
+ strip(0,1);
+ this.begin("emu");
+ } else {
+ this.begin("mu");
+ }
+ if(yy_.yytext) return 12;
+
+break;
+case 1:return 12;
+break;
+case 2:
+ this.popState();
+ return 12;
+
+break;
+case 3:
+ yy_.yytext = yy_.yytext.substr(5, yy_.yyleng-9);
+ this.popState();
+ return 15;
+
+break;
+case 4: return 12;
+break;
+case 5:strip(0,4); this.popState(); return 13;
+break;
+case 6:return 45;
+break;
+case 7:return 46;
+break;
+case 8: return 16;
+break;
+case 9:
+ this.popState();
+ this.begin('raw');
+ return 18;
+
+break;
+case 10:return 34;
+break;
+case 11:return 24;
+break;
+case 12:return 29;
+break;
+case 13:this.popState(); return 28;
+break;
+case 14:this.popState(); return 28;
+break;
+case 15:return 26;
+break;
+case 16:return 26;
+break;
+case 17:return 32;
+break;
+case 18:return 31;
+break;
+case 19:this.popState(); this.begin('com');
+break;
+case 20:strip(3,5); this.popState(); return 13;
+break;
+case 21:return 31;
+break;
+case 22:return 51;
+break;
+case 23:return 50;
+break;
+case 24:return 50;
+break;
+case 25:return 54;
+break;
+case 26:// ignore whitespace
+break;
+case 27:this.popState(); return 33;
+break;
+case 28:this.popState(); return 25;
+break;
+case 29:yy_.yytext = strip(1,2).replace(/\\"/g,'"'); return 42;
+break;
+case 30:yy_.yytext = strip(1,2).replace(/\\'/g,"'"); return 42;
+break;
+case 31:return 52;
+break;
+case 32:return 44;
+break;
+case 33:return 44;
+break;
+case 34:return 43;
+break;
+case 35:return 50;
+break;
+case 36:yy_.yytext = strip(1,2); return 50;
+break;
+case 37:return 'INVALID';
+break;
+case 38:return 5;
+break;
+}
+};
+lexer.rules = [/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|\\\{\{|\\\\\{\{|$)))/,/^(?:\{\{\{\{\/[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.])\}\}\}\})/,/^(?:[^\x00]*?(?=(\{\{\{\{\/)))/,/^(?:[\s\S]*?--\}\})/,/^(?:\()/,/^(?:\))/,/^(?:\{\{\{\{)/,/^(?:\}\}\}\})/,/^(?:\{\{(~)?>)/,/^(?:\{\{(~)?#)/,/^(?:\{\{(~)?\/)/,/^(?:\{\{(~)?\^\s*(~)?\}\})/,/^(?:\{\{(~)?\s*else\s*(~)?\}\})/,/^(?:\{\{(~)?\^)/,/^(?:\{\{(~)?\s*else\b)/,/^(?:\{\{(~)?\{)/,/^(?:\{\{(~)?&)/,/^(?:\{\{!--)/,/^(?:\{\{![\s\S]*?\}\})/,/^(?:\{\{(~)?)/,/^(?:=)/,/^(?:\.\.)/,/^(?:\.(?=([=~}\s\/.)])))/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}(~)?\}\})/,/^(?:(~)?\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@)/,/^(?:true(?=([~}\s)])))/,/^(?:false(?=([~}\s)])))/,/^(?:-?[0-9]+(?:\.[0-9]+)?(?=([~}\s)])))/,/^(?:([^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=([=~}\s\/.)]))))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:$)/];
+lexer.conditions = {"mu":{"rules":[6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38],"inclusive":false},"emu":{"rules":[2],"inclusive":false},"com":{"rules":[5],"inclusive":false},"raw":{"rules":[3,4],"inclusive":false},"INITIAL":{"rules":[0,1,38],"inclusive":true}};
+return lexer;})()
+parser.lexer = lexer;
+function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Parser;
+return new Parser;
+})();exports["default"] = handlebars;
+/* jshint ignore:end */ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 | +1 + +1 +48 + + +1 +48 + + +1 + +1 +89 + +89 +50 + + +89 +89 + + +1 +67 + + + +67 +59 + + +67 + +67 + + +1 +11 + +11 +11 +11 +11 +9 +9 +9 +9 + +11 +10 +10 +10 +10 +10 +10 + +11 + +11 + + +1 +40 + +40 +11 + + +40 + +40 + +40 + + +1 +40 + + +1 +5 +5 +2 + +5 +2 + +5 + + +1 +14 +14 + +14 +23 +23 +23 + + +14 + + +1 +7 + + +1 +3 + + +1 +6 + + +1 +60 +60 +1 + +59 + + + +1 +5 + + +1 +4 + + +1 +12 + + +1 +2 + | "use strict";
+var Visitor = require("./visitor")["default"];
+
+function print(ast) {
+ return new PrintVisitor().accept(ast);
+}
+
+exports.print = print;function PrintVisitor() {
+ this.padding = 0;
+}
+
+exports.PrintVisitor = PrintVisitor;PrintVisitor.prototype = new Visitor();
+
+PrintVisitor.prototype.pad = function(string) {
+ var out = "";
+
+ for(var i=0,l=this.padding; i<l; i++) {
+ out = out + " ";
+ }
+
+ out = out + string + "\n";
+ return out;
+};
+
+PrintVisitor.prototype.program = function(program) {
+ var out = "",
+ statements = program.statements,
+ i, l;
+
+ for(i=0, l=statements.length; i<l; i++) {
+ out = out + this.accept(statements[i]);
+ }
+
+ this.padding--;
+
+ return out;
+};
+
+PrintVisitor.prototype.block = function(block) {
+ var out = "";
+
+ out = out + this.pad("BLOCK:");
+ this.padding++;
+ out = out + this.accept(block.mustache);
+ if (block.program) {
+ out = out + this.pad("PROGRAM:");
+ this.padding++;
+ out = out + this.accept(block.program);
+ this.padding--;
+ }
+ if (block.inverse) {
+ if (block.program) { this.padding++; }
+ out = out + this.pad("{{^}}");
+ this.padding++;
+ out = out + this.accept(block.inverse);
+ this.padding--;
+ if (block.program) { this.padding--; }
+ }
+ this.padding--;
+
+ return out;
+};
+
+PrintVisitor.prototype.sexpr = function(sexpr) {
+ var params = sexpr.params, paramStrings = [], hash;
+
+ for(var i=0, l=params.length; i<l; i++) {
+ paramStrings.push(this.accept(params[i]));
+ }
+
+ params = "[" + paramStrings.join(", ") + "]";
+
+ hash = sexpr.hash ? " " + this.accept(sexpr.hash) : "";
+
+ return this.accept(sexpr.id) + " " + params + hash;
+};
+
+PrintVisitor.prototype.mustache = function(mustache) {
+ return this.pad("{{ " + this.accept(mustache.sexpr) + " }}");
+};
+
+PrintVisitor.prototype.partial = function(partial) {
+ var content = this.accept(partial.partialName);
+ if(partial.context) {
+ content += " " + this.accept(partial.context);
+ }
+ if (partial.hash) {
+ content += " " + this.accept(partial.hash);
+ }
+ return this.pad("{{> " + content + " }}");
+};
+
+PrintVisitor.prototype.hash = function(hash) {
+ var pairs = hash.pairs;
+ var joinedPairs = [], left, right;
+
+ for(var i=0, l=pairs.length; i<l; i++) {
+ left = pairs[i][0];
+ right = this.accept(pairs[i][1]);
+ joinedPairs.push( left + "=" + right );
+ }
+
+ return "HASH{" + joinedPairs.join(", ") + "}";
+};
+
+PrintVisitor.prototype.STRING = function(string) {
+ return '"' + string.string + '"';
+};
+
+PrintVisitor.prototype.NUMBER = function(number) {
+ return "NUMBER{" + number.number + "}";
+};
+
+PrintVisitor.prototype.BOOLEAN = function(bool) {
+ return "BOOLEAN{" + bool.bool + "}";
+};
+
+PrintVisitor.prototype.ID = function(id) {
+ var path = id.parts.join("/");
+ if(id.parts.length > 1) {
+ return "PATH:" + path;
+ } else {
+ return "ID:" + path;
+ }
+};
+
+PrintVisitor.prototype.PARTIAL_NAME = function(partialName) {
+ return "PARTIAL:" + partialName.name;
+};
+
+PrintVisitor.prototype.DATA = function(data) {
+ return "@" + this.accept(data.id);
+};
+
+PrintVisitor.prototype.content = function(content) {
+ return this.pad("CONTENT[ '" + content.string + "' ]");
+};
+
+PrintVisitor.prototype.comment = function(comment) {
+ return this.pad("{{! '" + comment.comment + "' }}");
+}; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 | +1 + +1 + + + +276 + + + +1 | "use strict";
+function Visitor() {}
+
+Visitor.prototype = {
+ constructor: Visitor,
+
+ accept: function(object) {
+ return this[object.type](object);
+ }
+};
+
+exports["default"] = Visitor; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 | + +1 + +1 +48 +48 +16 + +16 + + +48 + + +48 +336 + + +48 +16 +16 + + + +1 + +1 | "use strict";
+
+var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+
+function Exception(message, node) {
+ var line;
+ if (node && node.firstLine) {
+ line = node.firstLine;
+
+ message += ' - ' + line + ':' + node.firstColumn;
+ }
+
+ var tmp = Error.prototype.constructor.call(this, message);
+
+ // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+ for (var idx = 0; idx < errorProps.length; idx++) {
+ this[errorProps[idx]] = tmp[errorProps[idx]];
+ }
+
+ if (line) {
+ this.lineNumber = line;
+ this.column = node.firstColumn;
+ }
+}
+
+Exception.prototype = new Error();
+
+exports["default"] = Exception; |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| base.js | ++ | 100% | +(119 / 119) | +100% | +(83 / 83) | +100% | +(16 / 16) | +100% | +(113 / 113) | +
| exception.js | ++ | 100% | +(14 / 14) | +100% | +(6 / 6) | +100% | +(1 / 1) | +100% | +(14 / 14) | +
| runtime.js | ++ | 100% | +(104 / 104) | +100% | +(84 / 84) | +100% | +(17 / 17) | +100% | +(99 / 99) | +
| safe-string.js | ++ | 100% | +(5 / 5) | +100% | +(0 / 0) | +100% | +(2 / 2) | +100% | +(5 / 5) | +
| utils.js | ++ | 100% | +(47 / 47) | +100% | +(30 / 30) | +100% | +(8 / 8) | +100% | +(43 / 43) | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 | +1 +1 +1 +1 +1 + +1 +470 + + +470 +3 +2 + +2 + + + +1 + + + + + +1 + +1 + +474 +1 + +474 +3 + + + + +471 + +468 +55 +2 + + +55 + +53 +39 +39 +39 + +53 +52 +8 +8 +18 +6 + + +12 + +8 + +52 + +1 + + + + +468 + +175 +175 +261 +170 + + + + +138 + + + + + + +345 + + + + +345 + +345 +340 +5 +4 + +345 + + + +4 +6 + +4 + + +512 + +512 +313 + + +512 + + + + + + +468 +480 +480 + +480 +480 +462 + +480 +480 +141 + + +480 + +468 + +468 +482 +471 + +471 +41 + + +11 +11 + + + +468 +4 +1 + + +3 + +468 + + +1 +347 +365 + +365 + +347 +347 +347 + + +1 +55 + +55 +2 +53 +13 + + + +62 + +1 +462 +424 +424 + +462 + | "use strict";
+var Utils = require("./utils");
+var Exception = require("./exception")["default"];
+var COMPILER_REVISION = require("./base").COMPILER_REVISION;
+var REVISION_CHANGES = require("./base").REVISION_CHANGES;
+var createFrame = require("./base").createFrame;
+
+function checkRevision(compilerInfo) {
+ var compilerRevision = compilerInfo && compilerInfo[0] || 1,
+ currentRevision = COMPILER_REVISION;
+
+ if (compilerRevision !== currentRevision) {
+ if (compilerRevision < currentRevision) {
+ var runtimeVersions = REVISION_CHANGES[currentRevision],
+ compilerVersions = REVISION_CHANGES[compilerRevision];
+ throw new Exception("Template was precompiled with an older version of Handlebars than the current runtime. "+
+ "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").");
+ } else {
+ // Use the embedded version info since the runtime doesn't know about this revision yet
+ throw new Exception("Template was precompiled with a newer version of Handlebars than the current runtime. "+
+ "Please update your runtime to a newer version ("+compilerInfo[1]+").");
+ }
+ }
+}
+
+exports.checkRevision = checkRevision;// TODO: Remove this line and break up compilePartial
+
+function template(templateSpec, env) {
+ /* istanbul ignore next */
+ Iif (!env) {
+ throw new Exception("No environment passed to template");
+ }
+ if (!templateSpec || !templateSpec.main) {
+ throw new Exception('Unknown template object: ' + typeof templateSpec);
+ }
+
+ // Note: Using env.VM references rather than local var references throughout this section to allow
+ // for external users to override these as psuedo-supported APIs.
+ env.VM.checkRevision(templateSpec.compiler);
+
+ var invokePartialWrapper = function(partial, indent, name, context, hash, helpers, partials, data, depths) {
+ if (hash) {
+ context = Utils.extend({}, context, hash);
+ }
+
+ var result = env.VM.invokePartial.call(this, partial, name, context, helpers, partials, data, depths);
+
+ if (result == null && env.compile) {
+ var options = { helpers: helpers, partials: partials, data: data, depths: depths };
+ partials[name] = env.compile(partial, { data: data !== undefined, compat: templateSpec.compat }, env);
+ result = partials[name](context, options);
+ }
+ if (result != null) {
+ if (indent) {
+ var lines = result.split('\n');
+ for (var i = 0, l = lines.length; i < l; i++) {
+ if (!lines[i] && i + 1 === l) {
+ break;
+ }
+
+ lines[i] = indent + lines[i];
+ }
+ result = lines.join('\n');
+ }
+ return result;
+ } else {
+ throw new Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
+ }
+ };
+
+ // Just add water
+ var container = {
+ lookup: function(depths, name) {
+ var len = depths.length;
+ for (var i = 0; i < len; i++) {
+ if (depths[i] && depths[i][name] != null) {
+ return depths[i][name];
+ }
+ }
+ },
+ lambda: function(current, context) {
+ return typeof current === 'function' ? current.call(context) : current;
+ },
+
+ escapeExpression: Utils.escapeExpression,
+ invokePartial: invokePartialWrapper,
+
+ fn: function(i) {
+ return templateSpec[i];
+ },
+
+ programs: [],
+ program: function(i, data, depths) {
+ var programWrapper = this.programs[i],
+ fn = this.fn(i);
+ if (data || depths) {
+ programWrapper = program(this, i, fn, data, depths);
+ } else if (!programWrapper) {
+ programWrapper = this.programs[i] = program(this, i, fn);
+ }
+ return programWrapper;
+ },
+
+ data: function(data, depth) {
+ while (data && depth--) {
+ data = data._parent;
+ }
+ return data;
+ },
+ merge: function(param, common) {
+ var ret = param || common;
+
+ if (param && common && (param !== common)) {
+ ret = Utils.extend({}, common, param);
+ }
+
+ return ret;
+ },
+
+ noop: env.VM.noop,
+ compilerInfo: templateSpec.compiler
+ };
+
+ var ret = function(context, options) {
+ options = options || {};
+ var data = options.data;
+
+ ret._setup(options);
+ if (!options.partial && templateSpec.useData) {
+ data = initData(context, data);
+ }
+ var depths;
+ if (templateSpec.useDepths) {
+ depths = options.depths ? [context].concat(options.depths) : [context];
+ }
+
+ return templateSpec.main.call(container, context, container.helpers, container.partials, data, depths);
+ };
+ ret.isTop = true;
+
+ ret._setup = function(options) {
+ if (!options.partial) {
+ container.helpers = container.merge(options.helpers, env.helpers);
+
+ if (templateSpec.usePartial) {
+ container.partials = container.merge(options.partials, env.partials);
+ }
+ } else {
+ container.helpers = options.helpers;
+ container.partials = options.partials;
+ }
+ };
+
+ ret._child = function(i, data, depths) {
+ if (templateSpec.useDepths && !depths) {
+ throw new Exception('must pass parent depths');
+ }
+
+ return program(container, i, templateSpec[i], data, depths);
+ };
+ return ret;
+}
+
+exports.template = template;function program(container, i, fn, data, depths) {
+ var prog = function(context, options) {
+ options = options || {};
+
+ return fn.call(container, context, container.helpers, container.partials, options.data || data, depths && [context].concat(depths));
+ };
+ prog.program = i;
+ prog.depth = depths ? depths.length : 0;
+ return prog;
+}
+
+exports.program = program;function invokePartial(partial, name, context, helpers, partials, data, depths) {
+ var options = { partial: true, helpers: helpers, partials: partials, data: data, depths: depths };
+
+ if(partial === undefined) {
+ throw new Exception("The partial " + name + " could not be found");
+ } else if(partial instanceof Function) {
+ return partial(context, options);
+ }
+}
+
+exports.invokePartial = invokePartial;function noop() { return ""; }
+
+exports.noop = noop;function initData(context, data) {
+ if (!data || !('root' in data)) {
+ data = data ? createFrame(data) : {};
+ data.root = context;
+ }
+ return data;
+} |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 | + +1 +12 + + +1 +12 + + +1 | "use strict";
+// Build out our basic SafeString type
+function SafeString(string) {
+ this.string = string;
+}
+
+SafeString.prototype.toString = function() {
+ return "" + this.string;
+};
+
+exports["default"] = SafeString; |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 | + +1 + +1 + + + + + + + + +1 +1 + +1 +27 + + +1 +933 +1249 +6468 +6467 + + + + +933 + + +1 +1 + + +1 +175 + + + +1 +1 +1 + + +1 +1 + +1 +1 + +1 + +1 + +534 +11 +523 +29 +494 +19 + + + + + +475 + +475 +9 + + +1 +58 +5 +53 +2 + +51 + + + +1 +11 + + +1 | "use strict";
+/*jshint -W004 */
+var SafeString = require("./safe-string")["default"];
+
+var escape = {
+ "&": "&",
+ "<": "<",
+ ">": ">",
+ '"': """,
+ "'": "'",
+ "`": "`"
+};
+
+var badChars = /[&<>"'`]/g;
+var possible = /[&<>"'`]/;
+
+function escapeChar(chr) {
+ return escape[chr];
+}
+
+function extend(obj /* , ...source */) {
+ for (var i = 1; i < arguments.length; i++) {
+ for (var key in arguments[i]) {
+ if (Object.prototype.hasOwnProperty.call(arguments[i], key)) {
+ obj[key] = arguments[i][key];
+ }
+ }
+ }
+
+ return obj;
+}
+
+exports.extend = extend;var toString = Object.prototype.toString;
+exports.toString = toString;
+// Sourced from lodash
+// https://github.com/bestiejs/lodash/blob/master/LICENSE.txt
+var isFunction = function(value) {
+ return typeof value === 'function';
+};
+// fallback for older versions of Chrome and Safari
+/* istanbul ignore next */
+Iif (isFunction(/x/)) {
+ isFunction = function(value) {
+ return typeof value === 'function' && toString.call(value) === '[object Function]';
+ };
+}
+var isFunction;
+exports.isFunction = isFunction;
+/* istanbul ignore next */
+var isArray = Array.isArray || function(value) {
+ return (value && typeof value === 'object') ? toString.call(value) === '[object Array]' : false;
+};
+exports.isArray = isArray;
+
+function escapeExpression(string) {
+ // don't escape SafeStrings, since they're already safe
+ if (string instanceof SafeString) {
+ return string.toString();
+ } else if (string == null) {
+ return "";
+ } else if (!string) {
+ return string + '';
+ }
+
+ // Force a string conversion as this will be done by the append regardless and
+ // the regex test will do this transparently behind the scenes, causing issues if
+ // an object's to string has escaped characters in it.
+ string = "" + string;
+
+ if(!possible.test(string)) { return string; }
+ return string.replace(badChars, escapeChar);
+}
+
+exports.escapeExpression = escapeExpression;function isEmpty(value) {
+ if (!value && value !== 0) {
+ return true;
+ } else if (isArray(value) && value.length === 0) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+exports.isEmpty = isEmpty;function appendContextPath(contextPath, id) {
+ return (contextPath ? contextPath + '.' : '') + id;
+}
+
+exports.appendContextPath = appendContextPath; |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| handlebars.js | ++ | 100% | +(25 / 25) | +100% | +(0 / 0) | +100% | +(3 / 3) | +100% | +(25 / 25) | +
| handlebars.runtime.js | ++ | 100% | +(20 / 20) | +100% | +(0 / 0) | +100% | +(2 / 2) | +100% | +(20 / 20) | +
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| dist/cjs/ | ++ | 100% | +(45 / 45) | +100% | +(0 / 0) | +100% | +(5 / 5) | +100% | +(45 / 45) | +
| dist/cjs/handlebars/ | ++ | 100% | +(289 / 289) | +100% | +(203 / 203) | +100% | +(44 / 44) | +100% | +(274 / 274) | +
| dist/cjs/handlebars/compiler/ | ++ | 99.84% | +(1269 / 1271) | +99.4% | +(660 / 664) | +100% | +(164 / 164) | +99.84% | +(1229 / 1231) | +
| lib/ | ++ | 97.87% | +(92 / 94) | +94.87% | +(74 / 78) | +100% | +(7 / 7) | +97.85% | +(91 / 93) | +
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| index.js | ++ | 100% | +(13 / 13) | +100% | +(4 / 4) | +100% | +(1 / 1) | +100% | +(13 / 13) | +
| precompiler.js | ++ | 97.53% | +(79 / 81) | +94.59% | +(70 / 74) | +100% | +(6 / 6) | +97.5% | +(78 / 80) | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 | + + + + +1 + +1 + +1 +1 +1 + +1 + + + +1 +1 +2 +2 +2 + +1 +1 + + | // USAGE:
+// var handlebars = require('handlebars');
+
+// var local = handlebars.create();
+
+var handlebars = require('../dist/cjs/handlebars')["default"];
+
+handlebars.Visitor = require('../dist/cjs/handlebars/compiler/visitor')["default"];
+
+var printer = require('../dist/cjs/handlebars/compiler/printer');
+handlebars.PrintVisitor = printer.PrintVisitor;
+handlebars.print = printer.print;
+
+module.exports = handlebars;
+
+// Publish a Node.js require() handler for .handlebars and .hbs files
+/* istanbul ignore else */
+Eif (typeof require !== 'undefined' && require.extensions) {
+ var extension = function(module, filename) {
+ var fs = require("fs");
+ var templateString = fs.readFileSync(filename, "utf8");
+ module.exports = handlebars.compile(templateString);
+ };
+ require.extensions[".handlebars"] = extension;
+ require.extensions[".hbs"] = extension;
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 | +1 + + + + +1 +54 +3 +3 + + +51 +51 +3 + + +48 +51 +51 + +3 + + + +45 +3 + +42 +6 + + + +36 +36 +3 + +36 +3 +3 + + + + +36 +36 + +36 +36 +27 +12 +15 +3 + +12 + +27 +27 +27 +27 +27 + +1 +57 + +57 +15 +45 + +45 +21 + + + +42 + +42 + + + +42 + + + + +42 +3 + + + +42 +21 +21 +21 + +42 + +42 +9 +33 +9 +3 + +9 + +24 +3 + +24 + + + + +36 +36 + + + +36 +27 +12 +6 +3 + +3 + + +12 +15 +12 + + +36 + +36 +3 + + +36 + + +36 + + + |
+var fs = require('fs'),
+ Handlebars = require('./index'),
+ basename = require('path').basename,
+ uglify = require('uglify-js');
+
+module.exports.cli = function(opts) {
+ if (opts.version) {
+ console.log(Handlebars.VERSION);
+ return;
+ }
+
+ var template = [0];
+ if (!opts.templates.length) {
+ throw new Handlebars.Exception('Must define at least one template or directory.');
+ }
+
+ opts.templates.forEach(function(template) {
+ try {
+ fs.statSync(template);
+ } catch (err) {
+ throw new Handlebars.Exception('Unable to open template file "' + template + '"');
+ }
+ });
+
+ if (opts.simple && opts.min) {
+ throw new Handlebars.Exception('Unable to minimze simple output');
+ }
+ if (opts.simple && (opts.templates.length !== 1 || fs.statSync(opts.templates[0]).isDirectory())) {
+ throw new Handlebars.Exception('Unable to output multiple templates in simple mode');
+ }
+
+ // Convert the known list into a hash
+ var known = {};
+ if (opts.known && !Array.isArray(opts.known)) {
+ opts.known = [opts.known];
+ }
+ if (opts.known) {
+ for (var i = 0, len = opts.known.length; i < len; i++) {
+ known[opts.known[i]] = true;
+ }
+ }
+
+ // Build file extension pattern
+ var extension = opts.extension.replace(/[\\^$*+?.():=!|{}\-\[\]]/g, function(arg) { return '\\' + arg; });
+ extension = new RegExp('\\.' + extension + '$');
+
+ var output = [];
+ if (!opts.simple) {
+ if (opts.amd) {
+ output.push('define([\'' + opts.handlebarPath + 'handlebars.runtime\'], function(Handlebars) {\n Handlebars = Handlebars["default"];');
+ } else if (opts.commonjs) {
+ output.push('var Handlebars = require("' + opts.commonjs + '");');
+ } else {
+ output.push('(function() {\n');
+ }
+ output.push(' var template = Handlebars.template, templates = ');
+ output.push(opts.namespace);
+ output.push(' = ');
+ output.push(opts.namespace);
+ output.push(' || {};\n');
+ }
+ function processTemplate(template, root) {
+ var path = template,
+ stat = fs.statSync(path);
+ if (stat.isDirectory()) {
+ fs.readdirSync(template).map(function(file) {
+ var path = template + '/' + file;
+
+ if (extension.test(path) || fs.statSync(path).isDirectory()) {
+ processTemplate(path, root || template);
+ }
+ });
+ } else {
+ var data = fs.readFileSync(path, 'utf8');
+
+ Iif (opts.bom && data.indexOf('\uFEFF') === 0) {
+ data = data.substring(1);
+ }
+
+ var options = {
+ knownHelpers: known,
+ knownHelpersOnly: opts.o
+ };
+
+ if (opts.data) {
+ options.data = true;
+ }
+
+ // Clean the template name
+ if (!root) {
+ template = basename(template);
+ } else Eif (template.indexOf(root) === 0) {
+ template = template.substring(root.length+1);
+ }
+ template = template.replace(extension, '');
+
+ if (opts.simple) {
+ output.push(Handlebars.precompile(data, options) + '\n');
+ } else if (opts.partial) {
+ if(opts.amd && (opts.templates.length == 1 && !fs.statSync(opts.templates[0]).isDirectory())) {
+ output.push('return ');
+ }
+ output.push('Handlebars.partials[\'' + template + '\'] = template(' + Handlebars.precompile(data, options) + ');\n');
+ } else {
+ if(opts.amd && (opts.templates.length == 1 && !fs.statSync(opts.templates[0]).isDirectory())) {
+ output.push('return ');
+ }
+ output.push('templates[\'' + template + '\'] = template(' + Handlebars.precompile(data, options) + ');\n');
+ }
+ }
+ }
+
+ opts.templates.forEach(function(template) {
+ processTemplate(template, opts.root);
+ });
+
+ // Output the content
+ if (!opts.simple) {
+ if (opts.amd) {
+ if(opts.templates.length > 1 || (opts.templates.length == 1 && fs.statSync(opts.templates[0]).isDirectory())) {
+ if(opts.partial){
+ output.push('return Handlebars.partials;\n');
+ } else {
+ output.push('return templates;\n');
+ }
+ }
+ output.push('});');
+ } else if (!opts.commonjs) {
+ output.push('})();');
+ }
+ }
+ output = output.join('');
+
+ if (opts.min) {
+ output = uglify.minify(output, {fromString: true}).code;
+ }
+
+ Iif (opts.output) {
+ fs.writeFileSync(opts.output, output, 'utf8');
+ } else {
+ console.log(output);
+ }
+};
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 | +3 +3 +1 + + +2 + + + + + + +1 + + + + + + + + + + + +2 +1 + + + + +2 + + + + + + + + + + + + +2 + + + + + + + + + + + + + + + + +2 + + + + + + + +2 +2 + + + + + +2 + + + + + + + +2 + + + + + + + + + + + + +2 +2 + + + + + + + + + + + + + + + + + + + + + + + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + + +2 + +2 + + + + +2 + +2 +2 + + + + +2 + + + + + + + + + + + + + + + + + + + + +2 +2 + +1 + + + + + + +2 + +2 + +2 + + + + +2 + + + + +2 + + + + +2 + + + + +2 + + + + +2 + + + + + + + +2 +2 +2 + + + + + +2 +2 + + + + + + + + + + + + + + + +2 + + + + + + + +2 + + + + + + + + +2 + + + + + + + + + + + + + + + + +2 + + + + + + + + + + + + + + + + +2 + + + + + + + + + + + + + + + +2 + + + + + + + + + + + + + + + + +2 +2 + + + +2 + + + + + +2 + + + + + + + +2 +2 + + + +2 + + + + +2 + + + + + + + + + + + | /*global Handlebars, handlebarsEnv, shouldThrow */
+describe('ast', function() {
+ if (!Handlebars.AST) {
+ return;
+ }
+
+ var LOCATION_INFO = {
+ last_line: 0,
+ first_line: 0,
+ first_column: 0,
+ last_column: 0
+ };
+
+ function testLocationInfoStorage(node){
+ var properties = [ 'firstLine', 'lastLine', 'firstColumn', 'lastColumn' ],
+ property,
+ propertiesLen = properties.length,
+ i;
+
+ for (i = 0; i < propertiesLen; i++){
+ property = properties[0];
+ equals(node[property], 0);
+ }
+ }
+
+ describe('MustacheNode', function() {
+ function testEscape(open, expected) {
+ var mustache = new handlebarsEnv.AST.MustacheNode([{}], {}, open, false);
+ equals(mustache.escaped, expected);
+ }
+
+ it('should store args', function() {
+ var id = {isSimple: true},
+ hash = {},
+ mustache = new handlebarsEnv.AST.MustacheNode([id, 'param1'], hash, '', false, LOCATION_INFO);
+ equals(mustache.type, 'mustache');
+ equals(mustache.hash, hash);
+ equals(mustache.escaped, true);
+ equals(mustache.id, id);
+ equals(mustache.params.length, 1);
+ equals(mustache.params[0], 'param1');
+ equals(!!mustache.isHelper, true);
+ testLocationInfoStorage(mustache);
+ });
+ it('should accept token for escape', function() {
+ testEscape('{{', true);
+ testEscape('{{~', true);
+ testEscape('{{#', true);
+ testEscape('{{~#', true);
+ testEscape('{{/', true);
+ testEscape('{{~/', true);
+ testEscape('{{^', true);
+ testEscape('{{~^', true);
+ testEscape('{', true);
+ testEscape('{', true);
+
+ testEscape('{{&', false);
+ testEscape('{{~&', false);
+ testEscape('{{{', false);
+ testEscape('{{~{', false);
+ });
+ it('should accept boolean for escape', function() {
+ testEscape(true, true);
+ testEscape({}, true);
+
+ testEscape(false, false);
+ testEscape(undefined, false);
+ });
+ });
+ describe('BlockNode', function() {
+ it('should throw on mustache mismatch (old sexpr-less version)', function() {
+ shouldThrow(function() {
+ var mustacheNode = new handlebarsEnv.AST.MustacheNode([{ original: 'foo'}], null, '{{', {});
+ new handlebarsEnv.AST.BlockNode(mustacheNode, {}, {}, {path: {original: 'bar'}});
+ }, Handlebars.Exception, "foo doesn't match bar");
+ });
+ it('should throw on mustache mismatch', function() {
+ shouldThrow(function() {
+ var sexprNode = new handlebarsEnv.AST.SexprNode([{ original: 'foo'}], null);
+ var mustacheNode = new handlebarsEnv.AST.MustacheNode(sexprNode, null, '{{', {});
+ new handlebarsEnv.AST.BlockNode(mustacheNode, {}, {}, {path: {original: 'bar'}}, {first_line: 2, first_column: 2});
+ }, Handlebars.Exception, "foo doesn't match bar - 2:2");
+ });
+
+ it('stores location info', function(){
+ var sexprNode = new handlebarsEnv.AST.SexprNode([{ original: 'foo'}], null);
+ var mustacheNode = new handlebarsEnv.AST.MustacheNode(sexprNode, null, '{{', {});
+ var block = new handlebarsEnv.AST.BlockNode(mustacheNode,
+ {statements: [], strip: {}}, {statements: [], strip: {}},
+ {
+ strip: {},
+ path: {original: 'foo'}
+ },
+ LOCATION_INFO);
+ testLocationInfoStorage(block);
+ });
+ });
+ describe('IdNode', function() {
+ it('should throw on invalid path', function() {
+ shouldThrow(function() {
+ new handlebarsEnv.AST.IdNode([
+ {part: 'foo'},
+ {part: '..'},
+ {part: 'bar'}
+ ], {first_line: 1, first_column: 1});
+ }, Handlebars.Exception, "Invalid path: foo.. - 1:1");
+ shouldThrow(function() {
+ new handlebarsEnv.AST.IdNode([
+ {part: 'foo'},
+ {part: '.'},
+ {part: 'bar'}
+ ], {first_line: 1, first_column: 1});
+ }, Handlebars.Exception, "Invalid path: foo. - 1:1");
+ shouldThrow(function() {
+ new handlebarsEnv.AST.IdNode([
+ {part: 'foo'},
+ {part: 'this'},
+ {part: 'bar'}
+ ], {first_line: 1, first_column: 1});
+ }, Handlebars.Exception, "Invalid path: foothis - 1:1");
+ });
+
+ it('stores location info', function(){
+ var idNode = new handlebarsEnv.AST.IdNode([], LOCATION_INFO);
+ testLocationInfoStorage(idNode);
+ });
+ });
+
+ describe("HashNode", function(){
+
+ it('stores location info', function(){
+ var hash = new handlebarsEnv.AST.HashNode([], LOCATION_INFO);
+ testLocationInfoStorage(hash);
+ });
+ });
+
+ describe("ContentNode", function(){
+
+ it('stores location info', function(){
+ var content = new handlebarsEnv.AST.ContentNode("HI", LOCATION_INFO);
+ testLocationInfoStorage(content);
+ });
+ });
+
+ describe("CommentNode", function(){
+
+ it('stores location info', function(){
+ var comment = new handlebarsEnv.AST.CommentNode("HI", LOCATION_INFO);
+ testLocationInfoStorage(comment);
+ });
+ });
+
+ describe("NumberNode", function(){
+
+ it('stores location info', function(){
+ var integer = new handlebarsEnv.AST.NumberNode("6", LOCATION_INFO);
+ testLocationInfoStorage(integer);
+ });
+ });
+
+ describe("StringNode", function(){
+
+ it('stores location info', function(){
+ var string = new handlebarsEnv.AST.StringNode("6", LOCATION_INFO);
+ testLocationInfoStorage(string);
+ });
+ });
+
+ describe("BooleanNode", function(){
+
+ it('stores location info', function(){
+ var bool = new handlebarsEnv.AST.BooleanNode("true", LOCATION_INFO);
+ testLocationInfoStorage(bool);
+ });
+ });
+
+ describe("DataNode", function(){
+
+ it('stores location info', function(){
+ var data = new handlebarsEnv.AST.DataNode("YES", LOCATION_INFO);
+ testLocationInfoStorage(data);
+ });
+ });
+
+ describe("PartialNameNode", function(){
+
+ it('stores location info', function(){
+ var pnn = new handlebarsEnv.AST.PartialNameNode({original: "YES"}, LOCATION_INFO);
+ testLocationInfoStorage(pnn);
+ });
+ });
+
+ describe("PartialNode", function(){
+
+ it('stores location info', function(){
+ var pn = new handlebarsEnv.AST.PartialNode("so_partial", {}, {}, {}, LOCATION_INFO);
+ testLocationInfoStorage(pn);
+ });
+ });
+ describe("ProgramNode", function(){
+
+ describe("storing location info", function(){
+ it("stores when `inverse` argument isn't passed", function(){
+ var pn = new handlebarsEnv.AST.ProgramNode(false, [], LOCATION_INFO);
+ testLocationInfoStorage(pn);
+ });
+
+ it("stores when `inverse` or `stripInverse` arguments passed", function(){
+ var pn = new handlebarsEnv.AST.ProgramNode(false, [], {strip: {}}, undefined, LOCATION_INFO);
+ testLocationInfoStorage(pn);
+
+ var clone = {
+ strip: {},
+ firstLine: 0,
+ lastLine: 0,
+ firstColumn: 0,
+ lastColumn: 0
+ };
+ pn = new handlebarsEnv.AST.ProgramNode(false, [], {strip: {}}, [ clone ], LOCATION_INFO);
+ testLocationInfoStorage(pn);
+
+ // Assert that the newly created ProgramNode has the same location
+ // information as the inverse
+ testLocationInfoStorage(pn.inverse);
+ });
+ });
+ });
+
+ describe("Line Numbers", function(){
+ var ast, statements;
+
+ function testColumns(node, firstLine, lastLine, firstColumn, lastColumn){
+ equals(node.firstLine, firstLine);
+ equals(node.lastLine, lastLine);
+ equals(node.firstColumn, firstColumn);
+ equals(node.lastColumn, lastColumn);
+ }
+
+ ast = Handlebars.parse("line 1 {{line1Token}}\n line 2 {{line2token}}\n line 3 {{#blockHelperOnLine3}}\nline 4{{line4token}}\n" +
+ "line5{{else}}\n{{line6Token}}\n{{/blockHelperOnLine3}}");
+ statements = ast.statements;
+
+ it('gets ContentNode line numbers', function(){
+ var contentNode = statements[0];
+ testColumns(contentNode, 1, 1, 0, 7);
+ });
+
+ it('gets MustacheNode line numbers', function(){
+ var mustacheNode = statements[1];
+ testColumns(mustacheNode, 1, 1, 7, 21);
+ });
+
+ it('gets line numbers correct when newlines appear', function(){
+ testColumns(statements[2], 1, 2, 21, 0);
+ testColumns(statements[3], 2, 2, 0, 8);
+ });
+
+ it('gets MustacheNode line numbers correct across newlines', function(){
+ var secondMustacheNode = statements[4];
+ testColumns(secondMustacheNode, 2, 2, 8, 22);
+ });
+
+ it('gets the block helper information correct', function(){
+ var blockHelperNode = statements[7];
+ testColumns(blockHelperNode, 3, 7, 8, 23);
+ });
+
+ it('correctly records the line numbers of an inverse of a block helper', function(){
+ var blockHelperNode = statements[7],
+ inverse = blockHelperNode.inverse;
+
+ testColumns(inverse, 5, 6, 13, 0);
+ });
+ });
+
+ describe('standalone flags', function(){
+ describe('mustache', function() {
+ it('does not mark mustaches as standalone', function() {
+ var ast = Handlebars.parse(' {{comment}} ');
+ equals(ast.statements[0].omit, undefined);
+ equals(ast.statements[2].omit, undefined);
+ });
+ });
+ describe('blocks', function() {
+ it('marks block mustaches as standalone', function() {
+ var ast = Handlebars.parse(' {{# comment}} \nfoo\n {{else}} \n bar \n {{/comment}} '),
+ block = ast.statements[1];
+
+ equals(ast.statements[0].omit, true);
+
+ equals(block.program.statements[0].omit, true);
+ equals(block.program.statements[1].string, 'foo\n');
+ equals(block.program.statements[2].omit, true);
+
+ equals(block.inverse.statements[0].omit, true);
+ equals(block.inverse.statements[1].string, ' bar \n');
+ equals(block.inverse.statements[2].omit, true);
+
+ equals(ast.statements[2].omit, true);
+ });
+ it('marks initial block mustaches as standalone', function() {
+ var ast = Handlebars.parse('{{# comment}} \nfoo\n {{/comment}}'),
+ block = ast.statements[0];
+
+ equals(block.program.statements[0].omit, true);
+ equals(block.program.statements[1].string, 'foo\n');
+ equals(block.program.statements[2].omit, true);
+ });
+ it('marks mustaches with children as standalone', function() {
+ var ast = Handlebars.parse('{{# comment}} \n{{foo}}\n {{/comment}}'),
+ block = ast.statements[0];
+
+ equals(block.program.statements[0].omit, true);
+ equals(block.program.statements[1].id.original, 'foo');
+ equals(block.program.statements[2].omit, undefined);
+ equals(block.program.statements[3].omit, true);
+ });
+ it('marks nested block mustaches as standalone', function() {
+ var ast = Handlebars.parse('{{#foo}} \n{{# comment}} \nfoo\n {{else}} \n bar \n {{/comment}} \n{{/foo}}'),
+ statements = ast.statements[0].program.statements,
+ block = statements[1];
+
+ equals(statements[0].omit, true);
+
+ equals(block.program.statements[0].omit, true);
+ equals(block.program.statements[1].string, 'foo\n');
+ equals(block.program.statements[2].omit, true);
+
+ equals(block.inverse.statements[0].omit, true);
+ equals(block.inverse.statements[1].string, ' bar \n');
+ equals(block.inverse.statements[2].omit, true);
+
+ equals(statements[0].omit, true);
+ });
+ it('does not mark nested block mustaches as standalone', function() {
+ var ast = Handlebars.parse('{{#foo}} {{# comment}} \nfoo\n {{else}} \n bar \n {{/comment}} {{/foo}}'),
+ statements = ast.statements[0].program.statements,
+ block = statements[1];
+
+ equals(statements[0].omit, undefined);
+
+ equals(block.program.statements[0].omit, undefined);
+ equals(block.program.statements[1].string, 'foo\n');
+ equals(block.program.statements[2].omit, true);
+
+ equals(block.inverse.statements[0].omit, true);
+ equals(block.inverse.statements[1].string, ' bar \n');
+ equals(block.inverse.statements[2].omit, undefined);
+
+ equals(statements[0].omit, undefined);
+ });
+ it('does not mark nested initial block mustaches as standalone', function() {
+ var ast = Handlebars.parse('{{#foo}}{{# comment}} \nfoo\n {{else}} \n bar \n {{/comment}}{{/foo}}'),
+ statements = ast.statements[0].program.statements,
+ block = statements[0];
+
+ equals(block.program.statements[0].omit, undefined);
+ equals(block.program.statements[1].string, 'foo\n');
+ equals(block.program.statements[2].omit, true);
+
+ equals(block.inverse.statements[0].omit, true);
+ equals(block.inverse.statements[1].string, ' bar \n');
+ equals(block.inverse.statements[2].omit, undefined);
+
+ equals(statements[0].omit, undefined);
+ });
+
+ it('marks column 0 block mustaches as standalone', function() {
+ var ast = Handlebars.parse('test\n{{# comment}} \nfoo\n {{else}} \n bar \n {{/comment}} '),
+ block = ast.statements[1];
+
+ equals(ast.statements[0].omit, undefined);
+
+ equals(block.program.statements[0].omit, true);
+ equals(block.program.statements[1].string, 'foo\n');
+ equals(block.program.statements[2].omit, true);
+
+ equals(block.inverse.statements[0].omit, true);
+ equals(block.inverse.statements[1].string, ' bar \n');
+ equals(block.inverse.statements[2].omit, true);
+
+ equals(ast.statements[2].omit, true);
+ });
+ });
+ describe('partials', function() {
+ it('marks partial as standalone', function() {
+ var ast = Handlebars.parse('{{> partial }} ');
+ equals(ast.statements[1].omit, true);
+ });
+ it('marks indented partial as standalone', function() {
+ var ast = Handlebars.parse(' {{> partial }} ');
+ equals(ast.statements[0].omit, true);
+ equals(ast.statements[1].indent, ' ');
+ equals(ast.statements[2].omit, true);
+ });
+ it('marks those around content as not standalone', function() {
+ var ast = Handlebars.parse('a{{> partial }}');
+ equals(ast.statements[0].omit, undefined);
+
+ ast = Handlebars.parse('{{> partial }}a');
+ equals(ast.statements[1].omit, undefined);
+ });
+ });
+ describe('comments', function() {
+ it('marks comment as standalone', function() {
+ var ast = Handlebars.parse('{{! comment }} ');
+ equals(ast.statements[1].omit, true);
+ });
+ it('marks indented comment as standalone', function() {
+ var ast = Handlebars.parse(' {{! comment }} ');
+ equals(ast.statements[0].omit, true);
+ equals(ast.statements[2].omit, true);
+ });
+ it('marks those around content as not standalone', function() {
+ var ast = Handlebars.parse('a{{! comment }}');
+ equals(ast.statements[0].omit, undefined);
+
+ ast = Handlebars.parse('{{! comment }}a');
+ equals(ast.statements[1].omit, undefined);
+ });
+ });
+ });
+});
+
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 | +3 + +3 + + + +3 +3 + + + +3 + + + + + + + +3 + + + + +3 + + + + + +3 + + + + + +3 + + + + + + + + +3 + + + + + + +3 + + + + +3 + + + + + + + +3 + + + + + + + + + + + + + +3 + + + + + +3 + + + + + + +3 + + + + + +3 + + + + + +3 + + + + + + +3 + + + + + +3 + + + + + +3 + + + + +3 + + + + +3 + + + + + + +3 + + + + + +3 + + + + +3 + + + + +3 + + + + + + +3 + + + + +3 + + + +3 + + + + +3 + + + + + + + + + + +3 + + + + + + +3 + + + + + + + + + + + + + +3 + + + + + + + | /*global CompilerContext, Handlebars, beforeEach, shouldCompileTo */ +global.handlebarsEnv = null; + +beforeEach(function() { + global.handlebarsEnv = Handlebars.create(); +}); + +describe("basic context", function() { + it("most basic", function() { + shouldCompileTo("{{foo}}", { foo: "foo" }, "foo"); + }); + + it("escaping", function() { + shouldCompileTo("\\{{foo}}", { foo: "food" }, "{{foo}}"); + shouldCompileTo("content \\{{foo}}", { foo: "food" }, "content {{foo}}"); + shouldCompileTo("\\\\{{foo}}", { foo: "food" }, "\\food"); + shouldCompileTo("content \\\\{{foo}}", { foo: "food" }, "content \\food"); + shouldCompileTo("\\\\ {{foo}}", { foo: "food" }, "\\\\ food"); + }); + + it("compiling with a basic context", function() { + shouldCompileTo("Goodbye\n{{cruel}}\n{{world}}!", {cruel: "cruel", world: "world"}, "Goodbye\ncruel\nworld!", + "It works if all the required keys are provided"); + }); + + it("compiling with an undefined context", function() { + shouldCompileTo("Goodbye\n{{cruel}}\n{{world.bar}}!", undefined, "Goodbye\n\n!"); + + shouldCompileTo("{{#unless foo}}Goodbye{{../test}}{{test2}}{{/unless}}", undefined, "Goodbye"); + }); + + it("comments", function() { + shouldCompileTo("{{! Goodbye}}Goodbye\n{{cruel}}\n{{world}}!", + {cruel: "cruel", world: "world"}, "Goodbye\ncruel\nworld!", + "comments are ignored"); + }); + + it("boolean", function() { + var string = "{{#goodbye}}GOODBYE {{/goodbye}}cruel {{world}}!"; + shouldCompileTo(string, {goodbye: true, world: "world"}, "GOODBYE cruel world!", + "booleans show the contents when true"); + + shouldCompileTo(string, {goodbye: false, world: "world"}, "cruel world!", + "booleans do not show the contents when false"); + }); + + it("zeros", function() { + shouldCompileTo("num1: {{num1}}, num2: {{num2}}", {num1: 42, num2: 0}, + "num1: 42, num2: 0"); + shouldCompileTo("num: {{.}}", 0, "num: 0"); + shouldCompileTo("num: {{num1/num2}}", {num1: {num2: 0}}, "num: 0"); + }); + + it("newlines", function() { + shouldCompileTo("Alan's\nTest", {}, "Alan's\nTest"); + shouldCompileTo("Alan's\rTest", {}, "Alan's\rTest"); + }); + + it("escaping text", function() { + shouldCompileTo("Awesome's", {}, "Awesome's", "text is escaped so that it doesn't get caught on single quotes"); + shouldCompileTo("Awesome\\", {}, "Awesome\\", "text is escaped so that the closing quote can't be ignored"); + shouldCompileTo("Awesome\\\\ foo", {}, "Awesome\\\\ foo", "text is escaped so that it doesn't mess up backslashes"); + shouldCompileTo("Awesome {{foo}}", {foo: '\\'}, "Awesome \\", "text is escaped so that it doesn't mess up backslashes"); + shouldCompileTo(' " " ', {}, ' " " ', "double quotes never produce invalid javascript"); + }); + + it("escaping expressions", function() { + shouldCompileTo("{{{awesome}}}", {awesome: "&\"\\<>"}, '&\"\\<>', + "expressions with 3 handlebars aren't escaped"); + + shouldCompileTo("{{&awesome}}", {awesome: "&\"\\<>"}, '&\"\\<>', + "expressions with {{& handlebars aren't escaped"); + + shouldCompileTo("{{awesome}}", {awesome: "&\"'`\\<>"}, '&"'`\\<>', + "by default expressions should be escaped"); + + shouldCompileTo("{{awesome}}", {awesome: "Escaped, <b> looks like: <b>"}, 'Escaped, <b> looks like: &lt;b&gt;', + "escaping should properly handle amperstands"); + }); + + it("functions returning safestrings shouldn't be escaped", function() { + var hash = {awesome: function() { return new Handlebars.SafeString("&\"\\<>"); }}; + shouldCompileTo("{{awesome}}", hash, '&\"\\<>', + "functions returning safestrings aren't escaped"); + }); + + it("functions", function() { + shouldCompileTo("{{awesome}}", {awesome: function() { return "Awesome"; }}, "Awesome", + "functions are called and render their output"); + shouldCompileTo("{{awesome}}", {awesome: function() { return this.more; }, more: "More awesome"}, "More awesome", + "functions are bound to the context"); + }); + + it("functions with context argument", function() { + shouldCompileTo("{{awesome frank}}", + {awesome: function(context) { return context; }, + frank: "Frank"}, + "Frank", "functions are called with context arguments"); + }); + it("pathed functions with context argument", function() { + shouldCompileTo("{{bar.awesome frank}}", + {bar: {awesome: function(context) { return context; }}, + frank: "Frank"}, + "Frank", "functions are called with context arguments"); + }); + it("depthed functions with context argument", function() { + shouldCompileTo("{{#with frank}}{{../awesome .}}{{/with}}", + {awesome: function(context) { return context; }, + frank: "Frank"}, + "Frank", "functions are called with context arguments"); + }); + + it("block functions with context argument", function() { + shouldCompileTo("{{#awesome 1}}inner {{.}}{{/awesome}}", + {awesome: function(context, options) { return options.fn(context); }}, + "inner 1", "block functions are called with context and options"); + }); + + it("depthed block functions with context argument", function() { + shouldCompileTo("{{#with value}}{{#../awesome 1}}inner {{.}}{{/../awesome}}{{/with}}", + {value: true, awesome: function(context, options) { return options.fn(context); }}, + "inner 1", "block functions are called with context and options"); + }); + + it("block functions without context argument", function() { + shouldCompileTo("{{#awesome}}inner{{/awesome}}", + {awesome: function(options) { return options.fn(this); }}, + "inner", "block functions are called with options"); + }); + it("pathed block functions without context argument", function() { + shouldCompileTo("{{#foo.awesome}}inner{{/foo.awesome}}", + {foo: {awesome: function(options) { return this; }}}, + "inner", "block functions are called with options"); + }); + it("depthed block functions without context argument", function() { + shouldCompileTo("{{#with value}}{{#../awesome}}inner{{/../awesome}}{{/with}}", + {value: true, awesome: function(options) { return this; }}, + "inner", "block functions are called with options"); + }); + + + it("paths with hyphens", function() { + shouldCompileTo("{{foo-bar}}", {"foo-bar": "baz"}, "baz", "Paths can contain hyphens (-)"); + shouldCompileTo("{{foo.foo-bar}}", {foo: {"foo-bar": "baz"}}, "baz", "Paths can contain hyphens (-)"); + shouldCompileTo("{{foo/foo-bar}}", {foo: {"foo-bar": "baz"}}, "baz", "Paths can contain hyphens (-)"); + }); + + it("nested paths", function() { + shouldCompileTo("Goodbye {{alan/expression}} world!", {alan: {expression: "beautiful"}}, + "Goodbye beautiful world!", "Nested paths access nested objects"); + }); + + it("nested paths with empty string value", function() { + shouldCompileTo("Goodbye {{alan/expression}} world!", {alan: {expression: ""}}, + "Goodbye world!", "Nested paths access nested objects with empty string"); + }); + + it("literal paths", function() { + shouldCompileTo("Goodbye {{[@alan]/expression}} world!", {"@alan": {expression: "beautiful"}}, + "Goodbye beautiful world!", "Literal paths can be used"); + shouldCompileTo("Goodbye {{[foo bar]/expression}} world!", {"foo bar": {expression: "beautiful"}}, + "Goodbye beautiful world!", "Literal paths can be used"); + }); + + it('literal references', function() { + shouldCompileTo("Goodbye {{[foo bar]}} world!", {"foo bar": "beautiful"}, + "Goodbye beautiful world!", "Literal paths can be used"); + }); + + it("that current context path ({{.}}) doesn't hit helpers", function() { + shouldCompileTo("test: {{.}}", [null, {helper: "awesome"}], "test: "); + }); + + it("complex but empty paths", function() { + shouldCompileTo("{{person/name}}", {person: {name: null}}, ""); + shouldCompileTo("{{person/name}}", {person: {}}, ""); + }); + + it("this keyword in paths", function() { + var string = "{{#goodbyes}}{{this}}{{/goodbyes}}"; + var hash = {goodbyes: ["goodbye", "Goodbye", "GOODBYE"]}; + shouldCompileTo(string, hash, "goodbyeGoodbyeGOODBYE", + "This keyword in paths evaluates to current context"); + + string = "{{#hellos}}{{this/text}}{{/hellos}}"; + hash = {hellos: [{text: "hello"}, {text: "Hello"}, {text: "HELLO"}]}; + shouldCompileTo(string, hash, "helloHelloHELLO", "This keyword evaluates in more complex paths"); + }); + + it("this keyword nested inside path", function() { + var string = "{{#hellos}}{{text/this/foo}}{{/hellos}}"; + shouldThrow(function() { + CompilerContext.compile(string); + }, Error); + }); + + it("this keyword in helpers", function() { + var helpers = {foo: function(value) { + return 'bar ' + value; + }}; + var string = "{{#goodbyes}}{{foo this}}{{/goodbyes}}"; + var hash = {goodbyes: ["goodbye", "Goodbye", "GOODBYE"]}; + shouldCompileTo(string, [hash, helpers], "bar goodbyebar Goodbyebar GOODBYE", + "This keyword in paths evaluates to current context"); + + string = "{{#hellos}}{{foo this/text}}{{/hellos}}"; + hash = {hellos: [{text: "hello"}, {text: "Hello"}, {text: "HELLO"}]}; + shouldCompileTo(string, [hash, helpers], "bar hellobar Hellobar HELLO", "This keyword evaluates in more complex paths"); + }); + + it("this keyword nested inside helpers param", function() { + var string = "{{#hellos}}{{foo text/this/foo}}{{/hellos}}"; + shouldThrow(function() { + CompilerContext.compile(string); + }, Error); + }); +}); + |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 | +3 +3 + + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + +3 + + + + + + + +3 + + + + + + +3 +3 + + + + + +3 + + + + + +3 + + + + + +3 + + + + +3 + + + + + +3 +3 + + + + + + + + + +3 +3 + + + + + +3 + + + + + +3 + + + + + + + + | /*global CompilerContext, shouldCompileTo, shouldThrow */
+describe('blocks', function() {
+ it("array", function() {
+ var string = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+ shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
+ "Arrays iterate over the contents when not empty");
+
+ shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
+ "Arrays ignore the contents when empty");
+
+ });
+
+ it("array with @index", function() {
+ var string = "{{#goodbyes}}{{@index}}. {{text}}! {{/goodbyes}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "0. goodbye! 1. Goodbye! 2. GOODBYE! cruel world!", "The @index variable is used");
+ });
+
+ it("empty block", function() {
+ var string = "{{#goodbyes}}{{/goodbyes}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+ shouldCompileTo(string, hash, "cruel world!",
+ "Arrays iterate over the contents when not empty");
+
+ shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
+ "Arrays ignore the contents when empty");
+ });
+
+ it("block with complex lookup", function() {
+ var string = "{{#goodbyes}}{{text}} cruel {{../name}}! {{/goodbyes}}";
+ var hash = {name: "Alan", goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}]};
+
+ shouldCompileTo(string, hash, "goodbye cruel Alan! Goodbye cruel Alan! GOODBYE cruel Alan! ",
+ "Templates can access variables in contexts up the stack with relative path syntax");
+ });
+
+ it("block with complex lookup using nested context", function() {
+ var string = "{{#goodbyes}}{{text}} cruel {{foo/../name}}! {{/goodbyes}}";
+
+ shouldThrow(function() {
+ CompilerContext.compile(string);
+ }, Error);
+ });
+
+ it("block with deep nested complex lookup", function() {
+ var string = "{{#outer}}Goodbye {{#inner}}cruel {{../../omg}}{{/inner}}{{/outer}}";
+ var hash = {omg: "OMG!", outer: [{ inner: [{ text: "goodbye" }] }] };
+
+ shouldCompileTo(string, hash, "Goodbye cruel OMG!");
+ });
+
+ describe('inverted sections', function() {
+ it("inverted sections with unset value", function() {
+ var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
+ var hash = {};
+ shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value isn't set.");
+ });
+
+ it("inverted section with false value", function() {
+ var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
+ var hash = {goodbyes: false};
+ shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value is false.");
+ });
+
+ it("inverted section with empty set", function() {
+ var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
+ var hash = {goodbyes: []};
+ shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value is empty set.");
+ });
+
+ it("block inverted sections", function() {
+ shouldCompileTo("{{#people}}{{name}}{{^}}{{none}}{{/people}}", {none: "No people"},
+ "No people");
+ });
+
+ it("block inverted sections with empty arrays", function() {
+ shouldCompileTo("{{#people}}{{name}}{{^}}{{none}}{{/people}}", {none: "No people", people: []},
+ "No people");
+ });
+ });
+
+ describe('standalone sections', function() {
+ it('block standalone else sections', function() {
+ shouldCompileTo('{{#people}}\n{{name}}\n{{^}}\n{{none}}\n{{/people}}\n', {none: 'No people'},
+ 'No people\n');
+ shouldCompileTo('{{#none}}\n{{.}}\n{{^}}\n{{none}}\n{{/none}}\n', {none: 'No people'},
+ 'No people\n');
+ shouldCompileTo('\n{{#people}}\n{{name}}\n{{^}}\n{{none}}\n{{/people}}\n', {none: 'No people'},
+ 'No people\n');
+ });
+ });
+
+ describe('compat mode', function() {
+ it("block with deep recursive lookup lookup", function() {
+ var string = "{{#outer}}Goodbye {{#inner}}cruel {{omg}}{{/inner}}{{/outer}}";
+ var hash = {omg: "OMG!", outer: [{ inner: [{ text: "goodbye" }] }] };
+
+ shouldCompileTo(string, [hash, undefined, undefined, true], "Goodbye cruel OMG!");
+ });
+ it("block with deep recursive pathed lookup", function() {
+ var string = "{{#outer}}Goodbye {{#inner}}cruel {{omg.yes}}{{/inner}}{{/outer}}";
+ var hash = {omg: {yes: "OMG!"}, outer: [{ inner: [{ yes: 'no', text: "goodbye" }] }] };
+
+ shouldCompileTo(string, [hash, undefined, undefined, true], "Goodbye cruel OMG!");
+ });
+ it("block with missed recursive lookup", function() {
+ var string = "{{#outer}}Goodbye {{#inner}}cruel {{omg.yes}}{{/inner}}{{/outer}}";
+ var hash = {omg: {no: "OMG!"}, outer: [{ inner: [{ yes: 'no', text: "goodbye" }] }] };
+
+ shouldCompileTo(string, [hash, undefined, undefined, true], "Goodbye cruel ");
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 | +3 +3 +3 + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + +3 +3 + + + +3 + + + +3 + + + + + +3 +3 + + + + + +3 + + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + +3 + + + + + + + + + + + + +3 + + + + + + + +3 + + + + + + + + + + + + + + + +3 +3 + + + + + + + + +3 + + + + + + + + + + + | /*global CompilerContext, shouldCompileTo, shouldThrow, compileWithPartials, handlebarsEnv */
+describe('builtin helpers', function() {
+ describe('#if', function() {
+ it("if", function() {
+ var string = "{{#if goodbye}}GOODBYE {{/if}}cruel {{world}}!";
+ shouldCompileTo(string, {goodbye: true, world: "world"}, "GOODBYE cruel world!",
+ "if with boolean argument shows the contents when true");
+ shouldCompileTo(string, {goodbye: "dummy", world: "world"}, "GOODBYE cruel world!",
+ "if with string argument shows the contents");
+ shouldCompileTo(string, {goodbye: false, world: "world"}, "cruel world!",
+ "if with boolean argument does not show the contents when false");
+ shouldCompileTo(string, {world: "world"}, "cruel world!",
+ "if with undefined does not show the contents");
+ shouldCompileTo(string, {goodbye: ['foo'], world: "world"}, "GOODBYE cruel world!",
+ "if with non-empty array shows the contents");
+ shouldCompileTo(string, {goodbye: [], world: "world"}, "cruel world!",
+ "if with empty array does not show the contents");
+ shouldCompileTo(string, {goodbye: 0, world: "world"}, "cruel world!",
+ "if with zero does not show the contents");
+ shouldCompileTo("{{#if goodbye includeZero=true}}GOODBYE {{/if}}cruel {{world}}!",
+ {goodbye: 0, world: "world"}, "GOODBYE cruel world!",
+ "if with zero does not show the contents");
+ });
+
+ it("if with function argument", function() {
+ var string = "{{#if goodbye}}GOODBYE {{/if}}cruel {{world}}!";
+ shouldCompileTo(string, {goodbye: function() {return true;}, world: "world"}, "GOODBYE cruel world!",
+ "if with function shows the contents when function returns true");
+ shouldCompileTo(string, {goodbye: function() {return this.world;}, world: "world"}, "GOODBYE cruel world!",
+ "if with function shows the contents when function returns string");
+ shouldCompileTo(string, {goodbye: function() {return false;}, world: "world"}, "cruel world!",
+ "if with function does not show the contents when returns false");
+ shouldCompileTo(string, {goodbye: function() {return this.foo;}, world: "world"}, "cruel world!",
+ "if with function does not show the contents when returns undefined");
+ });
+ });
+
+ describe('#with', function() {
+ it("with", function() {
+ var string = "{{#with person}}{{first}} {{last}}{{/with}}";
+ shouldCompileTo(string, {person: {first: "Alan", last: "Johnson"}}, "Alan Johnson");
+ });
+ it("with with function argument", function() {
+ var string = "{{#with person}}{{first}} {{last}}{{/with}}";
+ shouldCompileTo(string, {person: function() { return {first: "Alan", last: "Johnson"};}}, "Alan Johnson");
+ });
+ it("with with else", function() {
+ var string = "{{#with person}}Person is present{{else}}Person is not present{{/with}}";
+ shouldCompileTo(string, {}, "Person is not present");
+ });
+ });
+
+ describe('#each', function() {
+ beforeEach(function() {
+ handlebarsEnv.registerHelper('detectDataInsideEach', function(options) {
+ return options.data && options.data.exclaim;
+ });
+ });
+
+ it("each", function() {
+ var string = "{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+ shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
+ "each with array argument iterates over the contents when not empty");
+ shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
+ "each with array argument ignores the contents when empty");
+ });
+
+ it("each with an object and @key", function() {
+ var string = "{{#each goodbyes}}{{@key}}. {{text}}! {{/each}}cruel {{world}}!";
+ var hash = {goodbyes: {"<b>#1</b>": {text: "goodbye"}, 2: {text: "GOODBYE"}}, world: "world"};
+
+ // Object property iteration order is undefined according to ECMA spec,
+ // so we need to check both possible orders
+ // @see http://stackoverflow.com/questions/280713/elements-order-in-a-for-in-loop
+ var actual = compileWithPartials(string, hash);
+ var expected1 = "<b>#1</b>. goodbye! 2. GOODBYE! cruel world!";
+ var expected2 = "2. GOODBYE! <b>#1</b>. goodbye! cruel world!";
+
+ equals(actual === expected1 || actual === expected2, true, "each with object argument iterates over the contents when not empty");
+ shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
+ "each with object argument ignores the contents when empty");
+ });
+
+ it("each with @index", function() {
+ var string = "{{#each goodbyes}}{{@index}}. {{text}}! {{/each}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "0. goodbye! 1. Goodbye! 2. GOODBYE! cruel world!", "The @index variable is used");
+ });
+
+ it("each with nested @index", function() {
+ var string = "{{#each goodbyes}}{{@index}}. {{text}}! {{#each ../goodbyes}}{{@index}} {{/each}}After {{@index}} {{/each}}{{@index}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "0. goodbye! 0 1 2 After 0 1. Goodbye! 0 1 2 After 1 2. GOODBYE! 0 1 2 After 2 cruel world!", "The @index variable is used");
+ });
+
+ it("each object with @index", function() {
+ var string = "{{#each goodbyes}}{{@index}}. {{text}}! {{/each}}cruel {{world}}!";
+ var hash = {goodbyes: {'a': {text: "goodbye"}, b: {text: "Goodbye"}, c: {text: "GOODBYE"}}, world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "0. goodbye! 1. Goodbye! 2. GOODBYE! cruel world!", "The @index variable is used");
+ });
+
+
+ it("each with @first", function() {
+ var string = "{{#each goodbyes}}{{#if @first}}{{text}}! {{/if}}{{/each}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "goodbye! cruel world!", "The @first variable is used");
+ });
+
+ it("each with nested @first", function() {
+ var string = "{{#each goodbyes}}({{#if @first}}{{text}}! {{/if}}{{#each ../goodbyes}}{{#if @first}}{{text}}!{{/if}}{{/each}}{{#if @first}} {{text}}!{{/if}}) {{/each}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "(goodbye! goodbye! goodbye!) (goodbye!) (goodbye!) cruel world!", "The @first variable is used");
+ });
+
+ it("each object with @first", function() {
+ var string = "{{#each goodbyes}}{{#if @first}}{{text}}! {{/if}}{{/each}}cruel {{world}}!";
+ var hash = {goodbyes: {'foo': {text: "goodbye"}, bar: {text: "Goodbye"}}, world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "goodbye! cruel world!", "The @first variable is used");
+ });
+
+ it("each with @last", function() {
+ var string = "{{#each goodbyes}}{{#if @last}}{{text}}! {{/if}}{{/each}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "GOODBYE! cruel world!", "The @last variable is used");
+ });
+
+ it("each with nested @last", function() {
+ var string = "{{#each goodbyes}}({{#if @last}}{{text}}! {{/if}}{{#each ../goodbyes}}{{#if @last}}{{text}}!{{/if}}{{/each}}{{#if @last}} {{text}}!{{/if}}) {{/each}}cruel {{world}}!";
+ var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, "(GOODBYE!) (GOODBYE!) (GOODBYE! GOODBYE! GOODBYE!) cruel world!", "The @last variable is used");
+ });
+
+ it("each with function argument", function() {
+ var string = "{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!";
+ var hash = {goodbyes: function () { return [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}];}, world: "world"};
+ shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
+ "each with array function argument iterates over the contents when not empty");
+ shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
+ "each with array function argument ignores the contents when empty");
+ });
+
+ it("data passed to helpers", function() {
+ var string = "{{#each letters}}{{this}}{{detectDataInsideEach}}{{/each}}";
+ var hash = {letters: ['a', 'b', 'c']};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash, {
+ data: {
+ exclaim: '!'
+ }
+ });
+ equal(result, 'a!b!c!', 'should output data');
+ });
+
+ it("each on implicit context", function() {
+ shouldThrow(function() {
+ var template = CompilerContext.compile("{{#each}}{{text}}! {{/each}}cruel world!");
+ template({});
+ }, handlebarsEnv.Exception, 'Must pass iterator to #each');
+ });
+ });
+
+ it("#log", function() {
+ var string = "{{log blah}}";
+ var hash = { blah: "whee" };
+
+ var levelArg, logArg;
+ handlebarsEnv.log = function(level, arg){
+ levelArg = level;
+ logArg = arg;
+ };
+
+ shouldCompileTo(string, hash, "", "log should not display");
+ equals(1, levelArg, "should call log with 1");
+ equals("whee", logArg, "should call log with 'whee'");
+ });
+
+
+ describe('#lookup', function() {
+ it('should lookup arbitrary content', function() {
+ var string = '{{#each goodbyes}}{{lookup ../data .}}{{/each}}',
+ hash = {goodbyes: [0, 1], data: ['foo', 'bar']};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, 'foobar');
+ });
+ it('should not fail on undefined value', function() {
+ var string = '{{#each goodbyes}}{{lookup ../bar .}}{{/each}}',
+ hash = {goodbyes: [0, 1], data: ['foo', 'bar']};
+
+ var template = CompilerContext.compile(string);
+ var result = template(hash);
+
+ equal(result, '');
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 | +3 +3 + + + + + + + + + + + + +3 + + + + + +3 + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + +3 + + + + + + + + + + + +3 + + + + + + + + + + + +3 + + + + + + + + + + + +3 + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 +3 + + + + + + + +3 + + + + + + +3 +3 + + + + + + + + + + + + + + + + + + | /*global CompilerContext, Handlebars, handlebarsEnv, shouldThrow */
+describe('data', function() {
+ it("passing in data to a compiled function that expects data - works with helpers", function() {
+ var template = CompilerContext.compile("{{hello}}", {data: true});
+
+ var helpers = {
+ hello: function(options) {
+ return options.data.adjective + " " + this.noun;
+ }
+ };
+
+ var result = template({noun: "cat"}, {helpers: helpers, data: {adjective: "happy"}});
+ equals("happy cat", result, "Data output by helper");
+ });
+
+ it("data can be looked up via @foo", function() {
+ var template = CompilerContext.compile("{{@hello}}");
+ var result = template({}, { data: { hello: "hello" } });
+ equals("hello", result, "@foo retrieves template data");
+ });
+
+ it("deep @foo triggers automatic top-level data", function() {
+ var template = CompilerContext.compile('{{#let world="world"}}{{#if foo}}{{#if foo}}Hello {{@world}}{{/if}}{{/if}}{{/let}}');
+
+ var helpers = Handlebars.createFrame(handlebarsEnv.helpers);
+
+ helpers.let = function(options) {
+ var frame = Handlebars.createFrame(options.data);
+
+ for (var prop in options.hash) {
+ frame[prop] = options.hash[prop];
+ }
+ return options.fn(this, { data: frame });
+ };
+
+ var result = template({ foo: true }, { helpers: helpers });
+ equals("Hello world", result, "Automatic data was triggered");
+ });
+
+ it("parameter data can be looked up via @foo", function() {
+ var template = CompilerContext.compile("{{hello @world}}");
+ var helpers = {
+ hello: function(noun) {
+ return "Hello " + noun;
+ }
+ };
+
+ var result = template({}, { helpers: helpers, data: { world: "world" } });
+ equals("Hello world", result, "@foo as a parameter retrieves template data");
+ });
+
+ it("hash values can be looked up via @foo", function() {
+ var template = CompilerContext.compile("{{hello noun=@world}}");
+ var helpers = {
+ hello: function(options) {
+ return "Hello " + options.hash.noun;
+ }
+ };
+
+ var result = template({}, { helpers: helpers, data: { world: "world" } });
+ equals("Hello world", result, "@foo as a parameter retrieves template data");
+ });
+
+ it("nested parameter data can be looked up via @foo.bar", function() {
+ var template = CompilerContext.compile("{{hello @world.bar}}");
+ var helpers = {
+ hello: function(noun) {
+ return "Hello " + noun;
+ }
+ };
+
+ var result = template({}, { helpers: helpers, data: { world: {bar: "world" } } });
+ equals("Hello world", result, "@foo as a parameter retrieves template data");
+ });
+
+ it("nested parameter data does not fail with @world.bar", function() {
+ var template = CompilerContext.compile("{{hello @world.bar}}");
+ var helpers = {
+ hello: function(noun) {
+ return "Hello " + noun;
+ }
+ };
+
+ var result = template({}, { helpers: helpers, data: { foo: {bar: "world" } } });
+ equals("Hello undefined", result, "@foo as a parameter retrieves template data");
+ });
+
+ it("parameter data throws when using complex scope references", function() {
+ var string = "{{#goodbyes}}{{text}} cruel {{@foo/../name}}! {{/goodbyes}}";
+
+ shouldThrow(function() {
+ CompilerContext.compile(string);
+ }, Error);
+ });
+
+ it("data is inherited downstream", function() {
+ var template = CompilerContext.compile("{{#let foo=1 bar=2}}{{#let foo=bar.baz}}{{@bar}}{{@foo}}{{/let}}{{@foo}}{{/let}}", { data: true });
+ var helpers = {
+ let: function(options) {
+ var frame = Handlebars.createFrame(options.data);
+ for (var prop in options.hash) {
+ frame[prop] = options.hash[prop];
+ }
+ return options.fn(this, {data: frame});
+ }
+ };
+
+ var result = template({ bar: { baz: "hello world" } }, { helpers: helpers, data: {} });
+ equals("2hello world1", result, "data variables are inherited downstream");
+ });
+
+ it("passing in data to a compiled function that expects data - works with helpers in partials", function() {
+ var template = CompilerContext.compile("{{>my_partial}}", {data: true});
+
+ var partials = {
+ my_partial: CompilerContext.compile("{{hello}}", {data: true})
+ };
+
+ var helpers = {
+ hello: function(options) {
+ return options.data.adjective + " " + this.noun;
+ }
+ };
+
+ var result = template({noun: "cat"}, {helpers: helpers, partials: partials, data: {adjective: "happy"}});
+ equals("happy cat", result, "Data output by helper inside partial");
+ });
+
+ it("passing in data to a compiled function that expects data - works with helpers and parameters", function() {
+ var template = CompilerContext.compile("{{hello world}}", {data: true});
+
+ var helpers = {
+ hello: function(noun, options) {
+ return options.data.adjective + " " + noun + (this.exclaim ? "!" : "");
+ }
+ };
+
+ var result = template({exclaim: true, world: "world"}, {helpers: helpers, data: {adjective: "happy"}});
+ equals("happy world!", result, "Data output by helper");
+ });
+
+ it("passing in data to a compiled function that expects data - works with block helpers", function() {
+ var template = CompilerContext.compile("{{#hello}}{{world}}{{/hello}}", {data: true});
+
+ var helpers = {
+ hello: function(options) {
+ return options.fn(this);
+ },
+ world: function(options) {
+ return options.data.adjective + " world" + (this.exclaim ? "!" : "");
+ }
+ };
+
+ var result = template({exclaim: true}, {helpers: helpers, data: {adjective: "happy"}});
+ equals("happy world!", result, "Data output by helper");
+ });
+
+ it("passing in data to a compiled function that expects data - works with block helpers that use ..", function() {
+ var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
+
+ var helpers = {
+ hello: function(options) {
+ return options.fn({exclaim: "?"});
+ },
+ world: function(thing, options) {
+ return options.data.adjective + " " + thing + (this.exclaim || "");
+ }
+ };
+
+ var result = template({exclaim: true, zomg: "world"}, {helpers: helpers, data: {adjective: "happy"}});
+ equals("happy world?", result, "Data output by helper");
+ });
+
+ it("passing in data to a compiled function that expects data - data is passed to with block helpers where children use ..", function() {
+ var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
+
+ var helpers = {
+ hello: function(options) {
+ return options.data.accessData + " " + options.fn({exclaim: "?"});
+ },
+ world: function(thing, options) {
+ return options.data.adjective + " " + thing + (this.exclaim || "");
+ }
+ };
+
+ var result = template({exclaim: true, zomg: "world"}, {helpers: helpers, data: {adjective: "happy", accessData: "#win"}});
+ equals("#win happy world?", result, "Data output by helper");
+ });
+
+ it("you can override inherited data when invoking a helper", function() {
+ var template = CompilerContext.compile("{{#hello}}{{world zomg}}{{/hello}}", {data: true});
+
+ var helpers = {
+ hello: function(options) {
+ return options.fn({exclaim: "?", zomg: "world"}, { data: {adjective: "sad"} });
+ },
+ world: function(thing, options) {
+ return options.data.adjective + " " + thing + (this.exclaim || "");
+ }
+ };
+
+ var result = template({exclaim: true, zomg: "planet"}, {helpers: helpers, data: {adjective: "happy"}});
+ equals("sad world?", result, "Overriden data output by helper");
+ });
+
+
+ it("you can override inherited data when invoking a helper with depth", function() {
+ var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
+
+ var helpers = {
+ hello: function(options) {
+ return options.fn({exclaim: "?"}, { data: {adjective: "sad"} });
+ },
+ world: function(thing, options) {
+ return options.data.adjective + " " + thing + (this.exclaim || "");
+ }
+ };
+
+ var result = template({exclaim: true, zomg: "world"}, {helpers: helpers, data: {adjective: "happy"}});
+ equals("sad world?", result, "Overriden data output by helper");
+ });
+
+ describe('@root', function() {
+ it('the root context can be looked up via @root', function() {
+ var template = CompilerContext.compile('{{@root.foo}}');
+ var result = template({foo: 'hello'}, { data: {} });
+ equals('hello', result);
+
+ result = template({foo: 'hello'}, {});
+ equals('hello', result);
+ });
+ it('passed root values take priority', function() {
+ var template = CompilerContext.compile('{{@root.foo}}');
+ var result = template({}, { data: {root: {foo: 'hello'} } });
+ equals('hello', result);
+ });
+ });
+
+ describe('nesting', function() {
+ it('the root context can be looked up via @root', function() {
+ var template = CompilerContext.compile('{{#helper}}{{#helper}}{{@./depth}} {{@../depth}} {{@../../depth}}{{/helper}}{{/helper}}');
+ var result = template({foo: 'hello'}, {
+ helpers: {
+ helper: function(options) {
+ var frame = Handlebars.createFrame(options.data);
+ frame.depth = options.data.depth + 1;
+ return options.fn(this, {data: frame});
+ }
+ },
+ data: {
+ depth: 0
+ }
+ });
+ equals('2 1 0', result);
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 | +1 + +1 + + + +1 +1 + +1 + + + + + + + + + +1 + + + + + + + + | /*global handlebarsEnv */
+require('./common');
+
+var _ = require('underscore'),
+ fs = require('fs'),
+ vm = require('vm');
+
+global.Handlebars = undefined;
+vm.runInThisContext(fs.readFileSync(__dirname + '/../../dist/handlebars.js'), 'dist/handlebars.js');
+
+global.CompilerContext = {
+ compile: function(template, options) {
+ var templateSpec = handlebarsEnv.precompile(template, options);
+ return handlebarsEnv.template(safeEval(templateSpec));
+ },
+ compileWithPartial: function(template, options) {
+ return handlebarsEnv.compile(template, options);
+ }
+};
+
+function safeEval(templateSpec) {
+ try {
+ return eval('(' + templateSpec + ')');
+ } catch (err) {
+ console.error(templateSpec);
+ throw err;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 | +1 + + + +1 + + + + + + +1 + + + + + + + + + + + + + + + + + +1 + + + + + +1 + + + + + + + + + + + + + + + + + | /*global CompilerContext, compileWithPartials, shouldCompileToWithPartials */ +global.shouldCompileTo = function(string, hashOrArray, expected, message) { + shouldCompileToWithPartials(string, hashOrArray, false, expected, message); +}; + +global.shouldCompileToWithPartials = function(string, hashOrArray, partials, expected, message) { + var result = compileWithPartials(string, hashOrArray, partials); + if (result !== expected) { + throw new Error("'" + result + "' should === '" + expected + "': " + message); + } +}; + +global.compileWithPartials = function(string, hashOrArray, partials) { + var template, + ary, + options; + if(Object.prototype.toString.call(hashOrArray) === "[object Array]") { + ary = []; + ary.push(hashOrArray[0]); + ary.push({ helpers: hashOrArray[1], partials: hashOrArray[2] }); + options = {compat: hashOrArray[3]}; + } else { + ary = [hashOrArray]; + } + + template = CompilerContext[partials ? 'compileWithPartial' : 'compile'](string, options); + return template.apply(this, ary); +}; + + +global.equals = global.equal = function(a, b, msg) { + if (a !== b) { + throw new Error("'" + a + "' should === '" + b + "'" + (msg ? ": " + msg : '')); + } +}; + +global.shouldThrow = function(callback, type, msg) { + var failed; + try { + callback(); + failed = true; + } catch (err) { + if (type && !(err instanceof type)) { + throw new Error('Type failure'); + } + if (msg && !(msg.test ? msg.test(err.message) : msg === err.message)) { + throw new Error('Message failure'); + } + } + if (failed) { + throw new Error('It failed to throw'); + } +}; + |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| browser.js | ++ | 46.15% | +(6 / 13) | +100% | +(0 / 0) | +0% | +(0 / 3) | +46.15% | +(6 / 13) | +
| common.js | ++ | 16.67% | +(5 / 30) | +0% | +(0 / 22) | +0% | +(0 / 5) | +16.67% | +(5 / 30) | +
| node.js | ++ | 36.36% | +(4 / 11) | +100% | +(0 / 0) | +0% | +(0 / 3) | +36.36% | +(4 / 11) | +
| runner.js | ++ | 100% | +(25 / 25) | +50% | +(1 / 2) | +100% | +(8 / 8) | +100% | +(25 / 25) | +
| runtime.js | ++ | 34.62% | +(9 / 26) | +100% | +(0 / 0) | +0% | +(0 / 5) | +34.62% | +(9 / 26) | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 | +1 + +1 + +1 + + + + + + + + + +1 + + + + + + + + | /*global handlebarsEnv */
+require('./common');
+
+global.Handlebars = require('../../lib');
+
+global.CompilerContext = {
+ compile: function(template, options) {
+ var templateSpec = handlebarsEnv.precompile(template, options);
+ return handlebarsEnv.template(safeEval(templateSpec));
+ },
+ compileWithPartial: function(template, options) {
+ return handlebarsEnv.compile(template, options);
+ }
+};
+
+function safeEval(templateSpec) {
+ try {
+ return eval('(' + templateSpec + ')');
+ } catch (err) {
+ console.error(templateSpec);
+ throw err;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 | 1 + + + +1 + + + +1 + +1 +26 +20 + +1 + +1 +1 +1 +1 + + + + + +1 +3 +3 +3 +3 +3 +3 + + +3 +60 + + +3 +3 +3 +3 +3 + + + | var fs = require('fs'),
+ Mocha = require('mocha'),
+ path = require('path');
+
+var errors = 0,
+ testDir = path.dirname(__dirname),
+ grep = process.argv[2];
+
+var files = [ testDir + "/basic.js" ];
+
+var files = fs.readdirSync(testDir)
+ .filter(function(name) { return (/.*\.js$/).test(name); })
+ .map(function(name) { return testDir + '/' + name; });
+
+console.log(files);
+
+run('./node', function() {
+ run('./browser', function() {
+ run('./runtime', function() {
+ process.exit(errors);
+ });
+ });
+});
+
+
+function run(env, callback) {
+ var mocha = new Mocha();
+ mocha.ui('bdd');
+ mocha.reporter('spec');
+ mocha.files = files.slice();
+ Eif (grep) {
+ mocha.grep(grep);
+ }
+
+ files.forEach(function(name) {
+ delete require.cache[name];
+ });
+
+ console.log('Running env: ' + env);
+ require(env);
+ mocha.run(function(errorCount) {
+ errors += errorCount;
+ callback();
+ });
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 | +1 + +1 + + + +1 +1 + +1 +1 +1 + +1 + + + + + + + + + + + + + + + + + + + + + + + + + +1 + + + + + + + + | /*global handlebarsEnv */
+require('./common');
+
+var _ = require('underscore'),
+ fs = require('fs'),
+ vm = require('vm');
+
+global.Handlebars = undefined;
+vm.runInThisContext(fs.readFileSync(__dirname + '/../../dist/handlebars.runtime.js'), 'dist/handlebars.runtime.js');
+
+var parse = require('../../dist/cjs/handlebars/compiler/base').parse;
+var compiler = require('../../dist/cjs/handlebars/compiler/compiler');
+var JavaScriptCompiler = require('../../dist/cjs/handlebars/compiler/javascript-compiler')['default'];
+
+global.CompilerContext = {
+ compile: function(template, options) {
+ // Hack the compiler on to the environment for these specific tests
+ handlebarsEnv.precompile = function(template, options) {
+ return compiler.precompile(template, options, handlebarsEnv);
+ };
+ handlebarsEnv.parse = parse;
+ handlebarsEnv.Compiler = compiler.Compiler;
+ handlebarsEnv.JavaScriptCompiler = JavaScriptCompiler;
+
+ var templateSpec = handlebarsEnv.precompile(template, options);
+ return handlebarsEnv.template(safeEval(templateSpec));
+ },
+ compileWithPartial: function(template, options) {
+ // Hack the compiler on to the environment for these specific tests
+ handlebarsEnv.compile = function(template, options) {
+ return compiler.compile(template, options, handlebarsEnv);
+ };
+ handlebarsEnv.parse = parse;
+ handlebarsEnv.Compiler = compiler.Compiler;
+ handlebarsEnv.JavaScriptCompiler = JavaScriptCompiler;
+
+ return handlebarsEnv.compile(template, options);
+ }
+};
+
+function safeEval(templateSpec) {
+ try {
+ return eval('(' + templateSpec + ')');
+ } catch (err) {
+ console.error(templateSpec);
+ throw err;
+ }
+}
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 +404 +405 +406 +407 +408 +409 +410 +411 +412 +413 +414 +415 +416 +417 +418 +419 +420 +421 +422 +423 +424 +425 +426 +427 +428 +429 +430 +431 +432 +433 +434 +435 +436 +437 +438 +439 +440 +441 +442 +443 +444 +445 +446 +447 +448 +449 +450 +451 +452 +453 +454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 +480 +481 +482 +483 +484 +485 +486 +487 +488 +489 +490 +491 +492 +493 +494 +495 +496 +497 +498 +499 +500 +501 +502 +503 +504 +505 +506 +507 +508 +509 +510 +511 +512 +513 +514 +515 +516 +517 +518 +519 +520 +521 +522 +523 +524 +525 +526 +527 +528 +529 +530 +531 +532 +533 +534 +535 +536 +537 +538 +539 +540 +541 +542 +543 +544 +545 +546 +547 +548 +549 +550 +551 +552 +553 +554 +555 +556 +557 +558 +559 +560 +561 +562 +563 +564 +565 +566 +567 +568 +569 +570 +571 +572 +573 +574 +575 +576 +577 +578 +579 +580 +581 +582 +583 +584 +585 +586 +587 +588 +589 +590 +591 +592 +593 +594 +595 +596 +597 +598 +599 +600 +601 +602 +603 +604 +605 +606 +607 +608 +609 +610 +611 +612 +613 +614 +615 +616 +617 +618 +619 +620 +621 | +3 +3 + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + +3 + + + + + + + + + + + + + +3 + + + + + + + + +3 + + + + + + + + +3 + + + + + + + +3 + + + + + + + +3 + + + + + + + + + + + + +3 + + + +3 + + + + + + + +3 + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 +3 + + + + + + + +3 + + + + + + +3 + + + + + +3 + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + + +3 + + + + + + + + + +3 +3 + + + + + + + + + + + +3 + + + + + + +3 + + + + + + +3 + + + + + + + +3 + + + + + + + + + +3 +3 + + + + + + +3 + + + + + + + + + +3 +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + +3 + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + +3 +3 + + + + + + +3 + + + + + + + + + + + + + + + +3 +3 + + + + + + +3 + + + + + +3 + + + + + +3 + + + + + +3 + + + + + +3 + + + + + +3 + + + + +3 + + + + + + +3 +3 + + + + +3 + + + + + + +3 +3 +3 + + + + + + + + + + + +3 + + +3 + + +3 + + +3 + + +3 + + +3 + + + + + +3 + + + +3 + + + + +3 +3 + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + + | /*global CompilerContext, Handlebars, shouldCompileTo, shouldCompileToWithPartials, shouldThrow, handlebarsEnv */
+describe('helpers', function() {
+ it("helper with complex lookup$", function() {
+ var string = "{{#goodbyes}}{{{link ../prefix}}}{{/goodbyes}}";
+ var hash = {prefix: "/root", goodbyes: [{text: "Goodbye", url: "goodbye"}]};
+ var helpers = {link: function(prefix) {
+ return "<a href='" + prefix + "/" + this.url + "'>" + this.text + "</a>";
+ }};
+ shouldCompileTo(string, [hash, helpers], "<a href='/root/goodbye'>Goodbye</a>");
+ });
+
+ it("helper for raw block gets raw content", function() {
+ var string = "{{{{raw}}}} {{test}} {{{{/raw}}}}";
+ var hash = { test: "hello" };
+ var helpers = { raw: function(options) {
+ return options.fn();
+ } };
+ shouldCompileTo(string, [hash, helpers], " {{test}} ",
+ "raw block helper gets raw content");
+ });
+
+ it("helper for raw block gets parameters", function() {
+ var string = "{{{{raw 1 2 3}}}} {{test}} {{{{/raw}}}}";
+ var hash = { test: "hello" };
+ var helpers = { raw: function(a, b, c, options) {
+ return options.fn() + a + b + c;
+ } };
+ shouldCompileTo(string, [hash, helpers], " {{test}} 123",
+ "raw block helper gets raw content");
+ });
+
+ it("helper block with complex lookup expression", function() {
+ var string = "{{#goodbyes}}{{../name}}{{/goodbyes}}";
+ var hash = {name: "Alan"};
+ var helpers = {goodbyes: function(options) {
+ var out = "";
+ var byes = ["Goodbye", "goodbye", "GOODBYE"];
+ for (var i = 0,j = byes.length; i < j; i++) {
+ out += byes[i] + " " + options.fn(this) + "! ";
+ }
+ return out;
+ }};
+ shouldCompileTo(string, [hash, helpers], "Goodbye Alan! goodbye Alan! GOODBYE Alan! ");
+ });
+
+ it("helper with complex lookup and nested template", function() {
+ var string = "{{#goodbyes}}{{#link ../prefix}}{{text}}{{/link}}{{/goodbyes}}";
+ var hash = {prefix: '/root', goodbyes: [{text: "Goodbye", url: "goodbye"}]};
+ var helpers = {link: function (prefix, options) {
+ return "<a href='" + prefix + "/" + this.url + "'>" + options.fn(this) + "</a>";
+ }};
+ shouldCompileToWithPartials(string, [hash, helpers], false, "<a href='/root/goodbye'>Goodbye</a>");
+ });
+
+ it("helper with complex lookup and nested template in VM+Compiler", function() {
+ var string = "{{#goodbyes}}{{#link ../prefix}}{{text}}{{/link}}{{/goodbyes}}";
+ var hash = {prefix: '/root', goodbyes: [{text: "Goodbye", url: "goodbye"}]};
+ var helpers = {link: function (prefix, options) {
+ return "<a href='" + prefix + "/" + this.url + "'>" + options.fn(this) + "</a>";
+ }};
+ shouldCompileToWithPartials(string, [hash, helpers], true, "<a href='/root/goodbye'>Goodbye</a>");
+ });
+
+ it("block helper", function() {
+ var string = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!";
+ var template = CompilerContext.compile(string);
+
+ var result = template({world: "world"}, { helpers: {goodbyes: function(options) { return options.fn({text: "GOODBYE"}); }}});
+ equal(result, "GOODBYE! cruel world!", "Block helper executed");
+ });
+
+ it("block helper staying in the same context", function() {
+ var string = "{{#form}}<p>{{name}}</p>{{/form}}";
+ var template = CompilerContext.compile(string);
+
+ var result = template({name: "Yehuda"}, {helpers: {form: function(options) { return "<form>" + options.fn(this) + "</form>"; } }});
+ equal(result, "<form><p>Yehuda</p></form>", "Block helper executed with current context");
+ });
+
+ it("block helper should have context in this", function() {
+ var source = "<ul>{{#people}}<li>{{#link}}{{name}}{{/link}}</li>{{/people}}</ul>";
+ var link = function(options) {
+ return '<a href="/people/' + this.id + '">' + options.fn(this) + '</a>';
+ };
+ var data = { "people": [
+ { "name": "Alan", "id": 1 },
+ { "name": "Yehuda", "id": 2 }
+ ]};
+
+ shouldCompileTo(source, [data, {link: link}], "<ul><li><a href=\"/people/1\">Alan</a></li><li><a href=\"/people/2\">Yehuda</a></li></ul>");
+ });
+
+ it("block helper for undefined value", function() {
+ shouldCompileTo("{{#empty}}shouldn't render{{/empty}}", {}, "");
+ });
+
+ it("block helper passing a new context", function() {
+ var string = "{{#form yehuda}}<p>{{name}}</p>{{/form}}";
+ var template = CompilerContext.compile(string);
+
+ var result = template({yehuda: {name: "Yehuda"}}, { helpers: {form: function(context, options) { return "<form>" + options.fn(context) + "</form>"; }}});
+ equal(result, "<form><p>Yehuda</p></form>", "Context variable resolved");
+ });
+
+ it("block helper passing a complex path context", function() {
+ var string = "{{#form yehuda/cat}}<p>{{name}}</p>{{/form}}";
+ var template = CompilerContext.compile(string);
+
+ var result = template({yehuda: {name: "Yehuda", cat: {name: "Harold"}}}, { helpers: {form: function(context, options) { return "<form>" + options.fn(context) + "</form>"; }}});
+ equal(result, "<form><p>Harold</p></form>", "Complex path variable resolved");
+ });
+
+ it("nested block helpers", function() {
+ var string = "{{#form yehuda}}<p>{{name}}</p>{{#link}}Hello{{/link}}{{/form}}";
+ var template = CompilerContext.compile(string);
+
+ var result = template({
+ yehuda: {name: "Yehuda" }
+ }, {
+ helpers: {
+ link: function(options) { return "<a href='" + this.name + "'>" + options.fn(this) + "</a>"; },
+ form: function(context, options) { return "<form>" + options.fn(context) + "</form>"; }
+ }
+ });
+ equal(result, "<form><p>Yehuda</p><a href='Yehuda'>Hello</a></form>", "Both blocks executed");
+ });
+
+ it("block helper inverted sections", function() {
+ var string = "{{#list people}}{{name}}{{^}}<em>Nobody's here</em>{{/list}}";
+ var list = function(context, options) {
+ if (context.length > 0) {
+ var out = "<ul>";
+ for(var i = 0,j=context.length; i < j; i++) {
+ out += "<li>";
+ out += options.fn(context[i]);
+ out += "</li>";
+ }
+ out += "</ul>";
+ return out;
+ } else {
+ return "<p>" + options.inverse(this) + "</p>";
+ }
+ };
+
+ var hash = {people: [{name: "Alan"}, {name: "Yehuda"}]};
+ var empty = {people: []};
+ var rootMessage = {
+ people: [],
+ message: "Nobody's here"
+ };
+
+ var messageString = "{{#list people}}Hello{{^}}{{message}}{{/list}}";
+
+ // the meaning here may be kind of hard to catch, but list.not is always called,
+ // so we should see the output of both
+ shouldCompileTo(string, [hash, { list: list }], "<ul><li>Alan</li><li>Yehuda</li></ul>", "an inverse wrapper is passed in as a new context");
+ shouldCompileTo(string, [empty, { list: list }], "<p><em>Nobody's here</em></p>", "an inverse wrapper can be optionally called");
+ shouldCompileTo(messageString, [rootMessage, { list: list }], "<p>Nobody's here</p>", "the context of an inverse is the parent of the block");
+ });
+
+ it('pathed lambas with parameters', function() {
+ var hash = {
+ helper: function() {
+ return 'winning';
+ }
+ };
+ hash.hash = hash;
+ var helpers = {
+ './helper': function() {
+ return 'fail';
+ }
+ };
+ shouldCompileTo('{{./helper 1}}', [hash, helpers], 'winning');
+ shouldCompileTo('{{hash/helper 1}}', [hash, helpers], 'winning');
+ });
+
+ describe("helpers hash", function() {
+ it("providing a helpers hash", function() {
+ shouldCompileTo("Goodbye {{cruel}} {{world}}!", [{cruel: "cruel"}, {world: function() { return "world"; }}], "Goodbye cruel world!",
+ "helpers hash is available");
+
+ shouldCompileTo("Goodbye {{#iter}}{{cruel}} {{world}}{{/iter}}!", [{iter: [{cruel: "cruel"}]}, {world: function() { return "world"; }}],
+ "Goodbye cruel world!", "helpers hash is available inside other blocks");
+ });
+
+ it("in cases of conflict, helpers win", function() {
+ shouldCompileTo("{{{lookup}}}", [{lookup: 'Explicit'}, {lookup: function() { return 'helpers'; }}], "helpers",
+ "helpers hash has precedence escaped expansion");
+ shouldCompileTo("{{lookup}}", [{lookup: 'Explicit'}, {lookup: function() { return 'helpers'; }}], "helpers",
+ "helpers hash has precedence simple expansion");
+ });
+
+ it("the helpers hash is available is nested contexts", function() {
+ shouldCompileTo("{{#outer}}{{#inner}}{{helper}}{{/inner}}{{/outer}}",
+ [{'outer': {'inner': {'unused':[]}}}, {'helper': function() { return 'helper'; }}], "helper",
+ "helpers hash is available in nested contexts.");
+ });
+
+ it("the helper hash should augment the global hash", function() {
+ handlebarsEnv.registerHelper('test_helper', function() { return 'found it!'; });
+
+ shouldCompileTo(
+ "{{test_helper}} {{#if cruel}}Goodbye {{cruel}} {{world}}!{{/if}}", [
+ {cruel: "cruel"},
+ {world: function() { return "world!"; }}
+ ],
+ "found it! Goodbye cruel world!!");
+ });
+ });
+
+ it("Multiple global helper registration", function() {
+ var helpers = handlebarsEnv.helpers;
+ handlebarsEnv.helpers = {};
+
+ handlebarsEnv.registerHelper({
+ 'if': helpers['if'],
+ world: function() { return "world!"; },
+ test_helper: function() { return 'found it!'; }
+ });
+
+ shouldCompileTo(
+ "{{test_helper}} {{#if cruel}}Goodbye {{cruel}} {{world}}!{{/if}}",
+ [{cruel: "cruel"}],
+ "found it! Goodbye cruel world!!");
+ });
+
+ it("decimal number literals work", function() {
+ var string = 'Message: {{hello -1.2 1.2}}';
+ var hash = {};
+ var helpers = {hello: function(times, times2) {
+ if(typeof times !== 'number') { times = "NaN"; }
+ if(typeof times2 !== 'number') { times2 = "NaN"; }
+ return "Hello " + times + " " + times2 + " times";
+ }};
+ shouldCompileTo(string, [hash, helpers], "Message: Hello -1.2 1.2 times", "template with a negative integer literal");
+ });
+
+ it("negative number literals work", function() {
+ var string = 'Message: {{hello -12}}';
+ var hash = {};
+ var helpers = {hello: function(times) {
+ if(typeof times !== 'number') { times = "NaN"; }
+ return "Hello " + times + " times";
+ }};
+ shouldCompileTo(string, [hash, helpers], "Message: Hello -12 times", "template with a negative integer literal");
+ });
+
+ describe("String literal parameters", function() {
+ it("simple literals work", function() {
+ var string = 'Message: {{hello "world" 12 true false}}';
+ var hash = {};
+ var helpers = {hello: function(param, times, bool1, bool2) {
+ if(typeof times !== 'number') { times = "NaN"; }
+ if(typeof bool1 !== 'boolean') { bool1 = "NaB"; }
+ if(typeof bool2 !== 'boolean') { bool2 = "NaB"; }
+ return "Hello " + param + " " + times + " times: " + bool1 + " " + bool2;
+ }};
+ shouldCompileTo(string, [hash, helpers], "Message: Hello world 12 times: true false", "template with a simple String literal");
+ });
+
+ it("using a quote in the middle of a parameter raises an error", function() {
+ var string = 'Message: {{hello wo"rld"}}';
+ shouldThrow(function() {
+ CompilerContext.compile(string);
+ }, Error);
+ });
+
+ it("escaping a String is possible", function(){
+ var string = 'Message: {{{hello "\\"world\\""}}}';
+ var hash = {};
+ var helpers = {hello: function(param) { return "Hello " + param; }};
+ shouldCompileTo(string, [hash, helpers], "Message: Hello \"world\"", "template with an escaped String literal");
+ });
+
+ it("it works with ' marks", function() {
+ var string = 'Message: {{{hello "Alan\'s world"}}}';
+ var hash = {};
+ var helpers = {hello: function(param) { return "Hello " + param; }};
+ shouldCompileTo(string, [hash, helpers], "Message: Hello Alan's world", "template with a ' mark");
+ });
+ });
+
+ it("negative number literals work", function() {
+ var string = 'Message: {{hello -12}}';
+ var hash = {};
+ var helpers = {hello: function(times) {
+ if(typeof times !== 'number') { times = "NaN"; }
+ return "Hello " + times + " times";
+ }};
+ shouldCompileTo(string, [hash, helpers], "Message: Hello -12 times", "template with a negative integer literal");
+ });
+
+ describe("multiple parameters", function() {
+ it("simple multi-params work", function() {
+ var string = 'Message: {{goodbye cruel world}}';
+ var hash = {cruel: "cruel", world: "world"};
+ var helpers = {goodbye: function(cruel, world) { return "Goodbye " + cruel + " " + world; }};
+ shouldCompileTo(string, [hash, helpers], "Message: Goodbye cruel world", "regular helpers with multiple params");
+ });
+
+ it("block multi-params work", function() {
+ var string = 'Message: {{#goodbye cruel world}}{{greeting}} {{adj}} {{noun}}{{/goodbye}}';
+ var hash = {cruel: "cruel", world: "world"};
+ var helpers = {goodbye: function(cruel, world, options) {
+ return options.fn({greeting: "Goodbye", adj: cruel, noun: world});
+ }};
+ shouldCompileTo(string, [hash, helpers], "Message: Goodbye cruel world", "block helpers with multiple params");
+ });
+ });
+
+ describe('hash', function() {
+ it("helpers can take an optional hash", function() {
+ var template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" times=12}}');
+
+ var helpers = {
+ goodbye: function(options) {
+ return "GOODBYE " + options.hash.cruel + " " + options.hash.world + " " + options.hash.times + " TIMES";
+ }
+ };
+
+ var context = {};
+
+ var result = template(context, {helpers: helpers});
+ equals(result, "GOODBYE CRUEL WORLD 12 TIMES", "Helper output hash");
+ });
+
+ it("helpers can take an optional hash with booleans", function() {
+ var helpers = {
+ goodbye: function(options) {
+ if (options.hash.print === true) {
+ return "GOODBYE " + options.hash.cruel + " " + options.hash.world;
+ } else if (options.hash.print === false) {
+ return "NOT PRINTING";
+ } else {
+ return "THIS SHOULD NOT HAPPEN";
+ }
+ }
+ };
+
+ var context = {};
+
+ var template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" print=true}}');
+ var result = template(context, {helpers: helpers});
+ equals(result, "GOODBYE CRUEL WORLD", "Helper output hash");
+
+ template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" print=false}}');
+ result = template(context, {helpers: helpers});
+ equals(result, "NOT PRINTING", "Boolean helper parameter honored");
+ });
+
+ it("block helpers can take an optional hash", function() {
+ var template = CompilerContext.compile('{{#goodbye cruel="CRUEL" times=12}}world{{/goodbye}}');
+
+ var helpers = {
+ goodbye: function(options) {
+ return "GOODBYE " + options.hash.cruel + " " + options.fn(this) + " " + options.hash.times + " TIMES";
+ }
+ };
+
+ var result = template({}, {helpers: helpers});
+ equals(result, "GOODBYE CRUEL world 12 TIMES", "Hash parameters output");
+ });
+
+ it("block helpers can take an optional hash with single quoted stings", function() {
+ var template = CompilerContext.compile("{{#goodbye cruel='CRUEL' times=12}}world{{/goodbye}}");
+
+ var helpers = {
+ goodbye: function(options) {
+ return "GOODBYE " + options.hash.cruel + " " + options.fn(this) + " " + options.hash.times + " TIMES";
+ }
+ };
+
+ var result = template({}, {helpers: helpers});
+ equals(result, "GOODBYE CRUEL world 12 TIMES", "Hash parameters output");
+ });
+
+ it("block helpers can take an optional hash with booleans", function() {
+ var helpers = {
+ goodbye: function(options) {
+ if (options.hash.print === true) {
+ return "GOODBYE " + options.hash.cruel + " " + options.fn(this);
+ } else if (options.hash.print === false) {
+ return "NOT PRINTING";
+ } else {
+ return "THIS SHOULD NOT HAPPEN";
+ }
+ }
+ };
+
+ var template = CompilerContext.compile('{{#goodbye cruel="CRUEL" print=true}}world{{/goodbye}}');
+ var result = template({}, {helpers: helpers});
+ equals(result, "GOODBYE CRUEL world", "Boolean hash parameter honored");
+
+ template = CompilerContext.compile('{{#goodbye cruel="CRUEL" print=false}}world{{/goodbye}}');
+ result = template({}, {helpers: helpers});
+ equals(result, "NOT PRINTING", "Boolean hash parameter honored");
+ });
+ });
+
+ describe("helperMissing", function() {
+ it("if a context is not found, helperMissing is used", function() {
+ shouldThrow(function() {
+ var template = CompilerContext.compile("{{hello}} {{link_to world}}");
+ template({});
+ }, undefined, /Missing helper: 'link_to'/);
+ });
+
+ it("if a context is not found, custom helperMissing is used", function() {
+ var string = "{{hello}} {{link_to world}}";
+ var context = { hello: "Hello", world: "world" };
+
+ var helpers = {
+ helperMissing: function(mesg, options) {
+ if(options.name === "link_to") {
+ return new Handlebars.SafeString("<a>" + mesg + "</a>");
+ }
+ }
+ };
+
+ shouldCompileTo(string, [context, helpers], "Hello <a>world</a>");
+ });
+ });
+
+ describe("knownHelpers", function() {
+ it("Known helper should render helper", function() {
+ var template = CompilerContext.compile("{{hello}}", {knownHelpers: {"hello" : true}});
+
+ var result = template({}, {helpers: {hello: function() { return "foo"; }}});
+ equal(result, "foo", "'foo' should === '" + result);
+ });
+
+ it("Unknown helper in knownHelpers only mode should be passed as undefined", function() {
+ var template = CompilerContext.compile("{{typeof hello}}", {knownHelpers: {'typeof': true}, knownHelpersOnly: true});
+
+ var result = template({}, {helpers: {'typeof': function(arg) { return typeof arg; }, hello: function() { return "foo"; }}});
+ equal(result, "undefined", "'undefined' should === '" + result);
+ });
+ it("Builtin helpers available in knownHelpers only mode", function() {
+ var template = CompilerContext.compile("{{#unless foo}}bar{{/unless}}", {knownHelpersOnly: true});
+
+ var result = template({});
+ equal(result, "bar", "'bar' should === '" + result);
+ });
+ it("Field lookup works in knownHelpers only mode", function() {
+ var template = CompilerContext.compile("{{foo}}", {knownHelpersOnly: true});
+
+ var result = template({foo: 'bar'});
+ equal(result, "bar", "'bar' should === '" + result);
+ });
+ it("Conditional blocks work in knownHelpers only mode", function() {
+ var template = CompilerContext.compile("{{#foo}}bar{{/foo}}", {knownHelpersOnly: true});
+
+ var result = template({foo: 'baz'});
+ equal(result, "bar", "'bar' should === '" + result);
+ });
+ it("Invert blocks work in knownHelpers only mode", function() {
+ var template = CompilerContext.compile("{{^foo}}bar{{/foo}}", {knownHelpersOnly: true});
+
+ var result = template({foo: false});
+ equal(result, "bar", "'bar' should === '" + result);
+ });
+ it("Functions are bound to the context in knownHelpers only mode", function() {
+ var template = CompilerContext.compile("{{foo}}", {knownHelpersOnly: true});
+ var result = template({foo: function() { return this.bar; }, bar: 'bar'});
+ equal(result, "bar", "'bar' should === '" + result);
+ });
+ it("Unknown helper call in knownHelpers only mode should throw", function() {
+ shouldThrow(function() {
+ CompilerContext.compile("{{typeof hello}}", {knownHelpersOnly: true});
+ }, Error);
+ });
+ });
+
+ describe("blockHelperMissing", function() {
+ it("lambdas are resolved by blockHelperMissing, not handlebars proper", function() {
+ var string = "{{#truthy}}yep{{/truthy}}";
+ var data = { truthy: function() { return true; } };
+ shouldCompileTo(string, data, "yep");
+ });
+ it("lambdas resolved by blockHelperMissing are bound to the context", function() {
+ var string = "{{#truthy}}yep{{/truthy}}";
+ var boundData = { truthy: function() { return this.truthiness(); }, truthiness: function() { return false; } };
+ shouldCompileTo(string, boundData, "");
+ });
+ });
+
+ describe('name field', function() {
+ var context = {};
+ var helpers = {
+ blockHelperMissing: function() {
+ return 'missing: ' + arguments[arguments.length-1].name;
+ },
+ helperMissing: function() {
+ return 'helper missing: ' + arguments[arguments.length-1].name;
+ },
+ helper: function() {
+ return 'ran: ' + arguments[arguments.length-1].name;
+ }
+ };
+
+ it('should include in ambiguous mustache calls', function() {
+ shouldCompileTo('{{helper}}', [context, helpers], 'ran: helper');
+ });
+ it('should include in helper mustache calls', function() {
+ shouldCompileTo('{{helper 1}}', [context, helpers], 'ran: helper');
+ });
+ it('should include in ambiguous block calls', function() {
+ shouldCompileTo('{{#helper}}{{/helper}}', [context, helpers], 'ran: helper');
+ });
+ it('should include in simple block calls', function() {
+ shouldCompileTo('{{#./helper}}{{/./helper}}', [context, helpers], 'missing: ./helper');
+ });
+ it('should include in helper block calls', function() {
+ shouldCompileTo('{{#helper 1}}{{/helper}}', [context, helpers], 'ran: helper');
+ });
+ it('should include in known helper calls', function() {
+ var template = CompilerContext.compile("{{helper}}", {knownHelpers: {'helper': true}, knownHelpersOnly: true});
+
+ equal(template({}, {helpers: helpers}), 'ran: helper');
+ });
+
+ it('should include full id', function() {
+ shouldCompileTo('{{#foo.helper}}{{/foo.helper}}', [{foo: {}}, helpers], 'missing: foo.helper');
+ });
+
+ it('should include full id if a hash is passed', function() {
+ shouldCompileTo('{{#foo.helper bar=baz}}{{/foo.helper}}', [{foo: {}}, helpers], 'helper missing: foo.helper');
+ });
+ });
+
+ describe('name conflicts', function() {
+ it("helpers take precedence over same-named context properties", function() {
+ var template = CompilerContext.compile("{{goodbye}} {{cruel world}}");
+
+ var helpers = {
+ goodbye: function() {
+ return this.goodbye.toUpperCase();
+ },
+
+ cruel: function(world) {
+ return "cruel " + world.toUpperCase();
+ }
+ };
+
+ var context = {
+ goodbye: "goodbye",
+ world: "world"
+ };
+
+ var result = template(context, {helpers: helpers});
+ equals(result, "GOODBYE cruel WORLD", "Helper executed");
+ });
+
+ it("helpers take precedence over same-named context properties$", function() {
+ var template = CompilerContext.compile("{{#goodbye}} {{cruel world}}{{/goodbye}}");
+
+ var helpers = {
+ goodbye: function(options) {
+ return this.goodbye.toUpperCase() + options.fn(this);
+ },
+
+ cruel: function(world) {
+ return "cruel " + world.toUpperCase();
+ }
+ };
+
+ var context = {
+ goodbye: "goodbye",
+ world: "world"
+ };
+
+ var result = template(context, {helpers: helpers});
+ equals(result, "GOODBYE cruel WORLD", "Helper executed");
+ });
+
+ it("Scoped names take precedence over helpers", function() {
+ var template = CompilerContext.compile("{{this.goodbye}} {{cruel world}} {{cruel this.goodbye}}");
+
+ var helpers = {
+ goodbye: function() {
+ return this.goodbye.toUpperCase();
+ },
+
+ cruel: function(world) {
+ return "cruel " + world.toUpperCase();
+ }
+ };
+
+ var context = {
+ goodbye: "goodbye",
+ world: "world"
+ };
+
+ var result = template(context, {helpers: helpers});
+ equals(result, "goodbye cruel WORLD cruel GOODBYE", "Helper not executed");
+ });
+
+ it("Scoped names take precedence over block helpers", function() {
+ var template = CompilerContext.compile("{{#goodbye}} {{cruel world}}{{/goodbye}} {{this.goodbye}}");
+
+ var helpers = {
+ goodbye: function(options) {
+ return this.goodbye.toUpperCase() + options.fn(this);
+ },
+
+ cruel: function(world) {
+ return "cruel " + world.toUpperCase();
+ }
+ };
+
+ var context = {
+ goodbye: "goodbye",
+ world: "world"
+ };
+
+ var result = template(context, {helpers: helpers});
+ equals(result, "GOODBYE cruel WORLD goodbye", "Helper executed");
+ });
+ });
+});
+ |
| File | ++ | Statements | ++ | Branches | ++ | Functions | ++ | Lines | ++ |
|---|---|---|---|---|---|---|---|---|---|
| ast.js | ++ | 28.99% | +(69 / 238) | +100% | +(2 / 2) | +30.88% | +(21 / 68) | +28.99% | +(69 / 238) | +
| basic.js | ++ | 29.31% | +(34 / 116) | +100% | +(0 / 0) | +2.13% | +(1 / 47) | +30.09% | +(34 / 113) | +
| blocks.js | ++ | 29.69% | +(19 / 64) | +100% | +(0 / 0) | +20% | +(4 / 20) | +29.69% | +(19 / 64) | +
| builtins.js | ++ | 20% | +(27 / 135) | +0% | +(0 / 4) | +13.89% | +(5 / 36) | +20.93% | +(27 / 129) | +
| data.js | ++ | 17.6% | +(22 / 125) | +0% | +(0 / 12) | +6.98% | +(3 / 43) | +17.6% | +(22 / 125) | +
| helpers.js | ++ | 19.23% | +(70 / 364) | +0% | +(0 / 26) | +7.81% | +(10 / 128) | +20.71% | +(70 / 338) | +
| javascript-compiler.js | ++ | 41.3% | +(19 / 46) | +50% | +(2 / 4) | +21.05% | +(4 / 19) | +41.3% | +(19 / 46) | +
| parser.js | ++ | 37.5% | +(39 / 104) | +100% | +(2 / 2) | +4.44% | +(2 / 45) | +37.5% | +(39 / 104) | +
| partials.js | ++ | 21.74% | +(25 / 115) | +100% | +(0 / 0) | +10.71% | +(3 / 28) | +21.74% | +(25 / 115) | +
| precompiler.js | ++ | 42.86% | +(9 / 21) | +50% | +(1 / 2) | +11.11% | +(1 / 9) | +42.86% | +(9 / 21) | +
| regressions.js | ++ | 27.94% | +(19 / 68) | +100% | +(2 / 2) | +4% | +(1 / 25) | +27.94% | +(19 / 68) | +
| require.js | ++ | 28.57% | +(4 / 14) | +75% | +(3 / 4) | +33.33% | +(1 / 3) | +28.57% | +(4 / 14) | +
| runtime.js | ++ | 100% | +(3 / 3) | +100% | +(0 / 0) | +100% | +(2 / 2) | +100% | +(3 / 3) | +
| spec.js | ++ | 76.19% | +(16 / 21) | +73.33% | +(11 / 15) | +83.33% | +(5 / 6) | +76.19% | +(16 / 21) | +
| string-params.js | ++ | 11.9% | +(10 / 84) | +100% | +(0 / 0) | +4.35% | +(1 / 23) | +11.9% | +(10 / 84) | +
| subexpressions.js | ++ | 13.33% | +(14 / 105) | +0% | +(0 / 4) | +2.56% | +(1 / 39) | +13.33% | +(14 / 105) | +
| tokenizer.js | ++ | 20.91% | +(55 / 263) | +22.22% | +(2 / 9) | +1.89% | +(1 / 53) | +20.91% | +(55 / 263) | +
| track-ids.js | ++ | 27.38% | +(23 / 84) | +100% | +(0 / 0) | +16.67% | +(5 / 30) | +27.38% | +(23 / 84) | +
| utils.js | ++ | 32.43% | +(12 / 37) | +0% | +(0 / 2) | +33.33% | +(4 / 12) | +32.43% | +(12 / 37) | +
| whitespace-control.js | ++ | 19.51% | +(8 / 41) | +100% | +(0 / 0) | +25% | +(2 / 8) | +19.51% | +(8 / 41) | +
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 | +3 +3 +1 + + +2 +2 +2 + + +2 + + + +2 + + + + + + +2 +2 +2 + + + +2 + + + +2 + + + + + + + + + + + +2 +2 +2 + + + + +2 + + + + + +2 + + + + + +2 + + + + + + + + | /*global Handlebars, beforeEach, handlebarsEnv, shouldCompileTo */
+describe('javascript-compiler api', function() {
+ if (!Handlebars.JavaScriptCompiler) {
+ return;
+ }
+
+ describe('#nameLookup', function() {
+ var $superName;
+ beforeEach(function() {
+ $superName = handlebarsEnv.JavaScriptCompiler.prototype.nameLookup;
+ });
+ afterEach(function() {
+ handlebarsEnv.JavaScriptCompiler.prototype.nameLookup = $superName;
+ });
+
+ it('should allow override', function() {
+ handlebarsEnv.JavaScriptCompiler.prototype.nameLookup = function(parent, name) {
+ return parent + '.bar_' + name;
+ };
+ shouldCompileTo("{{foo}}", { bar_foo: "food" }, "food");
+ });
+ });
+ describe('#compilerInfo', function() {
+ var $superCheck, $superInfo;
+ beforeEach(function() {
+ $superCheck = handlebarsEnv.VM.checkRevision;
+ $superInfo = handlebarsEnv.JavaScriptCompiler.prototype.compilerInfo;
+ });
+ afterEach(function() {
+ handlebarsEnv.VM.checkRevision = $superCheck;
+ handlebarsEnv.JavaScriptCompiler.prototype.compilerInfo = $superInfo;
+ });
+ it('should allow compilerInfo override', function() {
+ handlebarsEnv.JavaScriptCompiler.prototype.compilerInfo = function() {
+ return 'crazy';
+ };
+ handlebarsEnv.VM.checkRevision = function(compilerInfo) {
+ if (compilerInfo !== 'crazy') {
+ throw new Error('It didn\'t work');
+ }
+ };
+ shouldCompileTo("{{foo}} ", { foo: "food" }, "food ");
+ });
+ });
+ describe('buffer', function() {
+ var $superAppend, $superCreate;
+ beforeEach(function() {
+ handlebarsEnv.JavaScriptCompiler.prototype.forceBuffer = true;
+ $superAppend = handlebarsEnv.JavaScriptCompiler.prototype.appendToBuffer;
+ $superCreate = handlebarsEnv.JavaScriptCompiler.prototype.initializeBuffer;
+ });
+ afterEach(function() {
+ handlebarsEnv.JavaScriptCompiler.prototype.forceBuffer = false;
+ handlebarsEnv.JavaScriptCompiler.prototype.appendToBuffer = $superAppend;
+ handlebarsEnv.JavaScriptCompiler.prototype.initializeBuffer = $superCreate;
+ });
+
+ it('should allow init buffer override', function() {
+ handlebarsEnv.JavaScriptCompiler.prototype.initializeBuffer = function() {
+ return this.quotedString('foo_');
+ };
+ shouldCompileTo("{{foo}} ", { foo: "food" }, "foo_food ");
+ });
+ it('should allow append buffer override', function() {
+ handlebarsEnv.JavaScriptCompiler.prototype.appendToBuffer = function(string) {
+ return $superAppend.call(this, string + ' + "_foo"');
+ };
+ shouldCompileTo("{{foo}}", { foo: "food" }, "food_foo");
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 | +3 +3 +2 + + +1 + + + + +1 + + + + + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + + +1 + + + +1 + + + + + + + + + + + + + + + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + +1 + + + + + + + + + + + + + + + + + + +1 + + + + + + + + +1 + + + + + +1 +1 + + + + + | /*global Handlebars */
+describe('parser', function() {
+ if (!Handlebars.print) {
+ return;
+ }
+
+ function ast_for(template) {
+ var ast = Handlebars.parse(template);
+ return Handlebars.print(ast);
+ }
+
+ it('parses simple mustaches', function() {
+ equals(ast_for('{{foo}}'), "{{ ID:foo [] }}\n");
+ equals(ast_for('{{foo?}}'), "{{ ID:foo? [] }}\n");
+ equals(ast_for('{{foo_}}'), "{{ ID:foo_ [] }}\n");
+ equals(ast_for('{{foo-}}'), "{{ ID:foo- [] }}\n");
+ equals(ast_for('{{foo:}}'), "{{ ID:foo: [] }}\n");
+ });
+
+ it('parses simple mustaches with data', function() {
+ equals(ast_for("{{@foo}}"), "{{ @ID:foo [] }}\n");
+ });
+
+ it('parses simple mustaches with data paths', function() {
+ equals(ast_for("{{@../foo}}"), "{{ @ID:foo [] }}\n");
+ });
+
+ it('parses mustaches with paths', function() {
+ equals(ast_for("{{foo/bar}}"), "{{ PATH:foo/bar [] }}\n");
+ });
+
+ it('parses mustaches with this/foo', function() {
+ equals(ast_for("{{this/foo}}"), "{{ ID:foo [] }}\n");
+ });
+
+ it('parses mustaches with - in a path', function() {
+ equals(ast_for("{{foo-bar}}"), "{{ ID:foo-bar [] }}\n");
+ });
+
+ it('parses mustaches with parameters', function() {
+ equals(ast_for("{{foo bar}}"), "{{ ID:foo [ID:bar] }}\n");
+ });
+
+ it('parses mustaches with string parameters', function() {
+ equals(ast_for("{{foo bar \"baz\" }}"), '{{ ID:foo [ID:bar, "baz"] }}\n');
+ });
+
+ it('parses mustaches with NUMBER parameters', function() {
+ equals(ast_for("{{foo 1}}"), "{{ ID:foo [NUMBER{1}] }}\n");
+ });
+
+ it('parses mustaches with BOOLEAN parameters', function() {
+ equals(ast_for("{{foo true}}"), "{{ ID:foo [BOOLEAN{true}] }}\n");
+ equals(ast_for("{{foo false}}"), "{{ ID:foo [BOOLEAN{false}] }}\n");
+ });
+
+ it('parses mutaches with DATA parameters', function() {
+ equals(ast_for("{{foo @bar}}"), "{{ ID:foo [@ID:bar] }}\n");
+ });
+
+ it('parses mustaches with hash arguments', function() {
+ equals(ast_for("{{foo bar=baz}}"), "{{ ID:foo [] HASH{bar=ID:baz} }}\n");
+ equals(ast_for("{{foo bar=1}}"), "{{ ID:foo [] HASH{bar=NUMBER{1}} }}\n");
+ equals(ast_for("{{foo bar=true}}"), "{{ ID:foo [] HASH{bar=BOOLEAN{true}} }}\n");
+ equals(ast_for("{{foo bar=false}}"), "{{ ID:foo [] HASH{bar=BOOLEAN{false}} }}\n");
+ equals(ast_for("{{foo bar=@baz}}"), "{{ ID:foo [] HASH{bar=@ID:baz} }}\n");
+
+ equals(ast_for("{{foo bar=baz bat=bam}}"), "{{ ID:foo [] HASH{bar=ID:baz, bat=ID:bam} }}\n");
+ equals(ast_for("{{foo bar=baz bat=\"bam\"}}"), '{{ ID:foo [] HASH{bar=ID:baz, bat="bam"} }}\n');
+
+ equals(ast_for("{{foo bat='bam'}}"), '{{ ID:foo [] HASH{bat="bam"} }}\n');
+
+ equals(ast_for("{{foo omg bar=baz bat=\"bam\"}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam"} }}\n');
+ equals(ast_for("{{foo omg bar=baz bat=\"bam\" baz=1}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=NUMBER{1}} }}\n');
+ equals(ast_for("{{foo omg bar=baz bat=\"bam\" baz=true}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=BOOLEAN{true}} }}\n');
+ equals(ast_for("{{foo omg bar=baz bat=\"bam\" baz=false}}"), '{{ ID:foo [ID:omg] HASH{bar=ID:baz, bat="bam", baz=BOOLEAN{false}} }}\n');
+ });
+
+ it('parses contents followed by a mustache', function() {
+ equals(ast_for("foo bar {{baz}}"), "CONTENT[ \'foo bar \' ]\n{{ ID:baz [] }}\n");
+ });
+
+ it('parses a partial', function() {
+ equals(ast_for("{{> foo }}"), "{{> PARTIAL:foo }}\n");
+ });
+
+ it('parses a partial with context', function() {
+ equals(ast_for("{{> foo bar}}"), "{{> PARTIAL:foo ID:bar }}\n");
+ });
+
+ it('parses a partial with hash', function() {
+ equals(ast_for("{{> foo bar=bat}}"), "{{> PARTIAL:foo HASH{bar=ID:bat} }}\n");
+ });
+
+ it('parses a partial with context and hash', function() {
+ equals(ast_for("{{> foo bar bat=baz}}"), "{{> PARTIAL:foo ID:bar HASH{bat=ID:baz} }}\n");
+ });
+
+ it('parses a partial with a complex name', function() {
+ equals(ast_for("{{> shared/partial?.bar}}"), "{{> PARTIAL:shared/partial?.bar }}\n");
+ });
+
+ it('parses a comment', function() {
+ equals(ast_for("{{! this is a comment }}"), "{{! ' this is a comment ' }}\n");
+ });
+
+ it('parses a multi-line comment', function() {
+ equals(ast_for("{{!\nthis is a multi-line comment\n}}"), "{{! \'\nthis is a multi-line comment\n\' }}\n");
+ });
+
+ it('parses an inverse section', function() {
+ equals(ast_for("{{#foo}} bar {{^}} baz {{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n CONTENT[ ' bar ' ]\n {{^}}\n CONTENT[ ' baz ' ]\n");
+ });
+
+ it('parses an inverse (else-style) section', function() {
+ equals(ast_for("{{#foo}} bar {{else}} baz {{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n CONTENT[ ' bar ' ]\n {{^}}\n CONTENT[ ' baz ' ]\n");
+ });
+
+ it('parses empty blocks', function() {
+ equals(ast_for("{{#foo}}{{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n");
+ });
+
+ it('parses empty blocks with empty inverse section', function() {
+ equals(ast_for("{{#foo}}{{^}}{{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n");
+ });
+
+ it('parses empty blocks with empty inverse (else-style) section', function() {
+ equals(ast_for("{{#foo}}{{else}}{{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n");
+ });
+
+ it('parses non-empty blocks with empty inverse section', function() {
+ equals(ast_for("{{#foo}} bar {{^}}{{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n CONTENT[ ' bar ' ]\n {{^}}\n");
+ });
+
+ it('parses non-empty blocks with empty inverse (else-style) section', function() {
+ equals(ast_for("{{#foo}} bar {{else}}{{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n CONTENT[ ' bar ' ]\n {{^}}\n");
+ });
+
+ it('parses empty blocks with non-empty inverse section', function() {
+ equals(ast_for("{{#foo}}{{^}} bar {{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n {{^}}\n CONTENT[ ' bar ' ]\n");
+ });
+
+ it('parses empty blocks with non-empty inverse (else-style) section', function() {
+ equals(ast_for("{{#foo}}{{else}} bar {{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n PROGRAM:\n {{^}}\n CONTENT[ ' bar ' ]\n");
+ });
+
+ it('parses a standalone inverse section', function() {
+ equals(ast_for("{{^foo}}bar{{/foo}}"), "BLOCK:\n {{ ID:foo [] }}\n {{^}}\n CONTENT[ 'bar' ]\n");
+ });
+
+ it("raises if there's a Parse error", function() {
+ shouldThrow(function() {
+ ast_for("foo{{^}}bar");
+ }, Error, /Parse error on line 1/);
+ shouldThrow(function() {
+ ast_for("{{foo}");
+ }, Error, /Parse error on line 1/);
+ shouldThrow(function() {
+ ast_for("{{foo &}}");
+ }, Error, /Parse error on line 1/);
+ shouldThrow(function() {
+ ast_for("{{#goodbyes}}{{/hellos}}");
+ }, Error, /goodbyes doesn't match hellos/);
+
+ shouldThrow(function() {
+ ast_for("{{{{goodbyes}}}} {{{{/hellos}}}}");
+ }, Error, /goodbyes doesn't match hellos/);
+ });
+
+ it('knows how to report the correct line number in errors', function() {
+ shouldThrow(function() {
+ ast_for("hello\nmy\n{{foo}");
+ }, Error, /Parse error on line 3/);
+ shouldThrow(function() {
+ ast_for("hello\n\nmy\n\n{{foo}");
+ }, Error, /Parse error on line 5/);
+ });
+
+ it('knows how to report the correct line number in errors when the first character is a newline', function() {
+ shouldThrow(function() {
+ ast_for("\n\nhello\n\nmy\n\n{{foo}");
+ }, Error, /Parse error on line 7/);
+ });
+
+ describe('externally compiled AST', function() {
+ it('can pass through an already-compiled AST', function() {
+ equals(ast_for(new Handlebars.AST.ProgramNode(false, [ new Handlebars.AST.ContentNode("Hello")])), "CONTENT[ \'Hello\' ]\n");
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 | +3 +3 + + + + + + + +3 + + + + + + + +3 + + + + + + +3 + + + + + + + +3 + + + + + + + +3 + + + + + + +3 + + + + + + +3 + + + + + + + + + +3 + + + + + + +3 + + + + + + +3 + + + + + + +3 + + + + + + + + +3 + + + + + + + + + + +3 + + + + + + +3 + + + + + + +3 + + + + + + +3 + + + + + + +3 + + + + + +3 +3 + + + + + + +3 + + + + + + + + + +3 +3 + + + + + +3 + + + + + + + + | /*global CompilerContext, Handlebars, handlebarsEnv, shouldCompileTo, shouldCompileToWithPartials, shouldThrow */
+describe('partials', function() {
+ it("basic partials", function() {
+ var string = "Dudes: {{#dudes}}{{> dude}}{{/dudes}}";
+ var partial = "{{name}} ({{url}}) ";
+ var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: Yehuda (http://yehuda) Alan (http://alan) ",
+ "Basic partials output based on current context.");
+ });
+
+ it("partials with context", function() {
+ var string = "Dudes: {{>dude dudes}}";
+ var partial = "{{#this}}{{name}} ({{url}}) {{/this}}";
+ var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: Yehuda (http://yehuda) Alan (http://alan) ",
+ "Partials can be passed a context");
+ });
+
+ it("partials with undefined context", function() {
+ var string = "Dudes: {{>dude dudes}}";
+ var partial = "{{foo}} Empty";
+ var hash = {};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: Empty");
+ });
+
+ it("partials with parameters", function() {
+ var string = "Dudes: {{#dudes}}{{> dude others=..}}{{/dudes}}";
+ var partial = "{{others.foo}}{{name}} ({{url}}) ";
+ var hash = {foo: 'bar', dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: barYehuda (http://yehuda) barAlan (http://alan) ",
+ "Basic partials output based on current context.");
+ });
+
+ it("partial in a partial", function() {
+ var string = "Dudes: {{#dudes}}{{>dude}}{{/dudes}}";
+ var dude = "{{name}} {{> url}} ";
+ var url = "<a href='{{url}}'>{{url}}</a>";
+ var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: dude, url: url}], true, "Dudes: Yehuda <a href='http://yehuda'>http://yehuda</a> Alan <a href='http://alan'>http://alan</a> ", "Partials are rendered inside of other partials");
+ });
+
+ it("rendering undefined partial throws an exception", function() {
+ shouldThrow(function() {
+ var template = CompilerContext.compile("{{> whatever}}");
+ template();
+ }, Handlebars.Exception, 'The partial whatever could not be found');
+ });
+
+ it("rendering template partial in vm mode throws an exception", function() {
+ shouldThrow(function() {
+ var template = CompilerContext.compile("{{> whatever}}");
+ template();
+ }, Handlebars.Exception, 'The partial whatever could not be found');
+ });
+
+ it("rendering function partial in vm mode", function() {
+ var string = "Dudes: {{#dudes}}{{> dude}}{{/dudes}}";
+ var partial = function(context) {
+ return context.name + ' (' + context.url + ') ';
+ };
+ var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileTo(string, [hash, {}, {dude: partial}], "Dudes: Yehuda (http://yehuda) Alan (http://alan) ",
+ "Function partials output based in VM.");
+ });
+
+ it("GH-14: a partial preceding a selector", function() {
+ var string = "Dudes: {{>dude}} {{another_dude}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {dude:dude}], true, "Dudes: Jeepers Creepers", "Regular selectors can follow a partial");
+ });
+
+ it("Partials with slash paths", function() {
+ var string = "Dudes: {{> shared/dude}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {'shared/dude':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+ });
+
+ it("Partials with slash and point paths", function() {
+ var string = "Dudes: {{> shared/dude.thing}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {'shared/dude.thing':dude}], true, "Dudes: Jeepers", "Partials can use literal with points in paths");
+ });
+
+ it("Global Partials", function() {
+ handlebarsEnv.registerPartial('global_test', '{{another_dude}}');
+
+ var string = "Dudes: {{> shared/dude}} {{> global_test}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {'shared/dude':dude}], true, "Dudes: Jeepers Creepers", "Partials can use globals or passed");
+ });
+
+ it("Multiple partial registration", function() {
+ handlebarsEnv.registerPartial({
+ 'shared/dude': '{{name}}',
+ global_test: '{{another_dude}}'
+ });
+
+ var string = "Dudes: {{> shared/dude}} {{> global_test}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash], true, "Dudes: Jeepers Creepers", "Partials can use globals or passed");
+ });
+
+ it("Partials with integer path", function() {
+ var string = "Dudes: {{> 404}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {404:dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+ });
+
+ it("Partials with complex path", function() {
+ var string = "Dudes: {{> 404/asdf?.bar}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {'404/asdf?.bar':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+ });
+
+ it("Partials with escaped", function() {
+ var string = "Dudes: {{> [+404/asdf?.bar]}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {'+404/asdf?.bar':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+ });
+
+ it("Partials with string", function() {
+ var string = "Dudes: {{> \"+404/asdf?.bar\"}}";
+ var dude = "{{name}}";
+ var hash = {name:"Jeepers", another_dude:"Creepers"};
+ shouldCompileToWithPartials(string, [hash, {}, {'+404/asdf?.bar':dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
+ });
+
+ it('should handle empty partial', function() {
+ var string = "Dudes: {{#dudes}}{{> dude}}{{/dudes}}";
+ var partial = "";
+ var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: "); });
+
+ describe('standalone partials', function() {
+ it("indented partials", function() {
+ var string = "Dudes:\n{{#dudes}}\n {{>dude}}\n{{/dudes}}";
+ var dude = "{{name}}\n";
+ var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: dude}], true,
+ "Dudes:\n Yehuda\n Alan\n");
+ });
+ it("nested indented partials", function() {
+ var string = "Dudes:\n{{#dudes}}\n {{>dude}}\n{{/dudes}}";
+ var dude = "{{name}}\n {{> url}}";
+ var url = "{{url}}!\n";
+ var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: dude, url: url}], true,
+ "Dudes:\n Yehuda\n http://yehuda!\n Alan\n http://alan!\n");
+ });
+ });
+
+ describe('compat mode', function() {
+ it('basic partials', function() {
+ var string = 'Dudes: {{#dudes}}{{> dude}}{{/dudes}}';
+ var partial = '{{name}} ({{url}}) {{root}} ';
+ var hash = {root: 'yes', dudes: [{name: 'Yehuda', url: 'http://yehuda'}, {name: 'Alan', url: 'http://alan'}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: partial}, true], true, 'Dudes: Yehuda (http://yehuda) yes Alan (http://alan) yes ');
+ });
+ it('partials inherit compat', function() {
+ var string = 'Dudes: {{> dude}}';
+ var partial = '{{#dudes}}{{name}} ({{url}}) {{root}} {{/dudes}}';
+ var hash = {root: 'yes', dudes: [{name: 'Yehuda', url: 'http://yehuda'}, {name: 'Alan', url: 'http://alan'}]};
+ shouldCompileToWithPartials(string, [hash, {}, {dude: partial}, true], true, 'Dudes: Yehuda (http://yehuda) yes Alan (http://alan) yes ');
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 | + +3 + +3 + + + +3 + + +3 + + +3 + + + + + + +3 + + + +3 + + + +3 + + + + +3 + + + + + + | /*global shouldThrow */
+
+describe('precompiler', function() {
+ // NOP Under non-node environments
+ Iif (typeof process === 'undefined') {
+ return;
+ }
+
+ var Handlebars = require('../lib'),
+ Precompiler = require('../lib/precompiler');
+
+ var log,
+ logFunction;
+
+ beforeEach(function() {
+ logFunction = console.log;
+ log = '';
+ console.log = function() {
+ log += Array.prototype.join.call(arguments, '');
+ };
+ });
+ afterEach(function() {
+ console.log = logFunction;
+ });
+
+ it('should output version', function() {
+ Precompiler.cli({templates: [], version: true});
+ equals(log, Handlebars.VERSION);
+ });
+ it('should throw if lacking templates', function() {
+ shouldThrow(function() {
+ Precompiler.cli({templates: []});
+ }, Handlebars.Exception, 'Must define at least one template or directory.');
+ });
+ it('should throw on missing template', function() {
+ shouldThrow(function() {
+ Precompiler.cli({templates: ['foo']});
+ }, Handlebars.Exception, 'Unable to open template file "foo"');
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 | +3 +3 + + + + + + +3 + + + + + + + + +3 + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + +3 + + + + + + + + + + + + +3 + + + +3 + + + +3 + + + + + + + +3 + + + + + + + + +3 + + + + + + +3 + + + + + + + + + + + +3 + + + + + +3 + + + +3 + + + +3 +2 + + + +2 + + + + + | /*global CompilerContext, Handlebars, shouldCompileTo, shouldThrow */
+describe('Regressions', function() {
+ it("GH-94: Cannot read property of undefined", function() {
+ var data = {"books":[{"title":"The origin of species","author":{"name":"Charles Darwin"}},{"title":"Lazarillo de Tormes"}]};
+ var string = "{{#books}}{{title}}{{author.name}}{{/books}}";
+ shouldCompileTo(string, data, "The origin of speciesCharles DarwinLazarillo de Tormes",
+ "Renders without an undefined property error");
+ });
+
+ it("GH-150: Inverted sections print when they shouldn't", function() {
+ var string = "{{^set}}not set{{/set}} :: {{#set}}set{{/set}}";
+
+ shouldCompileTo(string, {}, "not set :: ", "inverted sections run when property isn't present in context");
+ shouldCompileTo(string, {set: undefined}, "not set :: ", "inverted sections run when property is undefined");
+ shouldCompileTo(string, {set: false}, "not set :: ", "inverted sections run when property is false");
+ shouldCompileTo(string, {set: true}, " :: set", "inverted sections don't run when property is true");
+ });
+
+ it("GH-158: Using array index twice, breaks the template", function() {
+ var string = "{{arr.[0]}}, {{arr.[1]}}";
+ var data = { "arr": [1,2] };
+
+ shouldCompileTo(string, data, "1, 2", "it works as expected");
+ });
+
+ it("bug reported by @fat where lambdas weren't being properly resolved", function() {
+ var string = '<strong>This is a slightly more complicated {{thing}}.</strong>.\n'
+ + '{{! Just ignore this business. }}\n'
+ + 'Check this out:\n'
+ + '{{#hasThings}}\n'
+ + '<ul>\n'
+ + '{{#things}}\n'
+ + '<li class={{className}}>{{word}}</li>\n'
+ + '{{/things}}</ul>.\n'
+ + '{{/hasThings}}\n'
+ + '{{^hasThings}}\n'
+ + '\n'
+ + '<small>Nothing to check out...</small>\n'
+ + '{{/hasThings}}';
+ var data = {
+ thing: function() {
+ return "blah";
+ },
+ things: [
+ {className: "one", word: "@fat"},
+ {className: "two", word: "@dhg"},
+ {className: "three", word:"@sayrer"}
+ ],
+ hasThings: function() {
+ return true;
+ }
+ };
+
+ var output = '<strong>This is a slightly more complicated blah.</strong>.\n'
+ + 'Check this out:\n'
+ + '<ul>\n'
+ + '<li class=one>@fat</li>\n'
+ + '<li class=two>@dhg</li>\n'
+ + '<li class=three>@sayrer</li>\n'
+ + '</ul>.\n';
+ shouldCompileTo(string, data, output);
+ });
+
+ it('GH-408: Multiple loops fail', function() {
+ var context = [
+ { name: "John Doe", location: { city: "Chicago" } },
+ { name: "Jane Doe", location: { city: "New York"} }
+ ];
+
+ var template = CompilerContext.compile('{{#.}}{{name}}{{/.}}{{#.}}{{name}}{{/.}}{{#.}}{{name}}{{/.}}');
+
+ var result = template(context);
+ equals(result, "John DoeJane DoeJohn DoeJane DoeJohn DoeJane Doe", 'It should output multiple times');
+ });
+
+ it('GS-428: Nested if else rendering', function() {
+ var succeedingTemplate = '{{#inverse}} {{#blk}} Unexpected {{/blk}} {{else}} {{#blk}} Expected {{/blk}} {{/inverse}}';
+ var failingTemplate = '{{#inverse}} {{#blk}} Unexpected {{/blk}} {{else}} {{#blk}} Expected {{/blk}} {{/inverse}}';
+
+ var helpers = {
+ blk: function(block) { return block.fn(''); },
+ inverse: function(block) { return block.inverse(''); }
+ };
+
+ shouldCompileTo(succeedingTemplate, [{}, helpers], ' Expected ');
+ shouldCompileTo(failingTemplate, [{}, helpers], ' Expected ');
+ });
+
+ it('GH-458: Scoped this identifier', function() {
+ shouldCompileTo('{{./foo}}', {foo: 'bar'}, 'bar');
+ });
+
+ it('GH-375: Unicode line terminators', function() {
+ shouldCompileTo('\u2028', {}, '\u2028');
+ });
+
+ it('GH-534: Object prototype aliases', function() {
+ Object.prototype[0xD834] = true;
+
+ shouldCompileTo('{{foo}}', { foo: 'bar' }, 'bar');
+
+ delete Object.prototype[0xD834];
+ });
+
+ it('GH-437: Matching escaping', function() {
+ shouldThrow(function() {
+ CompilerContext.compile('{{{a}}');
+ }, Error);
+ shouldThrow(function() {
+ CompilerContext.compile('{{a}}}');
+ }, Error);
+ });
+
+ it("GH-676: Using array in escaping mustache fails", function() {
+ var string = "{{arr}}";
+ var data = { "arr": [1,2] };
+
+ shouldCompileTo(string, data, data.arr.toString(), "it works as expected");
+ });
+
+ it("Mustache man page", function() {
+ var string = "Hello {{name}}. You have just won ${{value}}!{{#in_ca}} Well, ${{taxed_value}}, after taxes.{{/in_ca}}";
+ var data = {
+ "name": "Chris",
+ "value": 10000,
+ "taxed_value": 10000 - (10000 * 0.4),
+ "in_ca": true
+ };
+
+ shouldCompileTo(string, data, "Hello Chris. You have just won $10000! Well, $6000, after taxes.", "the hello world mustache example works");
+ });
+
+ it("Passing falsy values to Handlebars.compile throws an error", function() {
+ shouldThrow(function() {
+ CompilerContext.compile(null);
+ }, Error, 'You must pass a string or Handlebars AST to Handlebars.precompile. You passed null');
+ });
+
+ it('GH-731: zero context rendering', function() {
+ shouldCompileTo('{{#foo}} This is {{bar}} ~ {{/foo}}', {foo: 0, bar: 'OK'}, ' This is ~ ');
+ });
+
+ it('GH-820: zero pathed rendering', function() {
+ shouldCompileTo('{{foo.bar}}', {foo: 0}, '');
+ });
+
+ if (Handlebars.AST) {
+ it("can pass through an already-compiled AST via compile/precompile", function() {
+ equal(Handlebars.compile(new Handlebars.AST.ProgramNode(true, [ new Handlebars.AST.ContentNode("Hello")]))(), 'Hello');
+ });
+
+ it("can pass through an empty string", function() {
+ equal(Handlebars.compile('')(), '');
+ });
+ }
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 | 3 +3 +3 + + + + + + + + + +3 + + + + + + + + + + + | Eif (typeof(require) !== 'undefined' && require.extensions[".handlebars"]) { + describe('Require', function() { + it('Load .handlebars files with require()', function() { + var template = require("./artifacts/example_1"); + equal(template, require("./artifacts/example_1.handlebars")); + + var expected = 'foo\n'; + var result = template({foo: "foo"}); + + equal(result, expected); + }); + + it('Load .hbs files with require()', function() { + var template = require("./artifacts/example_2"); + equal(template, require("./artifacts/example_2.hbs")); + + var expected = 'Hello, World!\n'; + var result = template({name: "World"}); + + equal(result, expected); + }); + }); +} + |
| 1 +2 +3 +4 +5 +6 | 3 +3 +3 + + + | describe('runtime', function() {
+ describe('#template', function() {
+ it('should throw on invalid data');
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 | 3 + +3 + + + +3 + + + +3 +3 +42 + + +3 +21 +21 + + +366 + + + + + + + + +30 +78 +78 + + +288 +288 + + + +288 + + + + + + + + + + | describe('spec', function() {
+ // NOP Under non-node environments
+ Iif (typeof process === 'undefined') {
+ return;
+ }
+
+ var _ = require('underscore'),
+ Handlebars = require('../lib'),
+ fs = require('fs');
+
+ var specDir =__dirname + '/mustache/specs/';
+ var specs = _.filter(fs.readdirSync(specDir), function(name) {
+ return /.*\.json$/.test(name);
+ });
+
+ _.each(specs, function(name) {
+ var spec = require(specDir + name);
+ _.each(spec.tests, function(test) {
+ // Our lambda implementation knowingly deviates from the optional Mustace lambda spec
+ // We also do not support alternative delimeters
+ if (name === '~lambdas.json'
+
+ // We also choose to throw if paritals are not found
+ || (name === 'partials.json' && test.name === 'Failed Lookup')
+
+ // We nest the entire response from partials, not just the literals
+ || (name === 'partials.json' && test.name === 'Standalone Indentation')
+
+ || /\{\{\=/.test(test.template)
+ || _.any(test.partials, function(partial) { return /\{\{\=/.test(partial); })) {
+ it.skip(name + ' - ' + test.name);
+ return;
+ }
+
+ var data = _.clone(test.data);
+ Iif (data.lambda) {
+ // Blergh
+ data.lambda = eval('(' + data.lambda.js + ')');
+ }
+ it(name + ' - ' + test.name, function() {
+ if (test.partials) {
+ shouldCompileToWithPartials(test.template, [data, {}, test.partials, true], true, test.expected, test.desc + ' "' + test.template + '"');
+ } else {
+ shouldCompileTo(test.template, [data, {}, {}, true], test.expected, test.desc + ' "' + test.template + '"');
+ }
+ });
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 | 3 +3 + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + | describe('string params mode', function() {
+ it("arguments to helpers can be retrieved from options hash in string form", function() {
+ var template = CompilerContext.compile('{{wycats is.a slave.driver}}', {stringParams: true});
+
+ var helpers = {
+ wycats: function(passiveVoice, noun) {
+ return "HELP ME MY BOSS " + passiveVoice + ' ' + noun;
+ }
+ };
+
+ var result = template({}, {helpers: helpers});
+
+ equals(result, "HELP ME MY BOSS is.a slave.driver", "String parameters output");
+ });
+
+ it("when using block form, arguments to helpers can be retrieved from options hash in string form", function() {
+ var template = CompilerContext.compile('{{#wycats is.a slave.driver}}help :({{/wycats}}', {stringParams: true});
+
+ var helpers = {
+ wycats: function(passiveVoice, noun, options) {
+ return "HELP ME MY BOSS " + passiveVoice + ' ' +
+ noun + ': ' + options.fn(this);
+ }
+ };
+
+ var result = template({}, {helpers: helpers});
+
+ equals(result, "HELP ME MY BOSS is.a slave.driver: help :(", "String parameters output");
+ });
+
+ it("when inside a block in String mode, .. passes the appropriate context in the options hash", function() {
+ var template = CompilerContext.compile('{{#with dale}}{{tomdale ../need dad.joke}}{{/with}}', {stringParams: true});
+
+ var helpers = {
+ tomdale: function(desire, noun, options) {
+ return "STOP ME FROM READING HACKER NEWS I " +
+ options.contexts[0][desire] + " " + noun;
+ },
+
+ "with": function(context, options) {
+ return options.fn(options.contexts[0][context]);
+ }
+ };
+
+ var result = template({
+ dale: {},
+
+ need: 'need-a'
+ }, {helpers: helpers});
+
+ equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke", "Proper context variable output");
+ });
+
+ it("information about the types is passed along", function() {
+ var template = CompilerContext.compile('{{tomdale "need" dad.joke true false}}', { stringParams: true });
+
+ var helpers = {
+ tomdale: function(desire, noun, trueBool, falseBool, options) {
+ equal(options.types[0], 'STRING', "the string type is passed");
+ equal(options.types[1], 'ID', "the expression type is passed");
+ equal(options.types[2], 'BOOLEAN', "the expression type is passed");
+ equal(desire, "need", "the string form is passed for strings");
+ equal(noun, "dad.joke", "the string form is passed for expressions");
+ equal(trueBool, true, "raw booleans are passed through");
+ equal(falseBool, false, "raw booleans are passed through");
+ return "Helper called";
+ }
+ };
+
+ var result = template({}, { helpers: helpers });
+ equal(result, "Helper called");
+ });
+
+ it("hash parameters get type information", function() {
+ var template = CompilerContext.compile('{{tomdale he.says desire="need" noun=dad.joke bool=true}}', { stringParams: true });
+
+ var helpers = {
+ tomdale: function(exclamation, options) {
+ equal(exclamation, "he.says");
+ equal(options.types[0], "ID");
+
+ equal(options.hashTypes.desire, "STRING");
+ equal(options.hashTypes.noun, "ID");
+ equal(options.hashTypes.bool, "BOOLEAN");
+ equal(options.hash.desire, "need");
+ equal(options.hash.noun, "dad.joke");
+ equal(options.hash.bool, true);
+ return "Helper called";
+ }
+ };
+
+ var result = template({}, { helpers: helpers });
+ equal(result, "Helper called");
+ });
+
+ it("hash parameters get context information", function() {
+ var template = CompilerContext.compile('{{#with dale}}{{tomdale he.says desire="need" noun=../dad/joke bool=true}}{{/with}}', { stringParams: true });
+
+ var context = {dale: {}};
+
+ var helpers = {
+ tomdale: function(exclamation, options) {
+ equal(exclamation, "he.says");
+ equal(options.types[0], "ID");
+
+ equal(options.contexts.length, 1);
+ equal(options.hashContexts.noun, context);
+ equal(options.hash.desire, "need");
+ equal(options.hash.noun, "dad.joke");
+ equal(options.hash.bool, true);
+ return "Helper called";
+ },
+ "with": function(context, options) {
+ return options.fn(options.contexts[0][context]);
+ }
+ };
+
+ var result = template(context, { helpers: helpers });
+ equal(result, "Helper called");
+ });
+
+ it("when inside a block in String mode, .. passes the appropriate context in the options hash to a block helper", function() {
+ var template = CompilerContext.compile('{{#with dale}}{{#tomdale ../need dad.joke}}wot{{/tomdale}}{{/with}}', {stringParams: true});
+
+ var helpers = {
+ tomdale: function(desire, noun, options) {
+ return "STOP ME FROM READING HACKER NEWS I " +
+ options.contexts[0][desire] + " " + noun + " " +
+ options.fn(this);
+ },
+
+ "with": function(context, options) {
+ return options.fn(options.contexts[0][context]);
+ }
+ };
+
+ var result = template({
+ dale: {},
+
+ need: 'need-a'
+ }, {helpers: helpers});
+
+ equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke wot", "Proper context variable output");
+ });
+
+ it("with nested block ambiguous", function() {
+ var template = CompilerContext.compile('{{#with content}}{{#view}}{{firstName}} {{lastName}}{{/view}}{{/with}}', {stringParams: true});
+
+ var helpers = {
+ 'with': function(options) {
+ return "WITH";
+ },
+ view: function() {
+ return "VIEW";
+ }
+ };
+
+ var result = template({}, {helpers: helpers});
+ equals(result, "WITH");
+ });
+
+ it('should handle DATA', function() {
+ var template = CompilerContext.compile('{{foo @bar}}', { stringParams: true });
+
+ var helpers = {
+ foo: function(bar, options) {
+ equal(bar, 'bar');
+ equal(options.types[0], 'DATA');
+ return 'Foo!';
+ }
+ };
+
+ var result = template({}, { helpers: helpers });
+ equal(result, 'Foo!');
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 | +3 +3 + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + + | /*global CompilerContext, shouldCompileTo */
+describe('subexpressions', function() {
+ it("arg-less helper", function() {
+ var string = "{{foo (bar)}}!";
+ var context = {};
+ var helpers = {
+ foo: function(val) {
+ return val+val;
+ },
+ bar: function() {
+ return "LOL";
+ }
+ };
+ shouldCompileTo(string, [context, helpers], "LOLLOL!");
+ });
+
+ it("helper w args", function() {
+ var string = '{{blog (equal a b)}}';
+
+ var context = { bar: "LOL" };
+ var helpers = {
+ blog: function(val) {
+ return "val is " + val;
+ },
+ equal: function(x, y) {
+ return x === y;
+ }
+ };
+ shouldCompileTo(string, [context, helpers], "val is true");
+ });
+
+ it("mixed paths and helpers", function() {
+ var string = '{{blog baz.bat (equal a b) baz.bar}}';
+
+ var context = { bar: "LOL", baz: {bat: 'foo!', bar: 'bar!'} };
+ var helpers = {
+ blog: function(val, that, theOther) {
+ return "val is " + val + ', ' + that + ' and ' + theOther;
+ },
+ equal: function(x, y) {
+ return x === y;
+ }
+ };
+ shouldCompileTo(string, [context, helpers], "val is foo!, true and bar!");
+ });
+
+ it("supports much nesting", function() {
+ var string = '{{blog (equal (equal true true) true)}}';
+
+ var context = { bar: "LOL" };
+ var helpers = {
+ blog: function(val) {
+ return "val is " + val;
+ },
+ equal: function(x, y) {
+ return x === y;
+ }
+ };
+ shouldCompileTo(string, [context, helpers], "val is true");
+ });
+
+ it('GH-800 : Complex subexpressions', function() {
+ var context = {a: 'a', b:'b', c:{c:'c'}, d:'d', e: {e: 'e'}};
+ var helpers = {
+ dash: function(a, b) {
+ return a + "-" + b;
+ },
+ concat: function(a, b) {
+ return a + b;
+ }
+ };
+
+ shouldCompileTo('{{dash "abc" (concat a b)}}', [context, helpers], 'abc-ab');
+ shouldCompileTo('{{dash d (concat a b)}}', [context, helpers], 'd-ab');
+ shouldCompileTo('{{dash c.c (concat a b)}}', [context, helpers], 'c-ab');
+ shouldCompileTo('{{dash (concat a b) c.c}}', [context, helpers], 'ab-c');
+ shouldCompileTo('{{dash (concat a e.e) c.c}}', [context, helpers], 'ae-c');
+ });
+
+ it("provides each nested helper invocation its own options hash", function() {
+ var string = '{{equal (equal true true) true}}';
+
+ var lastOptions = null;
+ var helpers = {
+ equal: function(x, y, options) {
+ if (!options || options === lastOptions) {
+ throw new Error("options hash was reused");
+ }
+ lastOptions = options;
+ return x === y;
+ }
+ };
+ shouldCompileTo(string, [{}, helpers], "true");
+ });
+
+ it("with hashes", function() {
+ var string = '{{blog (equal (equal true true) true fun="yes")}}';
+
+ var context = { bar: "LOL" };
+ var helpers = {
+ blog: function(val) {
+ return "val is " + val;
+ },
+ equal: function(x, y) {
+ return x === y;
+ }
+ };
+ shouldCompileTo(string, [context, helpers], "val is true");
+ });
+
+ it("as hashes", function() {
+ var string = '{{blog fun=(equal (blog fun=1) "val is 1")}}';
+
+ var helpers = {
+ blog: function(options) {
+ return "val is " + options.hash.fun;
+ },
+ equal: function(x, y) {
+ return x === y;
+ }
+ };
+ shouldCompileTo(string, [{}, helpers], "val is true");
+ });
+
+ it("multiple subexpressions in a hash", function() {
+ var string = '{{input aria-label=(t "Name") placeholder=(t "Example User")}}';
+
+ var helpers = {
+ input: function(options) {
+ var hash = options.hash;
+ var ariaLabel = Handlebars.Utils.escapeExpression(hash['aria-label']);
+ var placeholder = Handlebars.Utils.escapeExpression(hash.placeholder);
+ return new Handlebars.SafeString('<input aria-label="' + ariaLabel + '" placeholder="' + placeholder + '" />');
+ },
+ t: function(defaultString) {
+ return new Handlebars.SafeString(defaultString);
+ }
+ }
+ shouldCompileTo(string, [{}, helpers], '<input aria-label="Name" placeholder="Example User" />');
+ });
+
+ it("in string params mode,", function() {
+ var template = CompilerContext.compile('{{snog (blorg foo x=y) yeah a=b}}', {stringParams: true});
+
+ var helpers = {
+ snog: function(a, b, options) {
+ equals(a, 'foo');
+ equals(options.types.length, 2, "string params for outer helper processed correctly");
+ equals(options.types[0], 'sexpr', "string params for outer helper processed correctly");
+ equals(options.types[1], 'ID', "string params for outer helper processed correctly");
+ return a + b;
+ },
+
+ blorg: function(a, options) {
+ equals(options.types.length, 1, "string params for inner helper processed correctly");
+ equals(options.types[0], 'ID', "string params for inner helper processed correctly");
+ return a;
+ }
+ };
+
+ var result = template({
+ foo: {},
+ yeah: {}
+ }, {helpers: helpers});
+
+ equals(result, "fooyeah");
+ });
+
+ it("as hashes in string params mode", function() {
+
+ var template = CompilerContext.compile('{{blog fun=(bork)}}', {stringParams: true});
+
+ var helpers = {
+ blog: function(options) {
+ equals(options.hashTypes.fun, 'sexpr');
+ return "val is " + options.hash.fun;
+ },
+ bork: function() {
+ return "BORK";
+ }
+ };
+
+ var result = template({}, {helpers: helpers});
+ equals(result, "val is BORK");
+ });
+
+ it("subexpression functions on the context", function() {
+ var string = "{{foo (bar)}}!";
+ var context = {
+ bar: function() {
+ return "LOL";
+ }
+ };
+ var helpers = {
+ foo: function(val) {
+ return val+val;
+ }
+ };
+ shouldCompileTo(string, [context, helpers], "LOLLOL!");
+ });
+
+ it("subexpressions can't just be property lookups", function() {
+ var string = "{{foo (bar)}}!";
+ var context = {
+ bar: "LOL"
+ };
+ var helpers = {
+ foo: function(val) {
+ return val+val;
+ }
+ };
+ shouldThrow(function() {
+ shouldCompileTo(string, [context, helpers], "LOLLOL!");
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 +165 +166 +167 +168 +169 +170 +171 +172 +173 +174 +175 +176 +177 +178 +179 +180 +181 +182 +183 +184 +185 +186 +187 +188 +189 +190 +191 +192 +193 +194 +195 +196 +197 +198 +199 +200 +201 +202 +203 +204 +205 +206 +207 +208 +209 +210 +211 +212 +213 +214 +215 +216 +217 +218 +219 +220 +221 +222 +223 +224 +225 +226 +227 +228 +229 +230 +231 +232 +233 +234 +235 +236 +237 +238 +239 +240 +241 +242 +243 +244 +245 +246 +247 +248 +249 +250 +251 +252 +253 +254 +255 +256 +257 +258 +259 +260 +261 +262 +263 +264 +265 +266 +267 +268 +269 +270 +271 +272 +273 +274 +275 +276 +277 +278 +279 +280 +281 +282 +283 +284 +285 +286 +287 +288 +289 +290 +291 +292 +293 +294 +295 +296 +297 +298 +299 +300 +301 +302 +303 +304 +305 +306 +307 +308 +309 +310 +311 +312 +313 +314 +315 +316 +317 +318 +319 +320 +321 +322 +323 +324 +325 +326 +327 +328 +329 +330 +331 +332 +333 +334 +335 +336 +337 +338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 +351 +352 +353 +354 +355 +356 +357 +358 +359 +360 +361 +362 +363 +364 +365 +366 +367 +368 +369 +370 +371 +372 +373 +374 +375 +376 +377 +378 +379 +380 +381 +382 +383 +384 +385 +386 +387 +388 +389 +390 +391 +392 +393 +394 +395 +396 +397 +398 +399 +400 +401 +402 +403 | 1 + + + + +1 + + + + +3 +3 +1 + + +1 + + + + + + + + + + + + + + + + + + +2 + + + + + +2 + + + + + + + +2 + + + + + + +2 + + + + + + + +2 + + + + + + + + +2 + + + + + + +2 + + + + + + + +2 + + + + + + + + + +2 + + + + + + + + + + +2 + + + + + + + + + +2 + + + + + + + +2 + + + + +2 + + + + + + +2 + + + + +2 + + + + +2 + + + + +2 + + + + + +2 + + + + + +2 + + + + + + +2 + + + + + +2 + + + + + +2 + + + + + + +2 + + + + +2 + + + + +2 + + + + +2 + + + + +2 + + + + +2 + + + + + +2 + + + + + +2 + + + + + +2 + + + + +2 + + + + + +2 + + + + + +2 + + + + + +2 + + + + + + + +2 + + + + + +2 + + + + + +2 + + + + + +2 + + + + + +2 + + + + + +2 + + + + + + + + + + + + + + + + + +2 + + + + + + + + + +2 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +2 + + + + + + + + + + + + + +2 + + + +2 + + + +2 + + + + + + + + + + + + +2 + + + + + + + + +2 + + + + + | function shouldMatchTokens(result, tokens) { + for (var index = 0; index < result.length; index++) { + equals(result[index].name, tokens[index]); + } +} +function shouldBeToken(result, name, text) { + equals(result.name, name); + equals(result.text, text); +} + +describe('Tokenizer', function() { + if (!Handlebars.Parser) { + return; + } + + function tokenize(template) { + var parser = Handlebars.Parser, + lexer = parser.lexer; + + lexer.setInput(template); + var out = [], + token; + + while (token = lexer.lex()) { + var result = parser.terminals_[token] || token; + if (!result || result === 'EOF' || result === 'INVALID') { + break; + } + out.push({name: result, text: lexer.yytext}); + } + + return out; + } + + it('tokenizes a simple mustache as "OPEN ID CLOSE"', function() { + var result = tokenize("{{foo}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + }); + + it('supports unescaping with &', function() { + var result = tokenize("{{&bar}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']); + + shouldBeToken(result[0], "OPEN", "{{&"); + shouldBeToken(result[1], "ID", "bar"); + }); + + it('supports unescaping with {{{', function() { + var result = tokenize("{{{bar}}}"); + shouldMatchTokens(result, ['OPEN_UNESCAPED', 'ID', 'CLOSE_UNESCAPED']); + + shouldBeToken(result[1], "ID", "bar"); + }); + + it('supports escaping delimiters', function() { + var result = tokenize("{{foo}} \\{{bar}} {{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + + shouldBeToken(result[3], "CONTENT", " "); + shouldBeToken(result[4], "CONTENT", "{{bar}} "); + }); + + it('supports escaping multiple delimiters', function() { + var result = tokenize("{{foo}} \\{{bar}} \\{{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT']); + + shouldBeToken(result[3], "CONTENT", " "); + shouldBeToken(result[4], "CONTENT", "{{bar}} "); + shouldBeToken(result[5], "CONTENT", "{{baz}}"); + }); + + it('supports escaping a triple stash', function() { + var result = tokenize("{{foo}} \\{{{bar}}} {{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + + shouldBeToken(result[4], "CONTENT", "{{{bar}}} "); + }); + + it('supports escaping escape character', function() { + var result = tokenize("{{foo}} \\\\{{bar}} {{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + + shouldBeToken(result[3], "CONTENT", " \\"); + shouldBeToken(result[5], "ID", "bar"); + }); + + it('supports escaping multiple escape characters', function() { + var result = tokenize("{{foo}} \\\\{{bar}} \\\\{{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + + shouldBeToken(result[3], "CONTENT", " \\"); + shouldBeToken(result[5], "ID", "bar"); + shouldBeToken(result[7], "CONTENT", " \\"); + shouldBeToken(result[9], "ID", "baz"); + }); + + it('supports escaped mustaches after escaped escape characters', function() { + var result = tokenize("{{foo}} \\\\{{bar}} \\{{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT']); + + shouldBeToken(result[3], "CONTENT", " \\"); + shouldBeToken(result[4], "OPEN", "{{"); + shouldBeToken(result[5], "ID", "bar"); + shouldBeToken(result[7], "CONTENT", " "); + shouldBeToken(result[8], "CONTENT", "{{baz}}"); + }); + + it('supports escaped escape characters after escaped mustaches', function() { + var result = tokenize("{{foo}} \\{{bar}} \\\\{{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'CONTENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + + shouldBeToken(result[4], "CONTENT", "{{bar}} "); + shouldBeToken(result[5], "CONTENT", "\\"); + shouldBeToken(result[6], "OPEN", "{{"); + shouldBeToken(result[7], "ID", "baz"); + }); + + it('supports escaped escape character on a triple stash', function() { + var result = tokenize("{{foo}} \\\\{{{bar}}} {{baz}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE', 'CONTENT', 'OPEN_UNESCAPED', 'ID', 'CLOSE_UNESCAPED', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + + shouldBeToken(result[3], "CONTENT", " \\"); + shouldBeToken(result[5], "ID", "bar"); + }); + + it('tokenizes a simple path', function() { + var result = tokenize("{{foo/bar}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']); + }); + + it('allows dot notation', function() { + var result = tokenize("{{foo.bar}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']); + + shouldMatchTokens(tokenize("{{foo.bar.baz}}"), ['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']); + }); + + it('allows path literals with []', function() { + var result = tokenize("{{foo.[bar]}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']); + }); + + it('allows multiple path literals on a line with []', function() { + var result = tokenize("{{foo.[bar]}}{{foo.[baz]}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE', 'OPEN', 'ID', 'SEP', 'ID', 'CLOSE']); + }); + + it('tokenizes {{.}} as OPEN ID CLOSE', function() { + var result = tokenize("{{.}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']); + }); + + it('tokenizes a path as "OPEN (ID SEP)* ID CLOSE"', function() { + var result = tokenize("{{../foo/bar}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", ".."); + }); + + it('tokenizes a path with .. as a parent path', function() { + var result = tokenize("{{../foo.bar}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", ".."); + }); + + it('tokenizes a path with this/foo as OPEN ID SEP ID CLOSE', function() { + var result = tokenize("{{this/foo}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'SEP', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", "this"); + shouldBeToken(result[3], "ID", "foo"); + }); + + it('tokenizes a simple mustache with spaces as "OPEN ID CLOSE"', function() { + var result = tokenize("{{ foo }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + }); + + it('tokenizes a simple mustache with line breaks as "OPEN ID ID CLOSE"', function() { + var result = tokenize("{{ foo \n bar }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + }); + + it('tokenizes raw content as "CONTENT"', function() { + var result = tokenize("foo {{ bar }} baz"); + shouldMatchTokens(result, ['CONTENT', 'OPEN', 'ID', 'CLOSE', 'CONTENT']); + shouldBeToken(result[0], "CONTENT", "foo "); + shouldBeToken(result[4], "CONTENT", " baz"); + }); + + it('tokenizes a partial as "OPEN_PARTIAL ID CLOSE"', function() { + var result = tokenize("{{> foo}}"); + shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'CLOSE']); + }); + + it('tokenizes a partial with context as "OPEN_PARTIAL ID ID CLOSE"', function() { + var result = tokenize("{{> foo bar }}"); + shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'ID', 'CLOSE']); + }); + + it('tokenizes a partial without spaces as "OPEN_PARTIAL ID CLOSE"', function() { + var result = tokenize("{{>foo}}"); + shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'CLOSE']); + }); + + it('tokenizes a partial space at the }); as "OPEN_PARTIAL ID CLOSE"', function() { + var result = tokenize("{{>foo }}"); + shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'CLOSE']); + }); + + it('tokenizes a partial space at the }); as "OPEN_PARTIAL ID CLOSE"', function() { + var result = tokenize("{{>foo/bar.baz }}"); + shouldMatchTokens(result, ['OPEN_PARTIAL', 'ID', 'SEP', 'ID', 'SEP', 'ID', 'CLOSE']); + }); + + it('tokenizes a comment as "COMMENT"', function() { + var result = tokenize("foo {{! this is a comment }} bar {{ baz }}"); + shouldMatchTokens(result, ['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + shouldBeToken(result[1], "COMMENT", " this is a comment "); + }); + + it('tokenizes a block comment as "COMMENT"', function() { + var result = tokenize("foo {{!-- this is a {{comment}} --}} bar {{ baz }}"); + shouldMatchTokens(result, ['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + shouldBeToken(result[1], "COMMENT", " this is a {{comment}} "); + }); + + it('tokenizes a block comment with whitespace as "COMMENT"', function() { + var result = tokenize("foo {{!-- this is a\n{{comment}}\n--}} bar {{ baz }}"); + shouldMatchTokens(result, ['CONTENT', 'COMMENT', 'CONTENT', 'OPEN', 'ID', 'CLOSE']); + shouldBeToken(result[1], "COMMENT", " this is a\n{{comment}}\n"); + }); + + it('tokenizes open and closing blocks as OPEN_BLOCK, ID, CLOSE ..., OPEN_ENDBLOCK ID CLOSE', function() { + var result = tokenize("{{#foo}}content{{/foo}}"); + shouldMatchTokens(result, ['OPEN_BLOCK', 'ID', 'CLOSE', 'CONTENT', 'OPEN_ENDBLOCK', 'ID', 'CLOSE']); + }); + + it('tokenizes inverse sections as "OPEN_INVERSE CLOSE"', function() { + shouldMatchTokens(tokenize("{{^}}"), ['OPEN_INVERSE', 'CLOSE']); + shouldMatchTokens(tokenize("{{else}}"), ['OPEN_INVERSE', 'CLOSE']); + shouldMatchTokens(tokenize("{{ else }}"), ['OPEN_INVERSE', 'CLOSE']); + }); + + it('tokenizes inverse sections with ID as "OPEN_INVERSE ID CLOSE"', function() { + var result = tokenize("{{^foo}}"); + shouldMatchTokens(result, ['OPEN_INVERSE', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + }); + + it('tokenizes inverse sections with ID and spaces as "OPEN_INVERSE ID CLOSE"', function() { + var result = tokenize("{{^ foo }}"); + shouldMatchTokens(result, ['OPEN_INVERSE', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + }); + + it('tokenizes mustaches with params as "OPEN ID ID ID CLOSE"', function() { + var result = tokenize("{{ foo bar baz }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + shouldBeToken(result[2], "ID", "bar"); + shouldBeToken(result[3], "ID", "baz"); + }); + + it('tokenizes mustaches with String params as "OPEN ID ID STRING CLOSE"', function() { + var result = tokenize("{{ foo bar \"baz\" }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']); + shouldBeToken(result[3], "STRING", "baz"); + }); + + it('tokenizes mustaches with String params using single quotes as "OPEN ID ID STRING CLOSE"', function() { + var result = tokenize("{{ foo bar \'baz\' }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']); + shouldBeToken(result[3], "STRING", "baz"); + }); + + it('tokenizes String params with spaces inside as "STRING"', function() { + var result = tokenize("{{ foo bar \"baz bat\" }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'STRING', 'CLOSE']); + shouldBeToken(result[3], "STRING", "baz bat"); + }); + + it('tokenizes String params with escapes quotes as STRING', function() { + var result = tokenize('{{ foo "bar\\"baz" }}'); + shouldMatchTokens(result, ['OPEN', 'ID', 'STRING', 'CLOSE']); + shouldBeToken(result[2], "STRING", 'bar"baz'); + }); + + it('tokenizes String params using single quotes with escapes quotes as STRING', function() { + var result = tokenize("{{ foo 'bar\\'baz' }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'STRING', 'CLOSE']); + shouldBeToken(result[2], "STRING", "bar'baz"); + }); + + it('tokenizes numbers', function() { + var result = tokenize('{{ foo 1 }}'); + shouldMatchTokens(result, ['OPEN', 'ID', 'NUMBER', 'CLOSE']); + shouldBeToken(result[2], "NUMBER", "1"); + + result = tokenize('{{ foo 1.1 }}'); + shouldMatchTokens(result, ['OPEN', 'ID', 'NUMBER', 'CLOSE']); + shouldBeToken(result[2], "NUMBER", "1.1"); + + result = tokenize('{{ foo -1 }}'); + shouldMatchTokens(result, ['OPEN', 'ID', 'NUMBER', 'CLOSE']); + shouldBeToken(result[2], "NUMBER", "-1"); + + result = tokenize('{{ foo -1.1 }}'); + shouldMatchTokens(result, ['OPEN', 'ID', 'NUMBER', 'CLOSE']); + shouldBeToken(result[2], "NUMBER", "-1.1"); + }); + + it('tokenizes booleans', function() { + var result = tokenize('{{ foo true }}'); + shouldMatchTokens(result, ['OPEN', 'ID', 'BOOLEAN', 'CLOSE']); + shouldBeToken(result[2], "BOOLEAN", "true"); + + result = tokenize('{{ foo false }}'); + shouldMatchTokens(result, ['OPEN', 'ID', 'BOOLEAN', 'CLOSE']); + shouldBeToken(result[2], "BOOLEAN", "false"); + }); + + it('tokenizes hash arguments', function() { + var result = tokenize("{{ foo bar=baz }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']); + + result = tokenize("{{ foo bar baz=bat }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']); + + result = tokenize("{{ foo bar baz=1 }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'NUMBER', 'CLOSE']); + + result = tokenize("{{ foo bar baz=true }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'BOOLEAN', 'CLOSE']); + + result = tokenize("{{ foo bar baz=false }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'BOOLEAN', 'CLOSE']); + + result = tokenize("{{ foo bar\n baz=bat }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'CLOSE']); + + result = tokenize("{{ foo bar baz=\"bat\" }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'STRING', 'CLOSE']); + + result = tokenize("{{ foo bar baz=\"bat\" bam=wot }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'STRING', 'ID', 'EQUALS', 'ID', 'CLOSE']); + + result = tokenize("{{foo omg bar=baz bat=\"bam\"}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'ID', 'EQUALS', 'ID', 'ID', 'EQUALS', 'STRING', 'CLOSE']); + shouldBeToken(result[2], "ID", "omg"); + }); + + it('tokenizes special @ identifiers', function() { + var result = tokenize("{{ @foo }}"); + shouldMatchTokens(result, ['OPEN', 'DATA', 'ID', 'CLOSE']); + shouldBeToken(result[2], "ID", "foo"); + + result = tokenize("{{ foo @bar }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'DATA', 'ID', 'CLOSE']); + shouldBeToken(result[3], "ID", "bar"); + + result = tokenize("{{ foo bar=@baz }}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'ID', 'EQUALS', 'DATA', 'ID', 'CLOSE']); + shouldBeToken(result[5], "ID", "baz"); + }); + + it('does not time out in a mustache with a single } followed by EOF', function() { + shouldMatchTokens(tokenize("{{foo}"), ['OPEN', 'ID']); + }); + + it('does not time out in a mustache when invalid ID characters are used', function() { + shouldMatchTokens(tokenize("{{foo & }}"), ['OPEN', 'ID']); + }); + + it('tokenizes subexpressions', function() { + var result = tokenize("{{foo (bar)}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'CLOSE_SEXPR', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + shouldBeToken(result[3], "ID", "bar"); + + result = tokenize("{{foo (a-x b-y)}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'ID', 'CLOSE_SEXPR', 'CLOSE']); + shouldBeToken(result[1], "ID", "foo"); + shouldBeToken(result[3], "ID", "a-x"); + shouldBeToken(result[4], "ID", "b-y"); + }); + + it('tokenizes nested subexpressions', function() { + var result = tokenize("{{foo (bar (lol rofl)) (baz)}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'OPEN_SEXPR', 'ID', 'ID', 'CLOSE_SEXPR', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'CLOSE_SEXPR', 'CLOSE']); + shouldBeToken(result[3], "ID", "bar"); + shouldBeToken(result[5], "ID", "lol"); + shouldBeToken(result[6], "ID", "rofl"); + shouldBeToken(result[10], "ID", "baz"); + }); + + it('tokenizes nested subexpressions: literals', function() { + var result = tokenize("{{foo (bar (lol true) false) (baz 1) (blah 'b') (blorg \"c\")}}"); + shouldMatchTokens(result, ['OPEN', 'ID', 'OPEN_SEXPR', 'ID', 'OPEN_SEXPR', 'ID', 'BOOLEAN', 'CLOSE_SEXPR', 'BOOLEAN', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'NUMBER', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'STRING', 'CLOSE_SEXPR', 'OPEN_SEXPR', 'ID', 'STRING', 'CLOSE_SEXPR', 'CLOSE']); + }); +}); + |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 +64 +65 +66 +67 +68 +69 +70 +71 +72 +73 +74 +75 +76 +77 +78 +79 +80 +81 +82 +83 +84 +85 +86 +87 +88 +89 +90 +91 +92 +93 +94 +95 +96 +97 +98 +99 +100 +101 +102 +103 +104 +105 +106 +107 +108 +109 +110 +111 +112 +113 +114 +115 +116 +117 +118 +119 +120 +121 +122 +123 +124 +125 +126 +127 +128 +129 +130 +131 +132 +133 +134 +135 +136 +137 +138 +139 +140 +141 +142 +143 +144 +145 +146 +147 +148 +149 +150 +151 +152 +153 +154 +155 +156 +157 +158 +159 +160 +161 +162 +163 +164 | +3 +3 +3 + + + +3 + + + + + + + + + + + + + +3 + + + + + + + + + + + + + +3 + + + + + + + + + + + + + +3 + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 + + + + + + + + + + + + + + +3 +3 + + + + + +3 +3 + + + + +3 + + + + +3 + + + + + +3 +3 + + + + +3 + + + + + +3 +3 + + + + +3 + + + + +3 + + + + + + + + | /*global CompilerContext */
+describe('track ids', function() {
+ var context;
+ beforeEach(function() {
+ context = {is: {a: 'foo'}, slave: {driver: 'bar'}};
+ });
+
+ it('should not include anything without the flag', function() {
+ var template = CompilerContext.compile('{{wycats is.a slave.driver}}');
+
+ var helpers = {
+ wycats: function(passiveVoice, noun, options) {
+ equal(options.ids, undefined);
+ equal(options.hashIds, undefined);
+
+ return 'success';
+ }
+ };
+
+ equals(template({}, {helpers: helpers}), 'success');
+ });
+ it('should include argument ids', function() {
+ var template = CompilerContext.compile('{{wycats is.a slave.driver}}', {trackIds: true});
+
+ var helpers = {
+ wycats: function(passiveVoice, noun, options) {
+ equal(options.ids[0], 'is.a');
+ equal(options.ids[1], 'slave.driver');
+
+ return "HELP ME MY BOSS " + options.ids[0] + ':' + passiveVoice + ' ' + options.ids[1] + ':' + noun;
+ }
+ };
+
+ equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS is.a:foo slave.driver:bar');
+ });
+ it('should include hash ids', function() {
+ var template = CompilerContext.compile('{{wycats bat=is.a baz=slave.driver}}', {trackIds: true});
+
+ var helpers = {
+ wycats: function(options) {
+ equal(options.hashIds.bat, 'is.a');
+ equal(options.hashIds.baz, 'slave.driver');
+
+ return "HELP ME MY BOSS " + options.hashIds.bat + ':' + options.hash.bat + ' ' + options.hashIds.baz + ':' + options.hash.baz;
+ }
+ };
+
+ equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS is.a:foo slave.driver:bar');
+ });
+ it('should note ../ and ./ references', function() {
+ var template = CompilerContext.compile('{{wycats ./is.a ../slave.driver}}', {trackIds: true});
+
+ var helpers = {
+ wycats: function(passiveVoice, noun, options) {
+ equal(options.ids[0], 'is.a');
+ equal(options.ids[1], '../slave.driver');
+
+ return "HELP ME MY BOSS " + options.ids[0] + ':' + passiveVoice + ' ' + options.ids[1] + ':' + noun;
+ }
+ };
+
+ equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS is.a:foo ../slave.driver:undefined');
+ });
+ it('should note @data references', function() {
+ var template = CompilerContext.compile('{{wycats @is.a @slave.driver}}', {trackIds: true});
+
+ var helpers = {
+ wycats: function(passiveVoice, noun, options) {
+ equal(options.ids[0], '@is.a');
+ equal(options.ids[1], '@slave.driver');
+
+ return "HELP ME MY BOSS " + options.ids[0] + ':' + passiveVoice + ' ' + options.ids[1] + ':' + noun;
+ }
+ };
+
+ equals(template({}, {helpers: helpers, data:context}), 'HELP ME MY BOSS @is.a:foo @slave.driver:bar');
+ });
+
+ it('should return null for constants', function() {
+ var template = CompilerContext.compile('{{wycats 1 "foo" key=false}}', {trackIds: true});
+
+ var helpers = {
+ wycats: function(passiveVoice, noun, options) {
+ equal(options.ids[0], null);
+ equal(options.ids[1], null);
+ equal(options.hashIds.key, null);
+
+ return "HELP ME MY BOSS " + passiveVoice + ' ' + noun + ' ' + options.hash.key;
+ }
+ };
+
+ equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS 1 foo false');
+ });
+ it('should return true for subexpressions', function() {
+ var template = CompilerContext.compile('{{wycats (sub)}}', {trackIds: true});
+
+ var helpers = {
+ sub: function() { return 1; },
+ wycats: function(passiveVoice, options) {
+ equal(options.ids[0], true);
+
+ return "HELP ME MY BOSS " + passiveVoice;
+ }
+ };
+
+ equals(template(context, {helpers: helpers}), 'HELP ME MY BOSS 1');
+ });
+
+ describe('builtin helpers', function() {
+ var helpers = {
+ wycats: function(name, options) {
+ return name + ':' + options.data.contextPath + '\n';
+ }
+ };
+
+ describe('#each', function() {
+ it('should track contextPath for arrays', function() {
+ var template = CompilerContext.compile('{{#each array}}{{wycats name}}{{/each}}', {trackIds: true});
+
+ equals(template({array: [{name: 'foo'}, {name: 'bar'}]}, {helpers: helpers}), 'foo:array.0\nbar:array.1\n');
+ });
+ it('should track contextPath for keys', function() {
+ var template = CompilerContext.compile('{{#each object}}{{wycats name}}{{/each}}', {trackIds: true});
+
+ equals(template({object: {foo: {name: 'foo'}, bar: {name: 'bar'}}}, {helpers: helpers}), 'foo:object.foo\nbar:object.bar\n');
+ });
+ it('should handle nesting', function() {
+ var template = CompilerContext.compile('{{#each .}}{{#each .}}{{wycats name}}{{/each}}{{/each}}', {trackIds: true});
+
+ equals(template({array: [{name: 'foo'}, {name: 'bar'}]}, {helpers: helpers}), 'foo:.array..0\nbar:.array..1\n');
+ });
+ });
+ describe('#with', function() {
+ it('should track contextPath', function() {
+ var template = CompilerContext.compile('{{#with field}}{{wycats name}}{{/with}}', {trackIds: true});
+
+ equals(template({field: {name: 'foo'}}, {helpers: helpers}), 'foo:field\n');
+ });
+ it('should handle nesting', function() {
+ var template = CompilerContext.compile('{{#with bat}}{{#with field}}{{wycats name}}{{/with}}{{/with}}', {trackIds: true});
+
+ equals(template({bat: {field: {name: 'foo'}}}, {helpers: helpers}), 'foo:bat.field\n');
+ });
+ });
+ describe('#blockHelperMissing', function() {
+ it('should track contextPath for arrays', function() {
+ var template = CompilerContext.compile('{{#field}}{{wycats name}}{{/field}}', {trackIds: true});
+
+ equals(template({field: [{name: 'foo'}]}, {helpers: helpers}), 'foo:field.0\n');
+ });
+ it('should track contextPath for keys', function() {
+ var template = CompilerContext.compile('{{#field}}{{wycats name}}{{/field}}', {trackIds: true});
+
+ equals(template({field: {name: 'foo'}}, {helpers: helpers}), 'foo:field\n');
+ });
+ it('should handle nesting', function() {
+ var template = CompilerContext.compile('{{#bat}}{{#field}}{{wycats name}}{{/field}}{{/bat}}', {trackIds: true});
+
+ equals(template({bat: {field: {name: 'foo'}}}, {helpers: helpers}), 'foo:bat.field\n');
+ });
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 | + +3 +3 +3 + + + + + + + +3 + + + + + + +3 +3 + + +3 + + + + +3 + + + + + + + +3 + + + + + +3 +3 + + + + + + + +3 + + + + + + + + | /*global Handlebars, shouldCompileTo */
+
+describe('utils', function() {
+ describe('#SafeString', function() {
+ it("constructing a safestring from a string and checking its type", function() {
+ var safe = new Handlebars.SafeString("testing 1, 2, 3");
+ if (!(safe instanceof Handlebars.SafeString)) {
+ throw new Error('Must be instance of SafeString');
+ }
+ equals(safe == 'testing 1, 2, 3', true, 'SafeString is equivalent to its underlying string');
+ });
+
+ it("it should not escape SafeString properties", function() {
+ var name = new Handlebars.SafeString("<em>Sean O'Malley</em>");
+
+ shouldCompileTo('{{name}}', [{ name: name }], "<em>Sean O'Malley</em>");
+ });
+ });
+
+ describe('#escapeExpression', function() {
+ it('shouhld escape html', function() {
+ equals(Handlebars.Utils.escapeExpression('foo<&"\'>'), 'foo<&"'>');
+ });
+ it('should not escape SafeString', function() {
+ var string = new Handlebars.SafeString('foo<&"\'>');
+ equals(Handlebars.Utils.escapeExpression(string), 'foo<&"\'>');
+
+ });
+ it('should handle falsy', function() {
+ equals(Handlebars.Utils.escapeExpression(''), '');
+ equals(Handlebars.Utils.escapeExpression(undefined), '');
+ equals(Handlebars.Utils.escapeExpression(null), '');
+ equals(Handlebars.Utils.escapeExpression(false), '');
+
+ equals(Handlebars.Utils.escapeExpression(0), '0');
+ });
+ it('should handle empty objects', function() {
+ equals(Handlebars.Utils.escapeExpression({}), {}.toString());
+ equals(Handlebars.Utils.escapeExpression([]), [].toString());
+ });
+ });
+
+ describe('#isEmpty', function() {
+ it('should not be empty', function() {
+ equals(Handlebars.Utils.isEmpty(undefined), true);
+ equals(Handlebars.Utils.isEmpty(null), true);
+ equals(Handlebars.Utils.isEmpty(false), true);
+ equals(Handlebars.Utils.isEmpty(''), true);
+ equals(Handlebars.Utils.isEmpty([]), true);
+ });
+
+ it('should be empty', function() {
+ equals(Handlebars.Utils.isEmpty(0), false);
+ equals(Handlebars.Utils.isEmpty([1]), false);
+ equals(Handlebars.Utils.isEmpty('foo'), false);
+ equals(Handlebars.Utils.isEmpty({bar: 1}), false);
+ });
+ });
+});
+ |
| 1 +2 +3 +4 +5 +6 +7 +8 +9 +10 +11 +12 +13 +14 +15 +16 +17 +18 +19 +20 +21 +22 +23 +24 +25 +26 +27 +28 +29 +30 +31 +32 +33 +34 +35 +36 +37 +38 +39 +40 +41 +42 +43 +44 +45 +46 +47 +48 +49 +50 +51 +52 +53 +54 +55 +56 +57 +58 +59 +60 +61 +62 +63 | 3 +3 + + + + + + + + + + +3 +3 + + + + + + + +3 + + + + + + + +3 + + + + + + + + + + + + + + + + + + + + +3 + + + + + +3 + + + + + + | describe('whitespace control', function() {
+ it('should strip whitespace around mustache calls', function() {
+ var hash = {foo: 'bar<'};
+
+ shouldCompileTo(' {{~foo~}} ', hash, 'bar<');
+ shouldCompileTo(' {{~foo}} ', hash, 'bar< ');
+ shouldCompileTo(' {{foo~}} ', hash, ' bar<');
+
+ shouldCompileTo(' {{~&foo~}} ', hash, 'bar<');
+ shouldCompileTo(' {{~{foo}~}} ', hash, 'bar<');
+ });
+
+ describe('blocks', function() {
+ it('should strip whitespace around simple block calls', function() {
+ var hash = {foo: 'bar<'};
+
+ shouldCompileTo(' {{~#if foo~}} bar {{~/if~}} ', hash, 'bar');
+ shouldCompileTo(' {{#if foo~}} bar {{/if~}} ', hash, ' bar ');
+ shouldCompileTo(' {{~#if foo}} bar {{~/if}} ', hash, ' bar ');
+ shouldCompileTo(' {{#if foo}} bar {{/if}} ', hash, ' bar ');
+ });
+ it('should strip whitespace around inverse block calls', function() {
+ var hash = {};
+
+ shouldCompileTo(' {{~^if foo~}} bar {{~/if~}} ', hash, 'bar');
+ shouldCompileTo(' {{^if foo~}} bar {{/if~}} ', hash, ' bar ');
+ shouldCompileTo(' {{~^if foo}} bar {{~/if}} ', hash, ' bar ');
+ shouldCompileTo(' {{^if foo}} bar {{/if}} ', hash, ' bar ');
+ });
+ it('should strip whitespace around complex block calls', function() {
+ var hash = {foo: 'bar<'};
+
+ shouldCompileTo('{{#if foo~}} bar {{~^~}} baz {{~/if}}', hash, 'bar');
+ shouldCompileTo('{{#if foo~}} bar {{^~}} baz {{/if}}', hash, 'bar ');
+ shouldCompileTo('{{#if foo}} bar {{~^~}} baz {{~/if}}', hash, ' bar');
+ shouldCompileTo('{{#if foo}} bar {{^~}} baz {{/if}}', hash, ' bar ');
+
+ shouldCompileTo('{{#if foo~}} bar {{~else~}} baz {{~/if}}', hash, 'bar');
+
+ hash = {};
+
+ shouldCompileTo('{{#if foo~}} bar {{~^~}} baz {{~/if}}', hash, 'baz');
+ shouldCompileTo('{{#if foo}} bar {{~^~}} baz {{/if}}', hash, 'baz ');
+ shouldCompileTo('{{#if foo~}} bar {{~^}} baz {{~/if}}', hash, ' baz');
+ shouldCompileTo('{{#if foo~}} bar {{~^}} baz {{/if}}', hash, ' baz ');
+
+ shouldCompileTo('{{#if foo~}} bar {{~else~}} baz {{~/if}}', hash, 'baz');
+ });
+ });
+
+ it('should strip whitespace around partials', function() {
+ shouldCompileToWithPartials('foo {{~> dude~}} ', [{}, {}, {dude: 'bar'}], true, 'foobar');
+ shouldCompileToWithPartials('foo {{> dude~}} ', [{}, {}, {dude: 'bar'}], true, 'foo bar');
+ shouldCompileToWithPartials('foo {{> dude}} ', [{}, {}, {dude: 'bar'}], true, 'foo bar ');
+ });
+
+ it('should only strip whitespace once', function() {
+ var hash = {foo: 'bar'};
+
+ shouldCompileTo(' {{~foo~}} {{foo}} {{foo}} ', hash, 'barbar bar ');
+ });
+});
+ |