basic.js

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: '&"\'`\\<>' },
      '&amp;&quot;&#x27;&#x60;\\&lt;&gt;',
      'by default expressions should be escaped'
    );

    shouldCompileTo(
      '{{awesome}}',
      { awesome: 'Escaped, <b> looks like: &lt;b&gt;' },
      'Escaped, &lt;b&gt; looks like: &amp;lt;b&amp;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 Map', function() {
    var map = new Map();
    map.set('expression', 'beautiful');
    expectTemplate('Goodbye {{foo/expression}} world!')
      .withInput({ foo: map })
      .toCompileTo('Goodbye beautiful world!');
  });

  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'
    );
  });
});