Java-based template engine based on django template syntax, adapted to render jinja templates (at least the subset of jinja in use in HubSpot content). Currently used in production to render thousands of websites with hundreds of millions of page views per month on the [HubSpot COS](http://www.hubspot.com/products/sites).
*Note*: Requires Java >= 8. Originally forked from [jangod](https://code.google.com/p/jangod/).
Get it:
-------
```xml
* Jinjava jinjava = new Jinjava();
* Map<String, Object> context = new HashMap<>();
* context.put("name", "Jared");
*
* String template = "Hello, {{ name }}";
* String renderedTemplate = jinjava.render(template, context);
*
*
* @author jstehler
*
*/
public class Jinjava {
private ExpressionFactory expressionFactory;
private ResourceLocator resourceLocator;
private Context globalContext;
private JinjavaConfig globalConfig;
/**
* Create a new Jinjava processor instance with the default global config
*/
public Jinjava() {
this(new JinjavaConfig());
}
/**
* Create a new jinjava processor instance with the specified global config
*
* @param globalConfig used for all render operations performed by this processor instance
*/
public Jinjava(JinjavaConfig globalConfig) {
this.globalConfig = globalConfig;
this.globalContext = new Context();
Properties expConfig = new Properties();
expConfig.setProperty(TreeBuilder.class.getName(), ExtendedSyntaxBuilder.class.getName());
TypeConverter converter = new TruthyTypeConverter();
this.expressionFactory = new ExpressionFactoryImpl(expConfig, converter);
this.resourceLocator = new CascadingResourceLocator(new ClasspathResourceLocator(), new FileLocator());
}
/**
* Set the object responsible for locating templates referenced in other templates
* @param resourceLocator the locator to use for loading all templates
*/
public void setResourceLocator(ResourceLocator resourceLocator) {
this.resourceLocator = resourceLocator;
}
/**
* @return The EL factory used to process expressions in templates by this instance.
*/
public ExpressionFactory getExpressionFactory() {
return expressionFactory;
}
/**
* @return The global config used as a base for all render operations performed by this instance.
*/
public JinjavaConfig getGlobalConfig() {
return globalConfig;
}
/**
* The global render context includes such things as the base set of tags, filters, exp tests and functions,
* used as a base by all render operations performed by this instance
*
* @return the global render context
*/
public Context getGlobalContext() {
return globalContext;
}
public ResourceLocator getResourceLocator() {
return resourceLocator;
}
/**
* @return a comprehensive descriptor of all available filters, functions, and tags registered on this jinjava instance.
*/
public JinjavaDoc getJinjavaDoc() {
return new JinjavaDocFactory(this).get();
}
/**
* Render the given template using the given context bindings.
*
* @param template jinja source template
* @param bindings map of objects to put into scope for this rendering action
* @return the rendered template
* @throws InterpretException if any syntax errors were encountered during rendering
*/
public String render(String template, MapHello, Handsome!
```
Voila! Hey, wait a minute...
Advanced Topics
---------------
### Template loading
Jinjava needs to know how to interpret template paths, so it can properly handle tags like:
```
{% extends "foo/bar/base.html" %}
```
By default, it will load a ```FileLocator```; you will likely want to provide your own implementation of
```ResourceLoader``` to hook into your application's template repository, and then tell jinjava about it:
```java
JinjavaConfig config = new JinjavaConfig();
config.setResourceLocator(new MyCustomResourceLocator());
Jinjava jinjava = new Jinjava(config);
```
### Custom tags, filters and functions
You can provide custom jinja tags, filters, and static functions to the template engine.
```java
// define a custom tag implementing com.hubspot.jinjava.lib.Tag
jinjava.getTagLibrary().addTag(new MyCustomTag());
// define a custom filter implementing com.hubspot.jinjava.lib.Filter
jinjava.getFilterLibrary().addFilter(new MyAwesomeFilter());
// define a custom public static function (this one will bind to myfn.my_func('foo', 42))
jinjava.getFunctionLibrary().addFunction(new ELFunctionDefinition("myfn", "my_func",
MyFuncsClass.class, "myFunc", String.class, Integer.class);
```
### See also
- [Javadocs](http://www.javadoc.io/doc/com.hubspot.jinjava/jinjava)
jinjava-jinjava-2.0.2/benchmark/ 0000775 0000000 0000000 00000000000 12517446303 0016514 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.2/benchmark/README.md 0000664 0000000 0000000 00000000154 12517446303 0017773 0 ustar 00root root 0000000 0000000 Jinjava Benchmarks
==================
To Run:
mvn clean package
java -jar target/benchmarks.jar
jinjava-jinjava-2.0.2/benchmark/jinja2/ 0000775 0000000 0000000 00000000000 12517446303 0017671 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.2/benchmark/liquid/ 0000775 0000000 0000000 00000000000 12517446303 0020003 5 ustar 00root root 0000000 0000000 jinjava-jinjava-2.0.2/benchmark/pom.xml 0000664 0000000 0000000 00000014630 12517446303 0020035 0 ustar 00root root 0000000 0000000
{{page_title|e}}
| {{cell}} | {% endfor %}