# lua-resty-template
**Repository Path**: mirrors_LuaDist/lua-resty-template
## Basic Information
- **Project Name**: lua-resty-template
- **Description**: Templating Engine (HTML) for Lua and OpenResty.
- **Primary Language**: Unknown
- **License**: BSD-3-Clause
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-08-09
- **Last Updated**: 2026-01-10
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
# lua-resty-template
**lua-resty-template** is a compiling (1) (HTML) templating engine for Lua and OpenResty.
(1) with compilation we mean that templates are translated to Lua functions that you may call or `string.dump` as a binary bytecode blobs to disk that can be later utilized with `lua-resty-template` or basic `load` and `loadfile` standard Lua functions (see also [Template Precompilation](#template-precompilation)). Although, generally you don't need to do that as `lua-resty-template` handles this behind the scenes.
## Hello World with lua-resty-template
```lua
local template = require "resty.template"
-- Using template.new
local view = template.new "view.html"
view.message = "Hello, World!"
view:render()
-- Using template.render
template.render("view.html", { message = "Hello, World!" })G
```
##### view.html
```html
{{message}}
```
##### Output
```html
Hello, World!
```
The same can be done with inline template string:
```lua
-- Using template string
template.render([[
{{message}}
]], { message = "Hello, World!" })
```
## Contents
* [Template Syntax](#template-syntax)
* [Reserved Context Keys and Remarks](#reserved-context-keys-and-remarks)
* [Installation](#installation)
* [Using OpenResty Package Manager (opm)](#using-openresty-package-manager-opm)
* [Using LuaRocks or Moonrocks](#using-luarocks-or-moonrocks)
* [Nginx / OpenResty Configuration](#nginx--openresty-configuration)
* [Lua API](#lua-api)
* [template.caching](#boolean-templatecachingboolean-or-nil)
* [template.new](#table-templatenewview-layout)
* [template.compile](#function-boolean-templatecompileview-key)
* [template.render](#templaterenderview-context-key)
* [template.parse](#string-templateparseview)
* [template.precompile](#string-templateprecompileview-path-strip)
* [template.load](#templateload)
* [template.print](#templateprint)
* [Template Precompilation](#template-precompilation)
* [Template Helpers](#template-helpers)
* [Usage Examples](#usage-examples)
* [Template Including](#template-including)
* [Views with Layouts](#views-with-layouts)
* [Using Blocks](#using-blocks)
* [Grandfather-Father-Son Inheritance](#grandfather-father-son-inheritance)
* [Macros](#macros)
* [Calling Methods in Templates](#calling-methods-in-templates)
* [Embedding Angular or other tags / templating inside the Templates](#embedding-angular-or-other-tags--templating-inside-the-templates)
* [Embedding Markdown inside the Templates](#embedding-markdown-inside-the-templates)
* [Lua Server Pages (LSP) with OpenResty](#lua-server-pages-lsp-with-openresty)
* [FAQ](#faq)
* [Alternatives](#alternatives)
* [Benchmarks](#benchmarks)
* [Changes](#changes)
* [License](#license)
## Template Syntax
You may use the following tags in templates:
* `{{expression}}`, writes result of expression - html escaped
* `{*expression*}`, writes result of expression
* `{% lua code %}`, executes Lua code
* `{(template)}`, includes `template` file, you may also supply context for include file `{(file.html, { message = "Hello, World" } )}`
* `{[expression]}`, includes `expression` file (the result of expression), you may also supply context for include file `{["file.html", { message = "Hello, World" } ]}`
* `{-block-}...{-block-}`, wraps inside of a `{-block-}` to a value stored in a `blocks` table with a key `block` (in this case), see [using blocks](https://github.com/bungle/lua-resty-template#using-blocks). Don't use predefined block names `verbatim` and `raw`.
* `{-verbatim-}...{-verbatim-}` and `{-raw-}...{-raw-}` are predefined blocks whose inside is not processed by the `lua-resty-template` but the content is outputted as is.
* `{# comments #}` everything between `{#` and `#}` is considered to be commented out (i.e. not outputted or executed)
From templates you may access everything in `context` table, and everything in `template` table. In templates you can also access `context` and `template` by prefixing keys.
```html
{{message}}
==
{{context.message}}
```
##### Short Escaping Syntax
If you don't want a particular template tag to be processed you may escape the starting tag with backslash `\`:
```html
\{{message}}
```
This will output (instead of evaluating the message):
```html
{{message}}
```
If you want to add backslash char just before template tag, you need to escape that as well:
```html
\\{{message}}
```
This will output:
```html
\[message-variables-content-here]
```
##### A Word About Complex Keys in Context Table
Say you have this kind of a context table:
```lua
local ctx = {["foo:bar"] = "foobar"}
```
And you want to render the `ctx["foo:bar"]`'s value `foobar` in your template. You have to specify it explicitly by referencing the `context` in your template:
```html
{# {*["foo:bar"]*} won't work, you need to use: #}
{*context["foo:bar"]*}
```
Or altogether:
```lua
template.render([[
{*context["foo:bar"]*}
]], {["foo:bar"] = "foobar"})
```
##### A Word About HTML Escaping
Only strings are escaped, functions are called without arguments (recursively) and results are returned as is, other types are `tostring`ified. `nil`s and `ngx.null`s are converted to empty strings `""`.
Escaped HTML characters:
* `&` becomes `&`
* `<` becomes `<`
* `>` becomes `>`
* `"` becomes `"`
* `'` becomes `'`
* `/` becomes `/`
#### Example
##### Lua
```lua
local template = require "resty.template"
template.render("view.html", {
title = "Testing lua-resty-template",
message = "Hello, World!",
names = { "James", "Jack", "Anne" },
jquery = ''
})
```
##### view.html
```html
{(header.html)}
{{message}}
{% for _, name in ipairs(names) do %}
{{name}}
{% end %}
{(footer.html)}
```
##### header.html
```html
{{title}}
{*jquery*}
```
##### footer.html
```html
```
#### Reserved Context Keys and Remarks
It is adviced that you do not use these keys in your context tables:
* `___`, holds the compiled template, if set you need to use `{{context.___}}`
* `context`, holds the current context, if set you need to use `{{context.context}}`
* `include`, holds the include helper function, if set you need to use `{{context.include}}`
* `layout`, holds the layout by which the view will be decorated, if set you need to use `{{context.layout}}`
* `blocks`, holds the blocks, if set you need to use `{{context.blocks}}` (see: [using blocks](#using-blocks))
* `template`, holds the template table, if set you need to use `{{context.template}}`
In addition to that with `template.new` you should not overwrite:
* `render`, the function that renders a view, obviously ;-)
You should also not `{(view.html)}` recursively:
##### Lua
```lua
template.render "view.html"
```
##### view.html
```html
{(view.html)}
```
You can load templates from "sub-directories" as well with `{(syntax)}`:
##### view.html
```html
{(users/list.html)}
```
**Also note that you can provide template either as a file path or as a string. If the file exists, it will be used, otherwise the string is used. See also [`template.load`](#templateload).**
## Installation
Just place [`template.lua`](https://github.com/bungle/lua-resty-template/blob/master/lib/resty/template.lua) and [`template`](https://github.com/bungle/lua-resty-template/tree/master/lib/resty/template) directory somewhere in your `package.path`, under `resty` directory. If you are using OpenResty, the default location would be `/usr/local/openresty/lualib/resty`.
### Using OpenResty Package Manager (opm)
```Shell
$ opm get bungle/lua-resty-template
```
### Using LuaRocks
```Shell
$ luarocks install lua-resty-template
```
LuaRocks repository for `lua-resty-template` is located at https://luarocks.org/modules/bungle/lua-resty-template.
## Nginx / OpenResty Configuration
When `lua-resty-template` is used in context of Nginx / OpenResty there are a few configuration directives that you need to be aware:
* `template_root` (`set $template_root /var/www/site/templates`)
* `template_location` (`set $template_location /templates`)
If none of these are set in Nginx configuration, `ngx.var.document_root` (aka root-directive) value is used. If `template_location` is set, it will be used first, and if the location returns anything but `200` as a status code, we do fallback to either `template_root` (if defined) or `document_root`.
##### Using `document_root`
This one tries to load file content with Lua code from `html` directory (relative to Nginx prefix).
```nginx
http {
server {
location / {
root html;
content_by_lua '
local template = require "resty.template"
template.render("view.html", { message = "Hello, World!" })
';
}
}
}
```
##### Using `template_root`
This one tries to load file content with Lua code from `/usr/local/openresty/nginx/html/templates` directory.
```nginx
http {
server {
set $template_root /usr/local/openresty/nginx/html/templates;
location / {
root html;
content_by_lua '
local template = require "resty.template"
template.render("view.html", { message = "Hello, World!" })
';
}
}
}
```
##### Using `template_location`
This one tries to load content with `ngx.location.capture` from `/templates` location (in this case this is served with `ngx_static` module).
```nginx
http {
server {
set $template_location /templates;
location / {
root html;
content_by_lua '
local template = require "resty.template"
template.render("view.html", { message = "Hello, World!" })
';
}
location /templates {
internal;
alias html/templates/;
}
}
}
```
**See also [`template.load`](#templateload).**
## Lua API
#### boolean template.caching(boolean or nil)
This function enables or disables template caching, or if no parameters are passed, returns current state of template caching. By default template caching is enabled, but you may want to disable it on development or low-memory situations.
```lua
local template = require "resty.template"
-- Get current state of template caching
local enabled = template.caching()
-- Disable template caching
template.caching(false)
-- Enable template caching
template.caching(true)
```
Please note that if the template was already cached when compiling a template, the cached version will be returned. You may want to flush cache with `template.cache = {}` to ensure that your template really gets recompiled.
#### table template.new(view, layout)
Creates a new template instance that is used as a (default) context when `render`ed. A table that gets created has
only one method `render`, but the table also has metatable with `__tostring` defined. See the example below. Both
`view` and `layout` arguments can either be strings or file paths, but layout can also be a table created previously
with `template.new`.
```lua
local view = template.new"template.html" -- or
local view = template.new("view.html", "layout.html") -- or
local view = template.new[[
{{message}}
]] -- or
local view = template.new([[
{{message}}
]], [[
{*view*}
]])
```
##### Example
```lua
local template = require "resty.template"
local view = template.new"view.html"
view.message = "Hello, World!"
view:render()
-- You may also replace context on render
view:render{ title = "Testing lua-resty-template" }
-- If you want to include view context in replacement context
view:render(setmetatable({ title = "Testing lua-resty-template" }, { __index = view }))
-- To get rendered template as a string, you can use tostring
local result = tostring(view)
```
#### function, boolean template.compile(view, key, plain)
Parses, compiles and caches (if caching is enabled) a template and returns the compiled template as a function that takes context as a parameter and returns rendered template as a string. Optionally you may pass `key` that is used as a cache key. If cache key is not provided `view` wil be used as a cache key. If cache key is `no-cache` the template cache will not be checked and the resulting function will not be cached. You may also optionally pass `plain` with a value of `true` if the `view` is plain text string (this will skip `template.load` and binary chunk detection in `template.parse` phase).
```lua
local func = template.compile("template.html") -- or
local func = template.compile([[
{{message}}
]])
```
##### Example
```lua
local template = require "resty.template"
local func = template.compile("view.html")
local world = func{ message = "Hello, World!" }
local universe = func{ message = "Hello, Universe!" }
print(world, universe)
```
Also note the second return value which is a boolean. You may discard it, or use it to determine if the returned function was cached.
#### template.render(view, context, key, plain)
Parses, compiles, caches (if caching is enabled) and outputs template either with `ngx.print` if available, or `print`. You may optionally also pass `key` that is used as a cache key. If `plain` evaluates to `true`, the `view` is considered to be plain string template (`template.load` and binary chunk detection is skipped on `template.parse`).
```lua
template.render("template.html", { message = "Hello, World!" }) -- or
template.render([[
{{message}}
]], { message = "Hello, World!" })
```
##### Example
```lua
local template = require "resty.template"
template.render("view.html", { message = "Hello, World!" })
template.render("view.html", { message = "Hello, Universe!" })
```
#### string template.parse(view, plain)
Parses template file or string, and generates a parsed template string. This may come useful when debugging templates. You should note that if you are trying to parse a binary chunk (e.g. one returned with `template.compile`), `template.parse` will return that binary chunk as is. If optional parameter `plain` evaluates to `true`, the `view` is considered to be plain string, and the `template.load` and binary chunk detection is skipped.
```lua
local t1 = template.parse("template.html")
local t2 = template.parse([[
{{message}}
]])
```
#### string template.precompile(view, path, strip)
Precompiles template as a binary chunk. This binary chunk can be written out as a file (and you may use it directly with Lua's `load` and `loadfile`). For convenience you may optionally specify `path` argument to output binary chunk to file. You may also supply `strip` parameter with value of `false` to make precompiled templates to have debug information as well (defaults to `true`).
```lua
local view = [[
{{title}}
{% for _, v in ipairs(context) do %}
{{v}}
{% end %}
]]
local compiled = template.precompile(view)
local file = io.open("precompiled-bin.html", "wb")
file:write(compiled)
file:close()
-- Alternatively you could just write (which does the same thing as above)
template.precompile(view, "precompiled-bin.html")
template.render("precompiled-bin.html", {
title = "Names",
"Emma", "James", "Nicholas", "Mary"
})
```
#### template.load
This field is used to load templates. `template.parse` calls this function before it starts parsing the template (assuming that optional `plain` argument in `template.parse` evaluates false (the default). By default there are two loaders in `lua-resty-template`: one for Lua and the other for Nginx / OpenResty. Users can overwrite this field with their own function. For example you may want to write a template loader function that loads templates from a database.
Default `template.load` for Lua (attached as template.load when used directly with Lua):
```lua
local function load_lua(path)
-- read_file tries to open file from path, and return its content.
return read_file(path) or path
end
```
Default `template.load` for Nginx / OpenResty (attached as template.load when used in context of Nginx / OpenResty):
```lua
local function load_ngx(path)
local file, location = path, ngx.var.template_location
if file:sub(1) == "/" then file = file:sub(2) end
if location and location ~= "" then
if location:sub(-1) == "/" then location = location:sub(1, -2) end
local res = ngx.location.capture(location .. '/' .. file)
if res.status == 200 then return res.body end
end
local root = ngx.var.template_root or ngx.var.document_root
if root:sub(-1) == "/" then root = root:sub(1, -2) end
-- read_file tries to open file from path, and return its content.
return read_file(root .. "/" .. file) or path
end
```
As you can see, `lua-resty-template` always tries (by default) to load a template from a file (or with `ngx.location.capture`) even if you provided template as a string. `lua-resty-template`. But if you know that your templates are always strings, and not file paths, you may use `plain` argument in `template.compile`, `template.render`, and `template.parse` OR replace `template.load` with the simplest possible template loader there is (but be aware that if your templates use `{(file.html)}` includes, those are considered as strings too, in this case `file.html` will be the template string that is parsed) - you could also setup a loader that finds templates in some database system, e.g. Redis:
```lua
local template = require "resty.template"
template.load = function(s) return s end
```
#### template.print
This field contains a function that is used on `template.render()` or `template.new("example.html"):render()` to output the results. By default this holds either `ngx.print` (if available) or `print`. You may want to (and are allowed to) overwrite this field, if you want to use your own output function instead. This is also useful if you are using some other framework, e.g. Turbo.lua (http://turbolua.org/).
```lua
local template = require "resty.template"
template.print = function(s)
print(s)
print("")
end
```
## Template Precompilation
`lua-resty-template` supports template precompilation. This can be useful when you want to skip template parsing (and Lua interpretation) in production or if you do not want your templates distributed as plain text files on production servers. Also by precompiling, you can ensure that your templates do not contain something, that cannot be compiled (they are syntactically valid Lua). Although templates are cached (even without precompilation), there are some perfomance (and memory) gains. You could integrate template precompilation in your build (or deployment) scripts (maybe as Gulp, Grunt or Ant tasks).
##### Precompiling template, and output it as a binary file
```lua
local template = require "resty.template"
local compiled = template.precompile("example.html", "example-bin.html")
```
##### Load precompiled template file, and run it with context parameters
```lua
local template = require "resty.template"
template.render("example-bin.html", { "Jack", "Mary" })
```
## Template Helpers
While `lua-resty-template` does not have much infrastucture or ways to extend it, you still have a few possibilities that you may try.
* Adding methods to global `string`, and `table` types (not encouraged, though)
* Wrap your values with something before adding them in context (e.g. proxy-table)
* Create global functions
* Add local functions either to `template` table or `context` table
* Use metamethods in your tables
While modifying global types seems convenient, it can have nasty side effects. That's why I suggest you to look at these libraries, and articles first:
* Method Chaining Wrapper (http://lua-users.org/wiki/MethodChainingWrapper)
* Moses (https://github.com/Yonaba/Moses)
* underscore-lua (https://github.com/jtarchie/underscore-lua)
You could for example add Moses' or Underscore's `_` to template table or context table.
##### Example
```lua
local _ = require "moses"
local template = require "resty.template"
template._ = _
```
Then you can use `_` inside your templates. I created one example template helper that can be found from here:
https://github.com/bungle/lua-resty-template/blob/master/lib/resty/template/html.lua
##### Lua
```lua
local template = require "resty.template"
local html = require "resty.template.html"
template.render([[
{% for _, person in ipairs(context) do %}
{*html.li(person.name)*}
{% end %}
{% for _, person in ipairs(context) do %}
{*html.td{ id = person.id }(person.name)*}
{% end %}
]], {
{ id = 1, name = "Emma"},
{ id = 2, name = "James" },
{ id = 3, name = "Nicholas" },
{ id = 4 }
})
```
##### Output
```html
Emma
James
Nicholas
Emma
James
Nicholas
```
## Usage Examples
### Template Including
You may include templates inside templates with `{(template)}` and `{(template, context)}` syntax. The first one uses the current context as a context for included template, and the second one replaces it with a new context. Here is example of using includes and passing a different context to include file:
##### Lua
```lua
local template = require "resty.template"
template.render("include.html", { users = {
{ name = "Jane", age = 29 },
{ name = "John", age = 25 }
}})
```
##### include.html
```html
{% for _, user in ipairs(users) do %}
{(user.html, user)}
{% end %}
```
##### user.html
```html
User {{name}} is of age {{age}}
```
##### Outut
```html
User Jane is of age 29
User John is of age 25
```
### Views with Layouts
Layouts (or Master Pages) can be used to wrap a view inside another view (aka layout).
##### Lua
```lua
local template = require "resty.template"
local layout = template.new "layout.html"
layout.title = "Testing lua-resty-template"
layout.view = template.compile "view.html" { message = "Hello, World!" }
layout:render()
-- Or like this
template.render("layout.html", {
title = "Testing lua-resty-template",
view = template.compile "view.html" { message = "Hello, World!" }
})
-- Or maybe you like this style more
-- (but please remember that context.view is overwritten on rendering the layout.html)
local view = template.new("view.html", "layout.html")
view.title = "Testing lua-resty-template"
view.message = "Hello, World!"
view:render()
-- Well, maybe like this then?
local layout = template.new "layout.html"
layout.title = "Testing lua-resty-template"
local view = template.new("view.html", layout)
view.message = "Hello, World!"
view:render()
```
##### view.html
```html
{{message}}
```
##### layout.html
```html
{{title}}
{*view*}
```
##### Alternatively you can define the layout in a view as well:
##### Lua
```lua
local view = template.new("view.html", "layout.html")
view.title = "Testing lua-resty-template"
view.message = "Hello, World!"
view:render()
```
##### view.html
```html
{% layout="section.html" %}
```
### Using Blocks
Blocks can be used to move different parts of the views to specific places in layouts. Layouts have placeholders for blocks.
##### Lua
```lua
local view = template.new("view.html", "layout.html")
view.title = "Testing lua-resty-template blocks"
view.message = "Hello, World!"
view.keywords = { "test", "lua", "template", "blocks" }
view:render()
```
##### view.html
```html
{{message}}
{-aside-}
{% for _, keyword in ipairs(keywords) do %}
{{keyword}}
{% end %}
{-aside-}
```
##### layout.html
```html
{*title*}
{*view*}
{% if blocks.aside then %}
{% end %}
```
##### Output
```html
Testing lua-resty-template blocks
Hello, World!
```
### Grandfather-Father-Son Inheritance
Say you have `base.html`, `layout1.html`, `layout2.html` and `page.html`. You want an inheritance like this:
`base.html ➡ layout1.html ➡ page.html` or `base.html ➡ layout2.html ➡ page.html` (actually this nesting is not limited to three levels).
##### Lua
```lua
local res = require"resty.template".compile("page.html"){}
```
##### base.html
```html
{* blocks.page_css *}
{* blocks.main *}
{* blocks.page_js *}
```
##### layout1.html
```html
{% layout = "base.html" %}
{-main-}
{-main-}
```
##### page.html
```html
{% layout = "layout1.html" %}
{-sidebar-}
this is sidebar
{-sidebar-}
{-content-}
this is content
{-content-}
{-page_css-}
{-page_css-}
{-page_js-}
{-page_js-}
```
Or:
##### page.html
```html
{% layout = "layout2.html" %}
{-sidebar-}
this is sidebar
{-sidebar-}
{-content-}
this is content
{-content-}
{-page_css-}
{-page_css-}
{-page_js-}
{-page_js-}
```
### Macros
[@DDarko](https://github.com/DDarko) mentioned in an [issue #5](https://github.com/bungle/lua-resty-template/issues/5) that he has a use case where he needs to have macros or parameterized views. That is a nice feature that you can use with `lua-resty-template`.
To use macros, let's first define some Lua code:
```lua
template.render("macro.html", {
item = "original",
items = { a = "original-a", b = "original-b" }
})
```
And the `macro-example.html`:
```lua
{% local string_macro = [[
{{item}}
]] %}
{* template.compile(string_macro)(context) *}
{* template.compile(string_macro){ item = "string-macro-context" } *}
```
This will output:
```html
original
string-macro-context
```
Now let's add function macro, in `macro-example.html` (you can omit `local` if you want):
```lua
{% local function_macro = function(var, el)
el = el or "div"
return "<" .. el .. ">{{" .. var .. "}}\n"
end %}
{* template.compile(function_macro("item"))(context) *}
{* template.compile(function_macro("a", "span"))(items) *}
```
This will output:
```html
original
original-a
```
But this is even more flexible, let's try another function macro:
```lua
{% local function function_macro2(var)
return template.compile("
{{" .. var .. "}}
\n")
end %}
{* function_macro2 "item" (context) *}
{* function_macro2 "b" (items) *}
```
This will output:
```html
original
original-b
```
And here is another one:
```lua
{% function function_macro3(var, ctx)
return template.compile("
{{" .. var .. "}}
\n")(ctx or context)
end %}
{* function_macro3("item") *}
{* function_macro3("a", items) *}
{* function_macro3("b", items) *}
{* function_macro3("b", { b = "b-from-new-context" }) *}
```
This will output:
```html
original
original-a
original-b
b-from-new-context
```
Macros are really flexible. You may have form-renderers and other helper-macros to have a reusable and parameterized template output. One thing you should know is that inside code blocks (between `{%` and `%}`) you cannot have `%}`, but you can work around this using string concatenation `"%" .. "}"`.
### Calling Methods in Templates
You can call string methods (or other table functions) in templates too.
##### Lua
```lua
local template = require "resty.template"
template.render([[
```
### Embedding Angular or other tags / templating inside the Templates
Sometimes you need to mix and match other templates (say client side Javascript templates like Angular) with
server side lua-resty-templates. Say you have this kind of Angular template:
```html