express-dot-engine


> Node.js engine using the ultra fast doT templating with support for layouts, partials. It's friendly for front-end web libraries (Angular, Ember, Backbone...)

Important

The default settings of doT has been change to use [[ ]] instead of {{ }}. This is to support client side templates (Angular, Ember, ...). You can change it back by changing the Settings (see below).

Features

- extremely fast (see jsperf)
- all the advantage of doT
- layout and partial support
- uses [[ ]] by default, not clashing with {{ }} (Angular, Ember...)
- custom helpers to your views
- conditional, array iterators, custom delimiters...
- use it as logic-less or with logic, it is up to you
- use it also for your email (or anything) templates
- automatic caching in production

$3

- √ Purists that wants html as their templates but with full access to javascript
- √ Minimum server-side logic, passing server models to client-side frameworks like Angular, Ember, Backbone...
- √ Clean and fast templating with support for layouts and partials
- √ Email templating

$3

- Jade style lovers (http://jade-lang.com/)
- Full blown templating with everything already coded for you (you can however provide any custom functions to your views)

Installation

Install with npm

``sh
$ npm install express-dot-engine --save
`

Then set the engine in express

`javascript
var engine = require('express-dot-engine');
...

app.engine('dot', engine.__express);
app.set('views', path.join(__dirname, './views'));
app.set('view engine', 'dot');
`

To use a different extension for your templates, for example to get better syntax highlighting in your IDE, replace 'dot' with your extension of choice. See express' documentation
`javascript
app.engine('html', engine.__express);
app.set('views', path.join(__dirname, './views'));
app.set('view engine', 'html');
`

Settings

By default, the engine uses [[ ]] instead of {{ }} on the backend. This allows the use of front-end templating libraries that already use {{ }}.

`
[[ ]] for evaluation
[[= ]] for interpolation
[[! ]] for interpolation with encoding
[[# ]] for compile-time evaluation/includes and partials
[[## #]] for compile-time defines
[[? ]] for conditionals
[[~ ]] for array iteration
`

If you want to configure this you can change the exposed doT settings.

`javascript
// doT settings
engine.settings.dot = {
evaluate: /\[\[([\s\S]+?)\]\]/g,
interpolate: /\[\[=([\s\S]+?)\]\]/g,
encode: /\[\[!([\s\S]+?)\]\]/g,
use: /\[\[#([\s\S]+?)\]\]/g,
define: /\[\[##\s([\w\.$]+)\s(\:|=)([\s\S]+?)#\]\]/g,
conditional: /\[\[\?(\?)?\s([\s\S]?)\s*\]\]/g,
iterate: /\[\[~\s(?:\]\]|([\s\S]+?)\s\:\s([\w$]+)\s(?:\:\s([\w$]+))?\s\]\])/g,
varname: 'layout, partial, locals, model',
strip: false,
append: true,
selfcontained: false,
};
`

Layout

You can specify the layout using yaml and refer to the section as you would from a model.

You can also define any extra configurations (like a page title) that are inherited to the master.

$3

master.dot

`html






Hello from master.dot

[[= layout.section1 ]]

[[= layout.section2 ]]


`

index.dot
`html
---
layout: master.dot
title: Index page
---

[[##section1:
Hello from index.dot
#]]

[[##section2:
Hello from index.dot again
#]]
`

#### Result
`html






Hello from master.dot

Hello from index.dot

Hello from index.dot again


`

$3

CEO.dot

`html






Hello from CEO.dot

[[= layout.section ]]


`

Boss.dot

`html
---
layout: ceo.dot
---

[[##section:
Hello from Boss.dot

[[= layout.section ]]
#]]
`

me.dot

`html
---
layout: boss.dot
title: Page title
---

[[##section:
Hello from me.dot
#]]
`

#### Result
`html






Hello from CEO.dot

Hello from Boss.dot

Hello from me.dot


`

Partials

Partials are supported. The path is relative to the path of the current file.

index.dot

`html



`

partials/hello.dot

`html
Hello from partial
`

$3

`html



`

Server model

In your node application, the model passed to the engine will be available through [[= model. ]] in your template. Layouts and Partials also has access to the server models.

server.js
`javascript
app.get('/', function(req, res){
res.render('index', { fromServer: 'Hello from server', });
});
`

view.dot
`html



`

$3

`html



`

> Pro tip

If you want to make the whole model available in the client (to use in angular for example), you can render the model as JSON in a variable on the view.

`html

`

Helper

You can provide custom helper properties or methods to your views.

server

`javascript
var engine = require('express-dot-engine');

engine.helper.myHelperProperty = 'Hello from server property helper';

engine.helper.myHelperMethod = function(param) {

// you have access to the server model
var message = this.model.fromServer;

// .. any logic you want
return 'Server model: ' + message;
}

...

app.get('/', function(req, res) {
res.render('helper/index', { fromServer: 'Hello from server', });
});

`

view

`html







model: [[= model.fromServer ]]

helper property: [[# def.myHelperProperty ]]

helper method: [[# def.myHelperMethod('Hello as a parameter') ]]

helper in view: [[# def.helperInView ]]




[[##def.helperInView:
Hello from view helper ([[= model.fromServer ]])
#]]

`

Templating for email (or anything)

- render(filename, model, [callback])
- renderString(templateStr, model, [callback])

The callback is optional. The callback is in node style function(err, result) {}

Example
`javascript
var engine = require('express-dot-engine');
var model = { message: 'Hello', };

// render from a file
var rendered = engine.render('path/to/file', model);
email.send('Subject', rendered);

// async render from template string
engine.renderString(
'

',
model,
function(err, rendered) {
email.send('Subject', rendered);
}
);

...
`

Custom template provider

You can provide a custom template provider

server

`javascript

function getTemplate(name, options, callback) {
var isAsync = callback && typeof callback === 'function',
template = '

';
if(!isAsync){
return template;
}
callback(null, template);
};

app.get('/', function(req, res) {
res.render('helper/index', { getTemplate: getTemplate, });
});

`

Caching

Caching is enabled when express is running in production via the 'view cache' variable in express. This is done automatically. If you want to enable cache in development, you can add this

`javascript
app.set('view cache', true);
`

How to run the examples

$3

`sh
$ npm install express-dot-engine
`

$3

`sh
$ npm install express
`

$3

`sh
$ node examples
`

Open your browser to http://localhost:2015`

Roadmap

- Html minification in prod
- Automatically remove server-side comments

License

MIT