Как проверить, определена ли переменная в шаблонах Pebble?

Не встроенный, но Pebble позволяет вам писать пользовательские расширения. В java instanceof — это оператор, для которого Pebble позволяет написать расширение.

Нам нужно 3 вещи, чтобы написать собственное расширение для оператора:

1. Класс, описывающий оператор (implements BinaryOperator)
2. Класс, который описывает, как оценивается оператор (extends BinaryExpression<Object>)
3. Класс, который добавляет этот оператор к бинарным операторам гальки, это класс расширения и должен implements Extension.

Шаг 1

Мы определяем оператор как instanceof с приоритетом 30 в соответствии с java приоритет instanceof такой же, как < > <= >=, в гальке эти операторы имеют приоритет 30, поэтому мы используем его. Узел, который оценивает эту операцию, — InstanceofExpression.class, это класс, который мы создадим на шаге 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;
    }

}

Шаг 2

Теперь мы должны написать, что оценивает оператор, в этом случае мы вернем true if left instanceof right. Для правой части этой оценки мы используем String, который должен содержать полное уточняющее имя класса, например 1 instanceof "java.lang.String", которое возвращает false, или 1 instanceof "java.lang.Long", которое возвращает true.

Будет выдано исключение, если класс right не может быть найден/загружен с помощью 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);
    }

}

Шаг 3

Теперь мы должны создать расширение для Pebble, это довольно просто. Мы создаем экземпляр нашего пользовательского InstanceofOperator и возвращаем его как бинарный оператор:

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.
    // ...
    // ...

}

В качестве альтернативы вместо всего шага 1 вы можете реализовать метод getBinaryOperators как таковой:

@Override
public List<BinaryOperator> getBinaryOperators() {
  return Arrays.asList(new BinaryOperatorImpl("instanceof", 30, InstanceofExpression.class,
            Associativity.LEFT));
}

Выгода!

Теперь мы можем добавить наше собственное расширение с помощью .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

Класс Person, который мы обрабатываем выше, определяется как расширяющий класс Entity. Чтобы доказать, что концепция работает, у нас также есть класс Fruit, который не расширяет Entity. Мы тестируем оба этих разных класса в v:

class Person extends Entity {
    public String name = "me";

}

class Entity {
    public String asd = "asdasdasdasds";

}

class Fruit {
    public String color = "red";
}

home.html мы проверяем, является ли v, который равен Person или Fruit, экземпляром com.mypackage.test.Entity или 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>

Результат:

<html>
    <body>
        <b>asdasdasdasds</b>
    </body>
</html>
<html>
    <body>
        <b>red</b>
    </body>
</html>

Комментарии

Вариант «левый не экземпляр правого»:

{% if not (v instanceof "com.mypackage.test.entity") %}