Repository files navigation

What could be more logical awesome than no logic at all?

lustache is an implementation of themustache template system in Lua.

Mustache is a logic-less template syntax. It canbe used for HTML, config files, source code - anything. It works by expandingtags in a template using values provided in a hash or object.

We call it "logic-less" because there are no if statements, else clauses, or forloops. Instead there are only tags. Some tags are replaced with a value, somenothing, and others a series of values.

For a language-agnostic overview of mustache's template syntax, see themustache(5)manpage.

You can use lustache to render mustache templates anywhere you can use Lua.

lustache exposes itself as a module, so you only have to require the file. and assign it.

Download lustache.lua and place it in your project, or install it withluarocksusingluarocks install lustache. On OSX, you canbrew install luarocks.

Below is quick example how to use lustache:

local lustache = require "lustache"view_model = {  title = "Joe",  calc = function ()    return 2 + 4  end}output = lustache:render("{{title}} spends {{calc}}", view_model)

In this example, thelustache:render function takes two parameters: 1) themustache template and 2) aview_model objectthat contains the data and code needed to render the template.

Lustache uses thebusted testing framework.

Runluarocks make, thenbusted spec.Install busted throughluarocks install busted.

Amustache template is a string that containsany number of mustache tags. Tags are indicated by the double mustaches thatsurround them.{{person}} is a tag, as is{{#person}}. In both examples werefer toperson as the tag's key.

There are several types of tags available in lustache.

The most basic tag type is a simple variable. A{{name}} tag renders the valueof thename key in the current context. If there is no such key, nothing isrendered.

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 avariable.

Template:

* {{name}}* {{age}}* {{company}}* {{{company}}}* {{&company}}

View:

{  name = "Chris",  company = "<b>GitHub</b>"}

Output:

* Chris** &lt;b&gt;GitHub&lt;/b&gt;* <b>GitHub</b>* <b>GitHub</b>

Dot notation may be used to access keys that are properties ofobjects in a view.

Template:

* {{name.first}} {{name.last}}* {{age}}

View:

{  name = {    first = "Michael",    last = "Jackson"  },  age = "RIP"}

Output:

* Michael Jackson* RIP

Sections render blocks of text one or more times, depending on the value of thekey in the current context.

A section begins with a pound and ends with a slash. That is,{{#person}}begins aperson section, while{{/person}} ends it. The text between the twotags is referred to as that section's "block".

The behavior of the section is determined by the value of the key.

If theperson key exists and has a value ofnil orfalse,or is an empty list, the block will not be rendered.

Template:

Shown.{{#person}}Never shown!{{/person}}

View:

{  person = false}

Output:

Shown.

If theperson key exists and is notnil orfalse, and isnot an empty list the block will be rendered one or more times.

When the value is a list, the block is rendered once for each item in the list.The context of the block is set to the current item in the list for eachiteration. In this way we can loop over collections.

Template:

{{#stooges}}<b>{{name}}</b>{{/stooges}}

View:

{  stooges = {    { name = "Moe" },    { name = "Larry" },    { name = "Curly" }  }}

Output:

<b>Moe</b><b>Larry</b><b>Curly</b>

When looping over an array of strings, a. can be used to refer to the currentitem in the list.

Template:

{{#musketeers}}* {{.}}{{/musketeers}}

View:

{  musketeers = { "Athos", "Aramis", "Porthos", "D'Artagnan" }}

Output:

* Athos* Aramis* Porthos* D'Artagnan

If the value of a section variable is a function, it will be called in thecontext of the current item in the list on each iteration.

Template:

{{#beatles}}* {{name}}{{/beatles}}

View:

{  beatles = {    { first_name = "John", last_name = "Lennon" },    { first_name = "Paul", last_name = "McCartney" },    { first_name = "George", last_name = "Harrison" },    { first_name = "Ringo", last_name = "Starr" }  },  name = function (self)    return self.first_name .. " " .. self.last_name  end}

Output:

* John Lennon* Paul McCartney* George Harrison* Ringo Starr

If the value of a section key is a function, it is called with the section'sliteral block of text, un-rendered, as its first argument. The second argumentis a special rendering function that uses the current view as its view argument.

Template:

{{#bold}}Hi {{name}}.{{/bold}}

View:

{  name = "Tater",  bold = function (text, render)      return "<b>" .. render(text) .. "</b>"  end}

Output:

<b>Hi Tater.</b>

An inverted section opens with{{^section}} instead of{{#section}}. Theblock of an inverted section is rendered only if the value of that section's tagisnil,false, or an empty list.

Template:

{{#repos}}<b>{{name}}</b>{{/repos}}{{^repos}}No repos :({{/repos}}

View:

{  repos = {}}

Output:

No repos :(

Comments begin with a bang and are ignored. The following template:

<h1>Today{{! ignore me }}.</h1>

Will render as follows:

<h1>Today.</h1>

Comments may contain newlines.

Partials begin with a greater than sign, like {{> box}}.

Partials are rendered at runtime (as opposed to compile time), so recursivepartials are possible. Just avoid infinite loops.

They also inherit the calling context. Whereas in ERB you may have this:

<%= partial :next_more, :start => start, :size => size %>

Mustache requires only this:

{{> next_more}}

Why? Because thenext_more.mustache file will inherit thesize andstartvariables from the calling context. In this way you may want to think ofpartials as includes, or template expansion, even though it's not literally true.

For example, this template and partial:

base.mustache:<h2>Names</h2>{{#names}}  {{> user}}{{/names}}user.mustache:<strong>{{name}}</strong>

Can be thought of as a single, expanded template:

<h2>Names</h2>{{#names}}  <strong>{{name}}</strong>{{/names}}

In lustache an object of partials may be passed as the third argument tolustache:render. The object should be keyed by the name of the partial, andits value should be the partial text.

Set Delimiter tags start with an equals sign and change the tag delimiters from{{ and}} to custom strings.

Consider the following contrived example:

* {{ default_tags }}{{=<% %>=}}* <% erb_style_tags %><%={{ }}=%>* {{ default_tags_again }}

Here we have a list with three items. The first item uses the default tag style,the second uses ERB style as defined by the Set Delimiter tag, and the thirdreturns to the default style after yet another Set Delimiter declaration.

According toctemplates,this "is useful for languages like TeX, where double-braces may occur in thetext and are awkward to use for markup."

Custom delimiters may not contain whitespace or the equals sign.

lustache uses thelunit testingframework. In order to run the tests you'll need to install lunit, whichcan be done throughluarocks or your choice oflua package manager.

$ luarocks install lunit

Then run the tests.

$ lunit spec/*

lustache began as a direct port ofJan Lehnardt'sexcellentmustache.js. It would besignificantly further behind without the available code from the manycontributors. <3

MIT licensed. View LICENSE file for more details.