feat(config): add renderingEnabledSupplier to disable rendering

src/main/java/com/hubspot/jinjava/Jinjava.java

@@ -27,6 +27,7 @@
 import com.hubspot.jinjava.interpret.InvalidInputException;
 import com.hubspot.jinjava.interpret.JinjavaInterpreter;
 import com.hubspot.jinjava.interpret.RenderResult;
+import com.hubspot.jinjava.interpret.RenderingDisabledException;
 import com.hubspot.jinjava.interpret.TemplateError;
 import com.hubspot.jinjava.interpret.TemplateError.ErrorType;
 import com.hubspot.jinjava.interpret.TemplateSyntaxException;
@@ -256,6 +257,12 @@ public RenderResult renderForResult(
           interpreter.getContext(),
           interpreter.getErrorsCopy()
         );
+      } catch (RenderingDisabledException e) {
+        return new RenderResult(
+          TemplateError.fromRenderingDisabledException(e),
+          interpreter.getContext(),
+          interpreter.getErrorsCopy()
+        );
       } catch (InterpretException e) {
         if (e instanceof TemplateSyntaxException) {
           return new RenderResult(

src/main/java/com/hubspot/jinjava/JinjavaConfig.java

@@ -49,6 +49,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiConsumer;
+import java.util.function.Supplier;
 import javax.el.ELResolver;
 import org.immutables.value.Value;
 
@@ -159,6 +160,11 @@ public int getMaxNumDeferredTokens() {
     return 1000;
   }
 
+  @Value.Default
+  public Supplier<Boolean> getRenderingEnabledSupplier() {
+    return () -> true;
+  }
+
   @Value.Default
   public InterpreterFactory getInterpreterFactory() {
     return new JinjavaInterpreterFactory();

src/main/java/com/hubspot/jinjava/interpret/JinjavaInterpreter.java

@@ -284,6 +284,12 @@ public String renderFlat(String template, long renderLimit) {
     }
   }
 
+  private void checkRenderingEnabled() {
+    if (!Boolean.TRUE.equals(config.getRenderingEnabledSupplier().get())) {
+      throw new RenderingDisabledException();
+    }
+  }
+
   private TemporaryValueClosable<ErrorHandlingStrategy> ignoreParseErrorsIfActivated() {
     return config
         .getFeatures()
@@ -314,6 +320,7 @@ public String render(String template) {
    * @return rendered result
    */
   public String render(String template, long renderLimit) {
+    checkRenderingEnabled();
     return render(parse(template), true, renderLimit);
   }
 
@@ -352,6 +359,7 @@ public String render(Node root, boolean processExtendRoots) {
    * @return rendered result
    */
   private String render(Node root, boolean processExtendRoots, long renderLimit) {
+    checkRenderingEnabled();
     boolean pushed = false;
     //noinspection ErrorProne
     if (JinjavaInterpreter.getCurrent() != this) {

src/main/java/com/hubspot/jinjava/interpret/RenderingDisabledException.java

@@ -0,0 +1,8 @@
+package com.hubspot.jinjava.interpret;
+
+public class RenderingDisabledException extends InterpretException {
+
+  public RenderingDisabledException() {
+    super("Rendering is disabled");
+  }
+}

src/main/java/com/hubspot/jinjava/interpret/TemplateError.java

@@ -171,6 +171,23 @@ public static TemplateError fromException(Exception ex) {
     );
   }
 
+  public static TemplateError fromRenderingDisabledException(
+    RenderingDisabledException ex
+  ) {
+    return new TemplateError(
+      ErrorType.FATAL,
+      ErrorReason.DISABLED,
+      ErrorItem.TEMPLATE,
+      ex.getMessage(),
+      null,
+      -1,
+      -1,
+      ex,
+      BasicTemplateErrorCategory.UNKNOWN,
+      ImmutableMap.of()
+    );
+  }
+
   public static TemplateError fromOutputTooBigException(Exception ex) {
     return new TemplateError(
       ErrorType.FATAL,

src/test/java/com/hubspot/jinjava/RenderingEnabledSupplierTest.java

@@ -0,0 +1,99 @@
+package com.hubspot.jinjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import com.google.common.collect.ImmutableMap;
+import com.hubspot.jinjava.interpret.FatalTemplateErrorsException;
+import com.hubspot.jinjava.interpret.JinjavaInterpreter;
+import com.hubspot.jinjava.interpret.RenderResult;
+import com.hubspot.jinjava.interpret.RenderingDisabledException;
+import com.hubspot.jinjava.interpret.TemplateError.ErrorReason;
+import com.hubspot.jinjava.interpret.TemplateError.ErrorType;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.Before;
+import org.junit.Test;
+
+public class RenderingEnabledSupplierTest {
+
+  private AtomicBoolean renderingEnabled;
+  private Jinjava jinjava;
+
+  @Before
+  public void setup() {
+    renderingEnabled = new AtomicBoolean(true);
+    jinjava =
+      new Jinjava(
+        JinjavaConfig
+          .newBuilder()
+          .withRenderingEnabledSupplier(renderingEnabled::get)
+          .build()
+      );
+  }
+
+  @Test
+  public void itRendersByDefault() {
+    assertThat(new Jinjava().render("{{ foo }}", ImmutableMap.of("foo", "bar")))
+      .isEqualTo("bar");
+  }
+
+  @Test
+  public void itRendersWhenEnabled() {
+    assertThat(jinjava.render("{{ foo }}", ImmutableMap.of("foo", "bar")))
+      .isEqualTo("bar");
+  }
+
+  @Test
+  public void itReturnsDisabledErrorWhenDisabled() {
+    renderingEnabled.set(false);
+
+    RenderResult result = jinjava.renderForResult(
+      "{{ foo }}",
+      ImmutableMap.of("foo", "bar")
+    );
+
+    assertThat(result.getOutput()).isEmpty();
+    assertThat(result.getErrors())
+      .singleElement()
+      .satisfies(error -> {
+        assertThat(error.getSeverity()).isEqualTo(ErrorType.FATAL);
+        assertThat(error.getReason()).isEqualTo(ErrorReason.DISABLED);
+        assertThat(error.getException()).isInstanceOf(RenderingDisabledException.class);
+      });
+  }
+
+  @Test
+  public void itThrowsFromRenderWhenDisabled() {
+    renderingEnabled.set(false);
+
+    assertThatThrownBy(() -> jinjava.render("{{ foo }}", ImmutableMap.of("foo", "bar")))
+      .isInstanceOf(FatalTemplateErrorsException.class);
+  }
+
+  @Test
+  public void itChecksSupplierOnEveryRender() {
+    assertThat(jinjava.render("{{ foo }}", ImmutableMap.of("foo", "bar")))
+      .isEqualTo("bar");
+
+    renderingEnabled.set(false);
+    assertThat(jinjava.renderForResult("{{ foo }}", ImmutableMap.of()).getErrors())
+      .isNotEmpty();
+
+    renderingEnabled.set(true);
+    assertThat(jinjava.render("{{ foo }}", ImmutableMap.of("foo", "baz")))
+      .isEqualTo("baz");
+  }
+
+  @Test
+  public void itPreventsInterpreterRenderingWhenDisabled() {
+    JinjavaInterpreter interpreter = jinjava.newInterpreter();
+    renderingEnabled.set(false);
+
+    assertThatThrownBy(() -> interpreter.render("{{ foo }}"))
+      .isInstanceOf(RenderingDisabledException.class);
+    assertThatThrownBy(() -> interpreter.render(interpreter.parse("{{ foo }}")))
+      .isInstanceOf(RenderingDisabledException.class);
+    assertThatThrownBy(() -> interpreter.renderFlat("{{ foo }}"))
+      .isInstanceOf(RenderingDisabledException.class);
+  }
+}