vphantom / node-jstc Goto Github PK

While we have coverage, we aren't robustly testing the potential contents of templates and how mistakes are handled.

We should also make cli.js exit non-zero when some templates failed at compile-time.

We need to read files asynchronously in order to play nice with server environments.

Our caller lists all files for us. Instead, and backwards-compatibly, we should treat each file as a glob to allow something like:

jstc 'templates/*.jst' 'plugins/*/templates/*.jst'

The difference for the command-line tool is negligible, but it will allow server use down the line.

A server would initialize with something like:

var render = {};
jstc.getObject(
  ['templates/*.jst','plugins/*/templates/*.jst'],
  function(err, newRender) {
    if (!err) {
      render = newRender;
    };
});

This allows long-running processes to recompile templates at any time, with the option to keep the in-memory version if something goes wrong.

Without promises/coroutines, this makes it difficult to block code that needs render to be populated to function properly, in the initial compilation. I guess a server would outright fail to start on an initial compilation error, and complete its startup inside the callback?

It would be nice if, in addition to it, templates had a shortcut to access a variety of utility functions, most provided by users and not by jstc itself, such as HTML encoding (which was handled as a special case in doT.js).

We should use this as a reference to render._lib which could contain misc constants and functions.

doT.js calls these "partials". This is a special syntax for creating several templates within a single file. To achieve this cleanly, we should introduce a pre-processor ahead of jstc.compile() and implement a first pair of directives define and end:

<p>content...</p>
<%@define foo %>
<p>Sub-template! Name is: <%= its.name %></p>
<%@end %>
<p>And here, content refers to it locally:</p>
<%= foo({name: 'first'}) %>
<%= foo({name: 'second'}) %>

This should be structured so that foo() is private to the template (and sibling sub-templates).

The pre-processor, in this case, would:

• Gather sub-templates while removing them entirely from the source string;
• Invoke the compiler for each gathered sub-template, in which case the argument becomes its;
• Invoke the compiler on the main source string and inject the sub-template functions after vars and before statements.