No-template: Difference between revisions

From unkrig.de
Jump to navigation Jump to search
Line 36: Line 36:
     // It is good practice to declare a method "render()" with
     // It is good practice to declare a method "render()" with
     // exactly the parameters of the document to be rendered.
     // exactly the parameters of the document to be rendered.
 
     public void
     public void
     render(String firstName, String lastName, int age) {
     render(String firstName, String lastName, int age) {
Line 59: Line 59:


  // Demonstrate how to render a document with this template:
  // Demonstrate how to render a document with this template:
  NoTemplate.render(MyTemplate.class, new File("JohnDoe99.html"), (MyTemplate t) -> {
  NoTemplate.render(
    t.render("John", "Doe", 99);
    MyTemplate.class,
  });
    new File("JohnDoe99.html"),
    (MyTemplate t) -> {
        t.render("John", "Doe", 99);
    }
  );


== Resources ==
== Resources ==

Revision as of 14:09, 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.