handlebars.js/spec/data.js

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) {
        if (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 can be functions', function() {
    var template = CompilerContext.compile('{{@hello}}');
    var result = template({}, { data: { hello: function() { return 'hello'; } } });
    equals('hello', result);
  });
  it('data can be functions with params', function() {
    var template = CompilerContext.compile('{{@hello "hello"}}');
    var result = template({}, { data: { hello: function(arg) { return arg; } } });
    equals('hello', result);
  });

  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) {
          if (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('{{>myPartial}}', {data: true});

    var partials = {
      myPartial: 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);
    });
  });
});