Condense overrideable options in Context to ContextConfiguration immutable

pom.xml

@@ -19,6 +19,8 @@
 
     <dep.plugin.jacoco.version>0.8.3</dep.plugin.jacoco.version>
     <dep.plugin.javadoc.version>3.0.1</dep.plugin.javadoc.version>
+    <dep.hubspot-immutables.version>1.9</dep.hubspot-immutables.version>
+
 
     <basepom.test.add.opens>
       --add-opens=java.base/java.lang=ALL-UNNAMED
@@ -89,6 +91,16 @@
         <artifactId>jackson-datatype-jdk8</artifactId>
         <version>2.14.0</version>
       </dependency>
+      <dependency>
+        <groupId>com.hubspot.immutables</groupId>
+        <artifactId>hubspot-style</artifactId>
+        <version>${dep.hubspot-immutables.version}</version>
+      </dependency>
+      <dependency>
+        <groupId>com.hubspot.immutables</groupId>
+        <artifactId>immutables-exceptions</artifactId>
+        <version>${dep.hubspot-immutables.version}</version>
+      </dependency>
     </dependencies>
   </dependencyManagement>
 
@@ -187,6 +199,20 @@
       <artifactId>mockito-core</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.immutables</groupId>
+      <artifactId>value</artifactId>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.hubspot.immutables</groupId>
+      <artifactId>hubspot-style</artifactId>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.hubspot.immutables</groupId>
+      <artifactId>immutables-exceptions</artifactId>
+    </dependency>
   </dependencies>
 
   <build>

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

@@ -22,7 +22,6 @@
 import com.google.common.collect.SetMultimap;
 import com.google.common.collect.Sets;
 import com.hubspot.jinjava.lib.Importable;
-import com.hubspot.jinjava.lib.expression.DefaultExpressionStrategy;
 import com.hubspot.jinjava.lib.expression.ExpressionStrategy;
 import com.hubspot.jinjava.lib.exptest.ExpTest;
 import com.hubspot.jinjava.lib.exptest.ExpTestLibrary;
@@ -65,11 +64,11 @@ public class Context extends ScopeMap<String, Object> {
   private Map<Library, Set<String>> disabled;
 
   public boolean isValidationMode() {
-    return validationMode;
+    return contextConfiguration.isValidationMode();
   }
 
   public Context setValidationMode(boolean validationMode) {
-    this.validationMode = validationMode;
+    contextConfiguration = contextConfiguration.withValidationMode(validationMode);
     return this;
   }
 
@@ -101,23 +100,14 @@ public enum Library {
   private final FunctionLibrary functionLibrary;
   private final TagLibrary tagLibrary;
 
-  private ExpressionStrategy expressionStrategy = new DefaultExpressionStrategy();
-
   private final Context parent;
 
   private int renderDepth = -1;
   private Boolean autoEscape;
   private List<? extends Node> superBlock;
 
   private final Stack<String> renderStack = new Stack<>();
-
-  private boolean validationMode = false;
-  private boolean deferredExecutionMode = false;
-  private boolean deferLargeObjects = false;
-  private boolean throwInterpreterErrors = false;
-  private boolean partialMacroEvaluation = false;
-  private boolean unwrapRawOverride = false;
-  private DynamicVariableResolver dynamicVariableResolver = null;
+  private ContextConfiguration contextConfiguration = ContextConfiguration.of();
   private final Set<String> metaContextVariables; // These variable names aren't tracked in eager execution
   private final Set<String> overriddenNonMetaContextVariables;
   private Node currentNode;
@@ -215,13 +205,7 @@ public Context(
     this.overriddenNonMetaContextVariables =
       parent == null ? new HashSet<>() : parent.overriddenNonMetaContextVariables;
     if (parent != null) {
-      this.expressionStrategy = parent.expressionStrategy;
-      this.partialMacroEvaluation = parent.partialMacroEvaluation;
-      this.unwrapRawOverride = parent.unwrapRawOverride;
-      this.dynamicVariableResolver = parent.dynamicVariableResolver;
-      this.deferredExecutionMode = parent.deferredExecutionMode;
-      this.deferLargeObjects = parent.deferLargeObjects;
-      this.throwInterpreterErrors = parent.throwInterpreterErrors;
+      this.contextConfiguration = parent.contextConfiguration;
     }
   }
 
@@ -654,21 +638,23 @@ public void registerTag(Tag t) {
   }
 
   public DynamicVariableResolver getDynamicVariableResolver() {
-    return dynamicVariableResolver;
+    return contextConfiguration.getDynamicVariableResolver();
   }
 
   public void setDynamicVariableResolver(
     final DynamicVariableResolver dynamicVariableResolver
   ) {
-    this.dynamicVariableResolver = dynamicVariableResolver;
+    contextConfiguration =
+      contextConfiguration.withDynamicVariableResolver(dynamicVariableResolver);
   }
 
   public ExpressionStrategy getExpressionStrategy() {
-    return expressionStrategy;
+    return contextConfiguration.getExpressionStrategy();
   }
 
   public void setExpressionStrategy(ExpressionStrategy expressionStrategy) {
-    this.expressionStrategy = expressionStrategy;
+    contextConfiguration =
+      contextConfiguration.withExpressionStrategy(expressionStrategy);
   }
 
   public Optional<String> getImportResourceAlias() {
@@ -754,48 +740,51 @@ public SetMultimap<String, String> getDependencies() {
   }
 
   public boolean isDeferredExecutionMode() {
-    return deferredExecutionMode;
+    return contextConfiguration.isDeferredExecutionMode();
   }
 
   public Context setDeferredExecutionMode(boolean deferredExecutionMode) {
-    this.deferredExecutionMode = deferredExecutionMode;
+    contextConfiguration =
+      contextConfiguration.withDeferredExecutionMode(deferredExecutionMode);
     return this;
   }
 
   public boolean isDeferLargeObjects() {
-    return deferLargeObjects;
+    return contextConfiguration.isDeferLargeObjects();
   }
 
   public Context setDeferLargeObjects(boolean deferLargeObjects) {
-    this.deferLargeObjects = deferLargeObjects;
+    contextConfiguration = contextConfiguration.withDeferLargeObjects(deferLargeObjects);
     return this;
   }
 
   public TemporaryValueClosable<Boolean> withDeferLargeObjects(
     boolean deferLargeObjects
   ) {
     TemporaryValueClosable<Boolean> temporaryValueClosable = new TemporaryValueClosable<>(
-      this.deferLargeObjects,
+      isDeferLargeObjects(),
       this::setDeferLargeObjects
     );
-    this.deferLargeObjects = deferLargeObjects;
+    setDeferLargeObjects(deferLargeObjects);
     return temporaryValueClosable;
   }
 
   public boolean getThrowInterpreterErrors() {
-    return throwInterpreterErrors;
+    return contextConfiguration.isThrowInterpreterErrors();
   }
 
   public void setThrowInterpreterErrors(boolean throwInterpreterErrors) {
-    this.throwInterpreterErrors = throwInterpreterErrors;
+    contextConfiguration =
+      contextConfiguration.withThrowInterpreterErrors(throwInterpreterErrors);
   }
 
   public boolean isPartialMacroEvaluation() {
-    return partialMacroEvaluation;
+    return contextConfiguration.isPartialMacroEvaluation();
   }
 
   public void setPartialMacroEvaluation(boolean partialMacroEvaluation) {
-    this.partialMacroEvaluation = partialMacroEvaluation;
+    contextConfiguration =
+      contextConfiguration.withPartialMacroEvaluation(partialMacroEvaluation);
   }
 
   public TemporaryValueClosable<Boolean> withPartialMacroEvaluation() {
@@ -806,27 +795,27 @@ public TemporaryValueClosable<Boolean> withPartialMacroEvaluation(
     boolean partialMacroEvaluation
   ) {
     TemporaryValueClosable<Boolean> temporaryValueClosable = new TemporaryValueClosable<>(
-      this.partialMacroEvaluation,
+      isPartialMacroEvaluation(),
       this::setPartialMacroEvaluation
     );
-    this.partialMacroEvaluation = partialMacroEvaluation;
+    setPartialMacroEvaluation(partialMacroEvaluation);
     return temporaryValueClosable;
   }
 
   public boolean isUnwrapRawOverride() {
-    return unwrapRawOverride;
+    return contextConfiguration.isUnwrapRawOverride();
   }
 
   public void setUnwrapRawOverride(boolean unwrapRawOverride) {
-    this.unwrapRawOverride = unwrapRawOverride;
+    contextConfiguration = contextConfiguration.withUnwrapRawOverride(unwrapRawOverride);
   }
 
   public TemporaryValueClosable<Boolean> withUnwrapRawOverride() {
     TemporaryValueClosable<Boolean> temporaryValueClosable = new TemporaryValueClosable<>(
-      this.unwrapRawOverride,
+      isUnwrapRawOverride(),
       this::setUnwrapRawOverride
     );
-    this.unwrapRawOverride = true;
+    setUnwrapRawOverride(true);
     return temporaryValueClosable;
   }
 

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

@@ -0,0 +1,50 @@
+package com.hubspot.jinjava.interpret;
+
+import com.hubspot.immutables.style.HubSpotImmutableStyle;
+import com.hubspot.jinjava.lib.expression.DefaultExpressionStrategy;
+import com.hubspot.jinjava.lib.expression.ExpressionStrategy;
+import javax.annotation.Nullable;
+import org.immutables.value.Value.Default;
+import org.immutables.value.Value.Immutable;
+
+@Immutable(singleton = true)
+@HubSpotImmutableStyle
+public interface ContextConfigurationIF {
+  @Default
+  default ExpressionStrategy getExpressionStrategy() {
+    return new DefaultExpressionStrategy();
+  }
+
+  @Nullable
+  DynamicVariableResolver getDynamicVariableResolver();
+
+  @Default
+  default boolean isValidationMode() {
+    return false;
+  }
+
+  @Default
+  default boolean isDeferredExecutionMode() {
+    return false;
+  }
+
+  @Default
+  default boolean isDeferLargeObjects() {
+    return false;
+  }
+
+  @Default
+  default boolean isThrowInterpreterErrors() {
+    return false;
+  }
+
+  @Default
+  default boolean isPartialMacroEvaluation() {
+    return false;
+  }
+
+  @Default
+  default boolean isUnwrapRawOverride() {
+    return false;
+  }
+}