kpdecker
306 lines
13 KiB
JavaScript
306 lines
13 KiB
JavaScript
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 a string context', function() {
|
|
shouldCompileTo('{{.}}{{length}}', 'bye', 'bye3');
|
|
});
|
|
|
|
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');
|
|
|
|
shouldCompileTo(' {{~! comment ~}} blah', {}, 'blah');
|
|
shouldCompileTo(' {{~!-- long-comment --~}} blah', {}, 'blah');
|
|
shouldCompileTo(' {{! comment ~}} blah', {}, ' blah');
|
|
shouldCompileTo(' {{!-- long-comment --~}} blah', {}, ' blah');
|
|
shouldCompileTo(' {{~! comment}} blah', {}, ' blah');
|
|
shouldCompileTo(' {{~!-- long-comment --}} blah', {}, ' blah');
|
|
});
|
|
|
|
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('false', function() {
|
|
/* eslint-disable no-new-wrappers */
|
|
shouldCompileTo('val1: {{val1}}, val2: {{val2}}', {val1: false, val2: new Boolean(false)}, 'val1: false, val2: false');
|
|
shouldCompileTo('val: {{.}}', false, 'val: false');
|
|
shouldCompileTo('val: {{val1/val2}}', {val1: {val2: false}}, 'val: false');
|
|
|
|
shouldCompileTo('val1: {{{val1}}}, val2: {{{val2}}}', {val1: false, val2: new Boolean(false)}, 'val1: false, val2: false');
|
|
shouldCompileTo('val: {{{val1/val2}}}', {val1: {val2: false}}, 'val: false');
|
|
/* eslint-enable */
|
|
});
|
|
|
|
it('should handle undefined and null', function() {
|
|
shouldCompileTo('{{awesome undefined null}}',
|
|
{
|
|
awesome: function(_undefined, _null, options) {
|
|
return (_undefined === undefined) + ' ' + (_null === null) + ' ' + (typeof options);
|
|
}
|
|
},
|
|
'true true object');
|
|
shouldCompileTo('{{undefined}}',
|
|
{
|
|
'undefined': function() {
|
|
return 'undefined!';
|
|
}
|
|
},
|
|
'undefined!');
|
|
shouldCompileTo('{{null}}',
|
|
{
|
|
'null': function() {
|
|
return 'null!';
|
|
}
|
|
},
|
|
'null!');
|
|
});
|
|
|
|
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() { 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() { 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!');
|
|
shouldCompileTo('Goodbye {{"foo bar"}} world!', {'foo bar': 'beautiful'}, 'Goodbye beautiful world!');
|
|
shouldCompileTo("Goodbye {{'foo bar'}} world!", {'foo bar': 'beautiful'}, 'Goodbye beautiful world!');
|
|
shouldCompileTo('Goodbye {{"foo[bar"}} world!', {'foo[bar': 'beautiful'}, 'Goodbye beautiful world!');
|
|
shouldCompileTo('Goodbye {{"foo\'bar"}} world!', {"foo'bar": 'beautiful'}, 'Goodbye beautiful world!');
|
|
shouldCompileTo("Goodbye {{'foo\"bar'}} world!", {'foo"bar': 'beautiful'}, 'Goodbye beautiful world!');
|
|
});
|
|
|
|
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() {
|
|
shouldThrow(function() {
|
|
CompilerContext.compile('{{#hellos}}{{text/this/foo}}{{/hellos}}');
|
|
}, Error, 'Invalid path: text/this - 1:13');
|
|
|
|
shouldCompileTo('{{[this]}}', {'this': 'bar'}, 'bar');
|
|
shouldCompileTo('{{text/[this]}}', {text: {'this': 'bar'}}, 'bar');
|
|
});
|
|
|
|
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, 'Invalid path: text/this - 1:17');
|
|
|
|
shouldCompileTo(
|
|
'{{foo [this]}}',
|
|
{foo: function(value) { return value; }, 'this': 'bar'},
|
|
'bar');
|
|
shouldCompileTo(
|
|
'{{foo text/[this]}}',
|
|
{foo: function(value) { return value; }, text: {'this': 'bar'}},
|
|
'bar');
|
|
});
|
|
|
|
it('pass string literals', function() {
|
|
shouldCompileTo('{{"foo"}}', {}, '');
|
|
shouldCompileTo('{{"foo"}}', { foo: 'bar' }, 'bar');
|
|
shouldCompileTo('{{#"foo"}}{{.}}{{/"foo"}}', { foo: ['bar', 'baz'] }, 'barbaz');
|
|
});
|
|
|
|
it('pass number literals', function() {
|
|
shouldCompileTo('{{12}}', {}, '');
|
|
shouldCompileTo('{{12}}', { '12': 'bar' }, 'bar');
|
|
shouldCompileTo('{{12.34}}', {}, '');
|
|
shouldCompileTo('{{12.34}}', { '12.34': 'bar' }, 'bar');
|
|
shouldCompileTo('{{12.34 1}}', { '12.34': function(arg) { return 'bar' + arg; } }, 'bar1');
|
|
});
|
|
|
|
it('pass boolean literals', function() {
|
|
shouldCompileTo('{{true}}', {}, '');
|
|
shouldCompileTo('{{true}}', { '': 'foo' }, '');
|
|
shouldCompileTo('{{false}}', { 'false': 'foo' }, 'foo');
|
|
});
|
|
|
|
it('should handle literals in subexpression', function() {
|
|
var helpers = {
|
|
foo: function(arg) {
|
|
return arg;
|
|
}
|
|
};
|
|
shouldCompileTo('{{foo (false)}}', [{ 'false': function() { return 'bar'; } }, helpers], 'bar');
|
|
});
|
|
});
|