Using Pebble version 3.0.6.
I need to check if value 'v' has a specific variable (translated to Java: if Object v has a specific property). Looking for something like
{% if v instanceof test.MyClass %}
...
{% endif %}
or
{% if v has myProperty %}
...
{% endif %}
Both are not available as far as i know. What is the best way to achieve this with Pebble?
UPDATE
Context:
strictVariables = true
Not a builtin one but pebble allows you to write custom extensions. In java instanceof is an operator, which is something pebble allows you to write an extension for.
We need 3 things to write a custom extension for an operator:
implements BinaryOperator)extends BinaryExpression<Object>)implements Extension.We define the operator as instanceof with a precedence of 30, according to java the precedence of instanceof is the same as < > <= >=, in pebble these operators have a precedence of 30 so we use that. The node which evaluates this operation is InstanceofExpression.class, which is the class we will create in step 2.
public class InstanceofOperator implements BinaryOperator {
/**
* This precedence is set based on
* <a href="https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html">Java
* Operators</a> 30 is the same precedence pebble has set for operators like {@code instanceof}
* like <a href="https://github.com/PebbleTemplates/pebble/wiki/extending-pebble">Extending
* Pebble</a>.
*/
public int getPrecedence() {
return 30;
}
public String getSymbol() {
return "instanceof";
}
public Class<? extends BinaryExpression<?>> getNodeClass() {
return InstanceofExpression.class;
}
public Associativity getAssociativity() {
return Associativity.LEFT;
}
}
We now must write what the operator evaluates to, in this case we will return true if left instanceof right. For the right part of this evaluation we use a String which must contain the full qualifying name for the class, for example 1 instanceof "java.lang.String" which will return false, or 1 instanceof "java.lang.Long" which will return true.
An exception will be thrown if the right class cannot be found/loaded with Class.forName.
public class InstanceofExpression extends BinaryExpression<Object> {
@Override
public Object evaluate(PebbleTemplateImpl self, EvaluationContextImpl context) {
// The left class (left instanceof right)
Object leftClass = getLeftExpression().evaluate(self, context);
// The right class, this is a string with the full qualifying name of the class eg (left
// instanceof "java.lang.String")
String rightClassname = getRightExpression().evaluate(self, context).toString();
// We must get the right class as Class<?> in order to check if left is an instanceof right
Class<?> rightClass;
try {
rightClass = Class.forName(rightClassname);
} catch (ClassNotFoundException e) {
throw new PebbleException(e.getCause(),
String.format("Cannot find class %s", rightClassname));
}
// Check if the left class is an instanceof the right class
return rightClass.isInstance(leftClass);
}
}
We now must create an extension for Pebble, this is quite simple. We create an instanceof our custom InstanceofOperator and return that as binary operator:
public class InstanceofExtension implements Extension {
@Override
public List<BinaryOperator> getBinaryOperators() {
return Arrays.asList(new InstanceofOperator());
}
// ...
// Other methods required by implementing Extension, these other methods can just return null.
// ...
// ...
}
Alternatively instead of the entire Step 1 you can implement the getBinaryOperators method as such:
@Override
public List<BinaryOperator> getBinaryOperators() {
return Arrays.asList(new BinaryOperatorImpl("instanceof", 30, InstanceofExpression.class,
Associativity.LEFT));
}
We can now add our custom extension with .extension(new InstanceofExtension()):
PebbleEngine engine =
new PebbleEngine.Builder().strictVariables(true)
.extension(new InstanceofExtension()).build();
PebbleTemplate compiledTemplate = engine.getTemplate("home.html");
// Test with Person as v
Writer personWriter = new StringWriter();
Map<String, Object> context = new HashMap<>();
context.put("v", new Person());
compiledTemplate.evaluate(personWriter, context);
System.out.println(personWriter.toString()); // <b>asdasdasdasds</b> is present
// Test with Fruit as v
Writer fruitWriter = new StringWriter();
context.put("v", new Fruit());
compiledTemplate.evaluate(fruitWriter, context);
System.out.println(fruitWriter.toString()); // <b>asdasdasdasds</b> is not present, but
// <b>red</b> is
The Person class which we are processing above is defined as such that it extends Entity. To prove the concept works we also have a class Fruit which does not extend Entity. We test both of these different classes in v:
class Person extends Entity {
public String name = "me";
}
class Entity {
public String asd = "asdasdasdasds";
}
class Fruit {
public String color = "red";
}
home.html we check if v which is Person or Fruit is an instance of com.mypackage.test.Entity or com.mypackage.test.Fruit:
<html>
<body>
{% if v instanceof "com.mypackage.test.Entity" %}
<b>{{ v.asd }}</b>
{% endif %}
{% if v instanceof "com.mypackage.test.Fruit" %}
<b>{{ v.color }}</b>
{% endif %}
</body>
</html>
The output is:
<html>
<body>
<b>asdasdasdasds</b>
</body>
</html>
<html>
<body>
<b>red</b>
</body>
</html>
The "left not instanceof right" version is:
{% if not (v instanceof "com.mypackage.test.entity") %}
