visionmedia/minstache

Mini mustache compiling to stand-alone functions

minstache

Mini mustache template engine.

Installation

$ npm install minstache
$ component install visionmedia/minstache

minstache(1)

The minstache(1) executable can compile a file to a valid stand-alone commonjs module for you, there's no need to have minstache as a dependency:

hello.mustache:

Hello {{name}}! {{^authenticated}}<a href="/login">login</a>{{/authenticated}}

convert it:

$ minstache < hello.mustache > hello.js

hello.js:

module.exports = function anonymous(obj) {

  function escape(html) {
    return String(html)
      .replace(/&/g, '&')
      .replace(/"/g, '"')
      .replace(/</g, '&lt;')
      .replace(/>/g, '&gt;');
  };

  function section(obj, prop, negate, str) {
    var val = obj[prop];
    if ('function' == typeof val) return val.call(obj, str);
    if (negate) val = !val;
    if (val) return str;
    return '';
  };

  return "Hello " + escape(obj.name) + "! " + section(obj, "authenticated", true, "<a href=\"/login\">login</a>") + "\n"
}

API

minstache(string, [obj])

Compile and render the given mustache string with optional context obj.

minstache.compile(string)

Compile the mustache string to a stand-alone Function accepting a context obj.

Divergence

Partials are not supported, this lib is meant to be a small template engine solution for stand-alone component templates. If your template takes "partials" then pass other rendered strings to it. If you need a full-blown mustache solution Hogan.js is still great.

Minstache uses {{!name}} for unescaped properties.

License

MIT

minstache's Issues

rendering with dom nodes

this is more a question than an issue. Do you think it would be possible to create a "render" function that would

1. return a dom element

2. accept dom nodes as paramaters

E.g it would be awesome to be able to do :

Minstache.compile("<div>{{object}}</div>")({ object: myComponent.render() })

support for unescaped values

would be nice to have support for unescaped output, maybe {{{comment}}} or {{!comment}}

Update: {{!...}} seems like a really easy fix. I can submit a pull request if you think it's a useful feature.

Empty arrays not considered falsy

There is a divergence from the mustache spec for inverted sections with respect to empty arrays. minstache seems to be handling them as an iterator, not as an inverted section

https://github.com/janl/mustache.js/blob/0.8.2/README.md#inverted-sections

> require('mustache').render('{{^places}}none{{/places}}', {places: []})
'none'
> require('minstache')('{{^places}}none{{/places}}', {places: []})
''

array support

it'd be sweet for this library to support iteration through arrays.

{ contacts :
  [
    { name : 'matt' },
    { name : 'john' }
  ]
}

<ul>
  {#contacts}<li>{name}</li>{/contacts}
</ul>

I took a look at the way the lib is structured - it doesn't look trivial to implement. I feel like it's the last feature missing from a lightweight "core" mustache though.

Strong array check is not needed

I think we do not need strong array check at function:

function section(obj, prop, negate, thunk) {
  var val = obj[prop];
  if (Array.isArray(val)) return val.map(thunk).join('');
  if ('function' == typeof val) return val.call(obj, thunk(obj));
  if (negate) val = !val;
  if (val) return thunk(obj);
  return '';
}

I explain why. I have array-like object (extended from Array). And minstache do not understand that array-like object have Array as prototype.

I propose to change Array.isArray(val) to val instanceof Array.

And when we using Array.isArray(val) we forgot about IE8.

Thanks.