No-template: Difference between revisions
Jump to navigation
Jump to search
mNo edit summary |
|||
| Line 12: | Line 12: | ||
* If the templating engine involves some kind of an "translation" step, then that must be executed on each and every code change - at worst manually. | * If the templating engine involves some kind of an "translation" step, then that must be executed on each and every code change - at worst manually. | ||
The approach of <code>no-template</code> is as simple as it could be: | == Solution == | ||
The approach of <code>no-template</code> is as simple as it could be: Write the templates in plain Java! Static context maps to string literals; variables, control structures and in-source documentation map to the respective Java constructs. | |||
The no-template framework basically consists of a single method | |||
public static final <T extends NoTemplate, EX extends Exception> void | |||
NoTemplate.render(final Class<T> templateClass, File outputFile, final ConsumerWhichThrows<? super T, EX> renderer); | |||
That method creates the ''outputFile'', instantiates the ''templateClass'', and eventually calls the ''renderer''. The latter typically generates the output by calling the <code>l(String...)</code> and <code>p(String)</code> methods. | |||
Done! | |||
== Code Example == | |||
package com.acme.notemplatedemo; | package com.acme.notemplatedemo; | ||
| Line 42: | Line 55: | ||
"</html>" | "</html>" | ||
); | ); | ||
} | } | ||
} | } | ||
// Demonstrate how to render a document with this template: | |||
NoTemplate.render(MyTemplate.class, new File("JohnDoe99.html"), (MyTemplate t) -> { | |||
t.render("John", "Doe", 99); | |||
}); | |||
== Resources == | == Resources == | ||
Revision as of 13:33, 2 June 2016
A super-small Java library for templating, i.e. generating text files (HTML, XML, whatever) from a "template" text file.
Background
Working with the common templating frameworks (Freemarker, JSP, PHP, ...), you probably agree on the following inconveniences and problems:
- Each framework has its own syntax and semantics for implementing the dynamic part of a document (variables, control structures, in-source documentation, ...).
- Because the nesting of control structures and the indentation of the static content are generally not identical, it is very hard to write easily-readable code.
- Most templating frameworks have no static typing, i.e. you must always be careful when using (or worse: re-using) variables, because there is no "compile-time checking" of types.
- Powerful debuggers are not available in many cases, so you typcially revert to looking at log files.
- Because there are so many different templating engines, you favorite IDE possibly offers no advanced editor with code completion, refactoring, and the like.
- If the templating engine involves some kind of an "translation" step, then that must be executed on each and every code change - at worst manually.
Solution
The approach of no-template is as simple as it could be: Write the templates in plain Java! Static context maps to string literals; variables, control structures and in-source documentation map to the respective Java constructs.
The no-template framework basically consists of a single method
public static final <T extends NoTemplate, EX extends Exception> void NoTemplate.render(final Class<T> templateClass, File outputFile, final ConsumerWhichThrows<? super T, EX> renderer);
That method creates the outputFile, instantiates the templateClass, and eventually calls the renderer. The latter typically generates the output by calling the l(String...) and p(String) methods.
Done!
Code Example
package com.acme.notemplatedemo;
import de.unkrig.notemplate.*;
public
class MyTemplate extends NoTemplate {
// It is good practice to declare a method "render()" with
// exactly the parameters of the document to be rendered.
public void
render(String firstName, String lastName, int age) {
// Method "l(String...)" prints its arguments as lines.
this.l(
"<!DOCTYPE html>",
"",
" ",
" My first template ",
" ",
" ",
" This is my very first template.",
" <br />",
" Hello " + firstName + " " + lastName + ",",
" you must be " + age + " years old!",
" ",
""
);
}
}
// Demonstrate how to render a document with this template:
NoTemplate.render(MyTemplate.class, new File("JohnDoe99.html"), (MyTemplate t) -> {
t.render("John", "Doe", 99);
});
Resources
Find the binaries here.
Find the source code here.
Find the JAVADOC here.
Licensing
No-template is distributed under the New BSD license.