handlebars.js/spec/subexpressions.js

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('multiple subexpressions in a hash with context', function() {
    var string =
      '{{input aria-label=(t item.field) placeholder=(t item.placeholder)}}';

    var context = {
      item: {
        field: 'Name',
        placeholder: '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,
      [context, 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],
          'SubExpression',
          'string params for outer helper processed correctly'
        );
        equals(
          options.types[1],
          'PathExpression',
          '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],
          'PathExpression',
          '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, 'SubExpression');
        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!');
    });
  });
});