Home

Awesome

[!IMPORTANT] Starting from 0.9.1.0 the Jsoup transitive dependency removed

Liqp   Build Status Maven Central Branches

A Java implementation of the Liquid templating engine backed up by an ANTLR grammar.

Installation

Gradle

Add the dependency:

dependencies {
  compile 'nl.big-o:liqp:0.9.1.1'
}

Maven

Add the following dependency:

<dependency>
  <groupId>nl.big-o</groupId>
  <artifactId>liqp</artifactId>
  <version>0.9.1.1</version>
</dependency>

Or clone this repository and run: mvn install which will create a JAR of Liqp in your local Maven repository, as well as in the project's target/ folder.

Usage

This library can be used in two different ways:

  1. to construct a parse tree of some Liquid input
  2. to render Liquid input source (either files, or input strings)

1. Creating a parse tree

To create a parse tree from input source, do the following:

String input =
        "<ul id=\"products\">                                               \n" +
                "  {% for product in products %}                            \n" +
                "    <li>                                                   \n" +
                "      <h2>{{ product.name }}</h2>                          \n" +
                "      Only {{ product.price | price }}                     \n" +
                "                                                           \n" +
                "      {{ product.description | prettyprint | paragraph }}  \n" +
                "    </li>                                                  \n" +
                "  {% endfor %}                                             \n" +
                "</ul>                                                      \n";
Template template = TemplateParser.DEFAULT.parse(input);

ParseTree root = template.getParseTree();

As you can see, the getParseTree() method returns an instance of a ParseTree denoting the root node of the input source. To see how the parse tree is built, you can use Template#toStringAST() to print an ASCII representation of the tree.

2. Render Liquid

If you're not familiar with Liquid, have a look at their website: http://liquidmarkup.org.

In Ruby, you'd render a template like this:

@template = Liquid::Template.parse("hi {{name}}")  # Parses and compiles the template
@template.render( 'name' => 'tobi' )               # Renders the output => "hi tobi"

With Liqp, the equivalent looks like this:

TemplateParser parser = new TemplateParser.Builder().build();
Template template = parser.parse("hi {{name}}");
String rendered = template.render("name", "tobi");
System.out.println(rendered);
/*
    hi tobi
*/

The template variables provided as parameters to render(...) can be:

The following examples are equivalent to the previous Liqp example:

Map example

Template template = new TemplateParser.Builder().build().parse("hi {{name}}");
Map<String, Object> map = new HashMap<>();
map.put("name", "tobi");
String rendered = template.render(map);
System.out.println(rendered);
/*
    hi tobi
*/

JSON example

Template template = new TemplateParser.Builder().build().parse("hi {{name}}");
String rendered = template.render("{\"name\" : \"tobi\"}");
System.out.println(rendered);
/*
    hi tobi
*/

Inspectable example

class MyParams implements Inspectable {
    public String name = "tobi";
};
Template template = TemplateParser.DEFAULT.parse("hi {{name}}");
String rendered = template.render(new MyParams());
System.out.println(rendered);
/*
    hi tobi
*/

LiquidSupport example

class MyLazy implements LiquidSupport {
    @Override
    public Map<String, Object> toLiquid() {
        return Collections.singletonMap("name", "tobi");
    }
};
Template template = TemplateParser.DEFAULT.parse("hi {{name}}");
String rendered = template.render(new MyLazy());
System.out.println(rendered);
/*
    hi tobi
*/

Controlling library behavior

The library has a set of keys to control the parsing/rendering process. Even if you might think that's too many of them, the defaults will work for you in most cases. All of them are set on TemplateParser.Builder class. Here they are:

2.1 Custom filters

Let's say you want to create a custom filter, called b, that changes a string like *text* to <strong>text</strong>.

You can do that as follows:

 // first create template parser with new filter
TemplateParser parser = new TemplateParser.Builder().withFilter(new Filter("b") {
    @Override
    public Object apply(Object value, TemplateContext context, Object... params) {
        // create a string from the value
        String text = super.asString(value, context);

        // replace and return *...* with <strong>...</strong>
        return text.replaceAll("\\*(\\w(.*?\\w)?)\\*", "<strong>$1</strong>");
    }
}).build();

// use your filter
Template template = parser.parse("{{ wiki | b }}");
String rendered = template.render("{\"wiki\" : \"Some *bold* text *in here*.\"}");
System.out.println(rendered);
/*
    Some <strong>bold</strong> text <strong>in here</strong>.
*/

And to use an optional parameter in your filter, do something like this:

// first create template parser with your filter
TemplateParser parser = new TemplateParser.Builder().withFilter(new Filter("repeat"){
    @Override
    public Object apply(Object value, TemplateContext context, Object... params) {
        // get the text of the value
        String text = super.asString(value, context);

        // check if an optional parameter is provided
        int times = params.length == 0 ? 1 : super.asNumber(params[0]).intValue();

        StringBuilder builder = new StringBuilder();

        while(times-- > 0) {
            builder.append(text);
        }

        return builder.toString();
    }
}).build();

// use your filter
Template template = parser.parse("{{ 'a' | repeat }}\n{{ 'b' | repeat:5 }}");
String rendered = template.render();
System.out.println(rendered);
/*
a
bbbbb
*/

You can use an array (or list) as well, and can also return a numerical value:

TemplateParser parser = new TemplateParser.Builder().withFilter((new Filter("sum"){
    @Override
    public Object apply(Object value, TemplateContext context, Object... params) {

        Object[] numbers = super.asArray(value, context);

        double sum = 0;

        for(Object obj : numbers) {
            sum += super.asNumber(obj).doubleValue();
        }

        return sum;
    }
})).build();

Template template = parser.parse("{{ numbers | sum }}");
String rendered = template.render("{\"numbers\" : [1, 2, 3, 4, 5]}");
System.out.println(rendered);
/*
    15.0
*/

In short, override one of the apply() methods of the Filter class to create your own custom filter behavior.

2.2 Tags and blocks

Both blocks and tags are kinds of insertions. Literally: Block extends Insertion and Tag extends Insertion. Class Insertion used as basic abstraction for parser. Below is defined the difference between tags and blocks.

Tags

Tag is a simple insertion in the template that will be processed and the result of it will be replaced in output, if any. Example is include tag:

See these data: {% include data.liquid %}

Another example is assign tag:

{% assign name='Joe' %}
Hello {{name}}!

It has no input but still is an insertion.

Blocks

Block is a kind of insertions that wraps some text and/or other blocks or tags and performs some operations on the given input. Blocks have opening and closing tags. Example of block is if:

{% if user %} Hello {{ user.name }} {% endif %}"

where {% if user %} is opening tag and {% endif %} is closing one. The user in this sample is just a parameter for given block.

Custom Tags and Blocks

Let's say you would like to create a block that makes it easy to loop for a fixed number of times executing a block of Liquid code.

Here's a way to create, and use, such a custom loop block:

TemplateParser parser = new TemplateParser.Builder().withBlock(new Block("loop"){
    @Override
    public Object render(TemplateContext context, LNode... nodes) {
        int n = super.asNumber(nodes[0].render(context)).intValue();
        LNode block = nodes[1];
        StringBuilder builder = new StringBuilder();
        while(n-- > 0) {
            builder.append(super.asString(block.render(context), context));
        }
        return builder.toString();
    }
}).build();

Template template = parser.parse("{% loop 5 %}looping!\n{% endloop %}");
String rendered = template.render();
System.out.println(rendered);
/*
    looping!
    looping!
    looping!
    looping!
    looping!
*/

For registering custom Tags there exists equivalent Builder.withTag function.

Build and Release

Use Maven 3.5.0 and run build with

mvn clean install

Release process into the Central Repository is performed with

 mvn release:clean release:prepare release:perform -P ossrh-release

Make sure having in ~/.m2/settings.xml this config(with your values):

<settings>
<servers>
  <server>
    <id>ossrh</id>
    <username>MY_OSSRH_USERNAME</username>
    <password>MY_OSSRH_PASSWORD</password>
  </server>
</servers>
  <profiles>
    <profile>
      <id>ossrh-release</id>
      <activation>
        <activeByDefault>false</activeByDefault>
      </activation>
      <properties>
        <gpg.executable>gpg2</gpg.executable>
        <gpg.passphrase>GPG_PRIVATE_KEY_PASSWORD</gpg.passphrase>
      </properties>
    </profile>
  </profiles>
</settings>

After executing this go to https://oss.sonatype.org/index.html#stagingRepositories, ensure all is OK, after you can "Close" the staging for promoting to the realease and after do "Release".