ole-martin
23d58e79bb
Reintroduce "merge" function, no called "mergeIfNeeded", that only creates a new partials object if both "env.partials" and "options.partials" are set. closes #1598
365 lines
13 KiB
JavaScript
365 lines
13 KiB
JavaScript
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() {
|
|
/* eslint-disable no-extend-native */
|
|
Object.prototype[0xD834] = true;
|
|
|
|
shouldCompileTo('{{foo}}', { foo: 'bar' }, 'bar');
|
|
|
|
delete Object.prototype[0xD834];
|
|
/* eslint-enable no-extend-native */
|
|
});
|
|
|
|
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('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}, '');
|
|
});
|
|
|
|
it('GH-837: undefined values for helpers', function() {
|
|
var helpers = {
|
|
str: function(value) { return value + ''; }
|
|
};
|
|
|
|
shouldCompileTo('{{str bar.baz}}', [{}, helpers], 'undefined');
|
|
});
|
|
|
|
it('GH-926: Depths and de-dupe', function() {
|
|
var context = {
|
|
name: 'foo',
|
|
data: [
|
|
1
|
|
],
|
|
notData: [
|
|
1
|
|
]
|
|
};
|
|
|
|
var template = CompilerContext.compile('{{#if dater}}{{#each data}}{{../name}}{{/each}}{{else}}{{#each notData}}{{../name}}{{/each}}{{/if}}');
|
|
|
|
var result = template(context);
|
|
equals(result, 'foo');
|
|
});
|
|
|
|
it('GH-1021: Each empty string key', function() {
|
|
var data = {
|
|
'': 'foo',
|
|
'name': 'Chris',
|
|
'value': 10000
|
|
};
|
|
|
|
shouldCompileTo('{{#each data}}Key: {{@key}}\n{{/each}}', {data: data}, 'Key: \nKey: name\nKey: value\n');
|
|
});
|
|
|
|
it('GH-1054: Should handle simple safe string responses', function() {
|
|
var root = '{{#wrap}}{{>partial}}{{/wrap}}';
|
|
var partials = {
|
|
partial: '{{#wrap}}<partial>{{/wrap}}'
|
|
};
|
|
var helpers = {
|
|
wrap: function(options) {
|
|
return new Handlebars.SafeString(options.fn());
|
|
}
|
|
};
|
|
|
|
shouldCompileToWithPartials(root, [{}, helpers, partials], true, '<partial>');
|
|
});
|
|
|
|
it('GH-1065: Sparse arrays', function() {
|
|
var array = [];
|
|
array[1] = 'foo';
|
|
array[3] = 'bar';
|
|
shouldCompileTo('{{#each array}}{{@index}}{{.}}{{/each}}', {array: array}, '1foo3bar');
|
|
});
|
|
|
|
it('GH-1093: Undefined helper context', function() {
|
|
var obj = {foo: undefined, bar: 'bat'};
|
|
var helpers = {
|
|
helper: function() {
|
|
// It's valid to execute a block against an undefined context, but
|
|
// helpers can not do so, so we expect to have an empty object here;
|
|
for (var name in this) {
|
|
if (Object.prototype.hasOwnProperty.call(this, name)) {
|
|
return 'found';
|
|
}
|
|
}
|
|
// And to make IE happy, check for the known string as length is not enumerated.
|
|
return (this === 'bat' ? 'found' : 'not');
|
|
}
|
|
};
|
|
|
|
shouldCompileTo('{{#each obj}}{{{helper}}}{{.}}{{/each}}', [{obj: obj}, helpers], 'notfoundbat');
|
|
});
|
|
|
|
it('should support multiple levels of inline partials', function() {
|
|
var string = '{{#> layout}}{{#*inline "subcontent"}}subcontent{{/inline}}{{/layout}}';
|
|
var partials = {
|
|
doctype: 'doctype{{> content}}',
|
|
layout: '{{#> doctype}}{{#*inline "content"}}layout{{> subcontent}}{{/inline}}{{/doctype}}'
|
|
};
|
|
shouldCompileToWithPartials(string, [{}, {}, partials], true, 'doctypelayoutsubcontent');
|
|
});
|
|
it('GH-1089: should support failover content in multiple levels of inline partials', function() {
|
|
var string = '{{#> layout}}{{/layout}}';
|
|
var partials = {
|
|
doctype: 'doctype{{> content}}',
|
|
layout: '{{#> doctype}}{{#*inline "content"}}layout{{#> subcontent}}subcontent{{/subcontent}}{{/inline}}{{/doctype}}'
|
|
};
|
|
shouldCompileToWithPartials(string, [{}, {}, partials], true, 'doctypelayoutsubcontent');
|
|
});
|
|
it('GH-1099: should support greater than 3 nested levels of inline partials', function() {
|
|
var string = '{{#> layout}}Outer{{/layout}}';
|
|
var partials = {
|
|
layout: '{{#> inner}}Inner{{/inner}}{{> @partial-block }}',
|
|
inner: ''
|
|
};
|
|
shouldCompileToWithPartials(string, [{}, {}, partials], true, 'Outer');
|
|
});
|
|
|
|
it('GH-1135 : Context handling within each iteration', function() {
|
|
var obj = {array: [1], name: 'John'};
|
|
var helpers = {
|
|
myif: function(conditional, options) {
|
|
if (conditional) {
|
|
return options.fn(this);
|
|
} else {
|
|
return options.inverse(this);
|
|
}
|
|
}
|
|
};
|
|
|
|
shouldCompileTo(
|
|
'{{#each array}}\n'
|
|
+ ' 1. IF: {{#if true}}{{../name}}-{{../../name}}-{{../../../name}}{{/if}}\n'
|
|
+ ' 2. MYIF: {{#myif true}}{{../name}}={{../../name}}={{../../../name}}{{/myif}}\n'
|
|
+ '{{/each}}', [obj, helpers],
|
|
' 1. IF: John--\n'
|
|
+ ' 2. MYIF: John==\n');
|
|
});
|
|
|
|
it('GH-1186: Support block params for existing programs', function() {
|
|
var string =
|
|
'{{#*inline "test"}}{{> @partial-block }}{{/inline}}'
|
|
+ '{{#>test }}{{#each listOne as |item|}}{{ item }}{{/each}}{{/test}}'
|
|
+ '{{#>test }}{{#each listTwo as |item|}}{{ item }}{{/each}}{{/test}}';
|
|
|
|
shouldCompileTo(string, { listOne: ['a'], listTwo: ['b']}, 'ab', '');
|
|
});
|
|
|
|
it('GH-1319: "unless" breaks when "each" value equals "null"', function() {
|
|
var string = '{{#each list}}{{#unless ./prop}}parent={{../value}} {{/unless}}{{/each}}';
|
|
shouldCompileTo(string, { value: 'parent', list: [ null, 'a'] }, 'parent=parent parent=parent ', '');
|
|
});
|
|
|
|
it('GH-1341: 4.0.7 release breaks {{#if @partial-block}} usage', function() {
|
|
var string = 'template {{>partial}} template';
|
|
var partials = {
|
|
partialWithBlock: '{{#if @partial-block}} block {{> @partial-block}} block {{/if}}',
|
|
partial: '{{#> partialWithBlock}} partial {{/partialWithBlock}}'
|
|
};
|
|
shouldCompileToWithPartials(string, [{}, {}, partials], true, 'template block partial block template');
|
|
});
|
|
|
|
describe('GH-1561: 4.3.x should still work with precompiled templates from 4.0.0 <= x < 4.3.0', function() {
|
|
|
|
it('should compile and execute templates', function() {
|
|
var newHandlebarsInstance = Handlebars.create();
|
|
|
|
registerTemplate(newHandlebarsInstance);
|
|
newHandlebarsInstance.registerHelper('loud', function(value) {
|
|
return value.toUpperCase();
|
|
});
|
|
var result = newHandlebarsInstance.templates['test.hbs']({name: 'yehuda'});
|
|
equals(result.trim(), 'YEHUDA');
|
|
});
|
|
|
|
it('should call "helperMissing" if a helper is missing', function() {
|
|
var newHandlebarsInstance = Handlebars.create();
|
|
|
|
shouldThrow(function() {
|
|
registerTemplate(newHandlebarsInstance);
|
|
newHandlebarsInstance.templates['test.hbs']({});
|
|
}, Handlebars.Exception, 'Missing helper: "loud"');
|
|
});
|
|
|
|
// This is a only slightly modified precompiled templated from compiled with 4.2.1
|
|
function registerTemplate(Handlebars) {
|
|
var template = Handlebars.template, templates = Handlebars.templates = Handlebars.templates || {};
|
|
templates['test.hbs'] = template({'compiler': [7, '>= 4.0.0'], 'main': function(container, depth0, helpers, partials, data) {
|
|
return container.escapeExpression((helpers.loud || (depth0 && depth0.loud) || helpers.helperMissing).call(depth0 != null ? depth0 : (container.nullContext || {}), (depth0 != null ? depth0.name : depth0), {'name': 'loud', 'hash': {}, 'data': data}))
|
|
+ '\n\n';
|
|
}, 'useData': true});
|
|
}
|
|
});
|
|
|
|
it('should allow hash with protected array names', function() {
|
|
var obj = {array: [1], name: 'John'};
|
|
var helpers = {
|
|
helpa: function(options) {
|
|
return options.hash.length;
|
|
}
|
|
};
|
|
|
|
shouldCompileTo('{{helpa length="foo"}}', [obj, helpers], 'foo');
|
|
});
|
|
|
|
describe('GH-1598: Performance degradation for partials since v4.3.0', function() {
|
|
// Do not run test for runs without compiler
|
|
if (!Handlebars.compile) {
|
|
return;
|
|
}
|
|
|
|
var newHandlebarsInstance;
|
|
beforeEach(function() {
|
|
newHandlebarsInstance = Handlebars.create();
|
|
});
|
|
afterEach(function() {
|
|
sinon.restore();
|
|
});
|
|
|
|
it('should only compile global partials once', function() {
|
|
var templateSpy = sinon.spy(newHandlebarsInstance, 'template');
|
|
newHandlebarsInstance.registerPartial({
|
|
'dude': 'I am a partial'
|
|
});
|
|
var string = 'Dudes: {{> dude}} {{> dude}}';
|
|
newHandlebarsInstance.compile(string)(); // This should compile template + partial once
|
|
newHandlebarsInstance.compile(string)(); // This should only compile template
|
|
equal(templateSpy.callCount, 3);
|
|
sinon.restore();
|
|
});
|
|
});
|
|
});
|