From efdeb55202b4e8ed114eebeaabe798391f1b0a4c Mon Sep 17 00:00:00 2001 From: "raymond.lam" Date: Thu, 16 Aug 2018 22:50:22 -0400 Subject: [PATCH] Add tags parameter to .render() --- README.md | 16 +++++++++++----- mustache.js | 16 +++++++++++----- test/render-test.js | 32 ++++++++++++++++++++++++++++++++ 3 files changed, 54 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index b7baa5c40..34b339204 100644 --- a/README.md +++ b/README.md @@ -117,9 +117,10 @@ Following is an [rtype](https://git.io/rtype) signature of the most commonly use ```js Mustache.render( - template : String, - view : Object, - partials? : Object, + template : String, + view : Object, + partials? : Object, + tags = ['{{', '}}'] : Tags, ) => String Mustache.parse( @@ -181,7 +182,7 @@ function loadUser() { The most basic tag type is a simple variable. A `{{name}}` tag renders the value of the `name` key in the current context. If there is no such key, nothing is rendered. -All variables are HTML-escaped by default. If you want to render unescaped HTML, use the triple mustache: `{{{name}}}`. You can also use `&` to unescape a variable. +All variables are HTML-escaped by default. If you want to render unescaped HTML, use the triple mustache: `{{{name}}}`. You can also use `&` to unescape a variable. If you'd like to change HTML-escaping behavior globally (for example, to template non-HTML formats), you can override Mustache's escape function. For example, to disable all escaping: `Mustache.escape = function(text) {return text;};`. @@ -504,12 +505,17 @@ Custom delimiters can be used in place of `{{` and `}}` by setting the new value #### Setting in JavaScript -The `Mustache.tags` property holds an array consisting of the opening and closing tag values. Set custom values by setting this property. +The `Mustache.tags` property holds an array consisting of the opening and closing tag values. Set custom values by passing a new array of tags to `render()`, which gets honored over the default values, or by overriding the `Mustache.tags` property itself: ```js var customTags = [ '<%', '%>' ]; ``` +##### Pass Value into Render Method +```js +Mustache.render(template, view, {}, customTags); +``` + ##### Override Tags Property ```js Mustache.tags = customTags; diff --git a/mustache.js b/mustache.js index 1b19379d3..bfc7ea9bb 100644 --- a/mustache.js +++ b/mustache.js @@ -462,9 +462,13 @@ * names and templates of partials that are used in the template. It may * also be a function that is used to load partial templates on the fly * that takes a single argument: the name of the partial. + * + * If the optional `tags` argument is given here it must be an array with two + * string values: the opening and closing tags used in the template (e.g. + * [ "<%", "%>" ]). The default is to mustache.tags. */ - Writer.prototype.render = function render (template, view, partials) { - var tokens = this.parse(template); + Writer.prototype.render = function render (template, view, partials, tags) { + var tokens = this.parse(template, tags); var context = (view instanceof Context) ? view : new Context(view); return this.renderTokens(tokens, context, partials, template); }; @@ -593,16 +597,18 @@ /** * Renders the `template` with the given `view` and `partials` using the - * default writer. + * default writer. If the optional `tags` argument is given here it must be an + * array with two string values: the opening and closing tags used in the + * template (e.g. [ "<%", "%>" ]). The default is to mustache.tags. */ - mustache.render = function render (template, view, partials) { + mustache.render = function render (template, view, partials, tags) { if (typeof template !== 'string') { throw new TypeError('Invalid template! Template should be a "string" ' + 'but "' + typeStr(template) + '" was given as the first ' + 'argument for mustache#render(template, view, partials)'); } - return defaultWriter.render(template, view, partials); + return defaultWriter.render(template, view, partials, tags); }; // This is here for backwards compatibility with 0.4.x., diff --git a/test/render-test.js b/test/render-test.js index e9d61a9da..dbcfc4cbc 100644 --- a/test/render-test.js +++ b/test/render-test.js @@ -17,6 +17,38 @@ describe('Mustache.render', function () { 'for mustache#render(template, view, partials)'); }); + it('uses tags argument instead of Mustache.tags when given', function () { + var template = '<>bar{{placeholder}}'; + + Mustache.tags = ['{{', '}}']; + assert.equal(Mustache.render(template, { placeholder: 'foo' }, {}, ['<<', '>>']), 'foobar{{placeholder}}'); + }); + + it('uses tags argument instead of Mustache.tags when given, even when it previous rendered the template using Mustache.tags', function () { + var template = '((placeholder))bar{{placeholder}}'; + + Mustache.tags = ['{{', '}}']; + Mustache.render(template, { placeholder: 'foo' }); + assert.equal(Mustache.render(template, { placeholder: 'foo' }, {}, ['((', '))']), 'foobar{{placeholder}}'); + }); + + it('uses tags argument instead of Mustache.tags when given, even when it previous rendered the template using different tags', function () { + var template = '[[placeholder]]bar<>'; + + Mustache.render(template, { placeholder: 'foo' }, {}, ['<<', '>>']); + assert.equal(Mustache.render(template, { placeholder: 'foo' }, {}, ['[[', ']]']), 'foobar<>'); + }); + + it('does not mutate Mustache.tags when given tags argument', function() { + var correctMustacheTags = ['{{', '}}']; + Mustache.tags = correctMustacheTags; + + Mustache.render('((placeholder))', { placeholder: 'foo' }, {}, ['((', '))']); + + assert.equal(Mustache.tags, correctMustacheTags); + assert.deepEqual(Mustache.tags, ['{{', '}}']); + }); + tests.forEach(function (test) { var view = eval(test.view);