Add iteratorOnlyReverseFilter LegacyOverride and fix Builder.from() bug

The |reverse filter in Jinja returns an iterator, but Jinjava 2 returned
a list. The ReverseArrayIterator introduced in 3.0 breaks non-standard
usage like {{ (arr|reverse)[0] }}. This override (enabled in THREE_POINT_0)
keeps the iterator behavior; when disabled, the result is collected into
a list for backwards compatibility.

Also fixes Builder.from() which was missing keepNullableLoopValues, causing
it to silently reset to false when cloning a LegacyOverrides instance.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jasmith-hs

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

@@ -18,6 +18,7 @@ public class LegacyOverrides {
     .withAllowAdjacentTextNodes(true)
     .withUseTrimmingForNotesAndExpressions(true)
     .withKeepNullableLoopValues(true)
+    .withIteratorOnlyReverseFilter(true)
     .build();
   public static final LegacyOverrides ALL = new LegacyOverrides.Builder()
     .withEvaluateMapKeys(true)
@@ -29,6 +30,7 @@ public class LegacyOverrides {
     .withAllowAdjacentTextNodes(true)
     .withUseTrimmingForNotesAndExpressions(true)
     .withKeepNullableLoopValues(true)
+    .withIteratorOnlyReverseFilter(true)
     .build();
   private final boolean evaluateMapKeys;
   private final boolean iterateOverMapKeys;
@@ -39,6 +41,7 @@ public class LegacyOverrides {
   private final boolean allowAdjacentTextNodes;
   private final boolean useTrimmingForNotesAndExpressions;
   private final boolean keepNullableLoopValues;
+  private final boolean iteratorOnlyReverseFilter;
 
   private LegacyOverrides(Builder builder) {
     evaluateMapKeys = builder.evaluateMapKeys;
@@ -50,6 +53,7 @@ private LegacyOverrides(Builder builder) {
     allowAdjacentTextNodes = builder.allowAdjacentTextNodes;
     useTrimmingForNotesAndExpressions = builder.useTrimmingForNotesAndExpressions;
     keepNullableLoopValues = builder.keepNullableLoopValues;
+    iteratorOnlyReverseFilter = builder.iteratorOnlyReverseFilter;
   }
 
   public static Builder newBuilder() {
@@ -92,6 +96,10 @@ public boolean isKeepNullableLoopValues() {
     return keepNullableLoopValues;
   }
 
+  public boolean isIteratorOnlyReverseFilter() {
+    return iteratorOnlyReverseFilter;
+  }
+
   public static class Builder {
 
     private boolean evaluateMapKeys = false;
@@ -103,6 +111,7 @@ public static class Builder {
     private boolean allowAdjacentTextNodes = false;
     private boolean useTrimmingForNotesAndExpressions = false;
     private boolean keepNullableLoopValues = false;
+    private boolean iteratorOnlyReverseFilter = false;
 
     private Builder() {}
 
@@ -123,7 +132,9 @@ public static Builder from(LegacyOverrides legacyOverrides) {
         .withAllowAdjacentTextNodes(legacyOverrides.allowAdjacentTextNodes)
         .withUseTrimmingForNotesAndExpressions(
           legacyOverrides.useTrimmingForNotesAndExpressions
-        );
+        )
+        .withKeepNullableLoopValues(legacyOverrides.keepNullableLoopValues)
+        .withIteratorOnlyReverseFilter(legacyOverrides.iteratorOnlyReverseFilter);
     }
 
     public Builder withEvaluateMapKeys(boolean evaluateMapKeys) {
@@ -176,5 +187,10 @@ public Builder withKeepNullableLoopValues(boolean keepNullableLoopValues) {
       this.keepNullableLoopValues = keepNullableLoopValues;
       return this;
     }
+
+    public Builder withIteratorOnlyReverseFilter(boolean iteratorOnlyReverseFilter) {
+      this.iteratorOnlyReverseFilter = iteratorOnlyReverseFilter;
+      return this;
+    }
   }
 }

src/main/java/com/hubspot/jinjava/lib/filter/ReverseFilter.java

@@ -21,8 +21,10 @@
 import com.hubspot.jinjava.interpret.JinjavaInterpreter;
 import com.hubspot.jinjava.objects.collections.ArrayBacked;
 import java.lang.reflect.Array;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.List;
 import java.util.NoSuchElementException;
 
 @JinjavaDoc(
@@ -51,11 +53,14 @@ public Object filter(Object object, JinjavaInterpreter interpreter, String... ar
     }
     // collection
     if (object instanceof Collection) {
-      return ReverseArrayIterator.create(((Collection<?>) object).toArray());
+      return maybeCollectToList(
+        ReverseArrayIterator.create(((Collection<?>) object).toArray()),
+        interpreter
+      );
     }
     // array
     if (object.getClass().isArray()) {
-      return ReverseArrayIterator.create(object);
+      return maybeCollectToList(ReverseArrayIterator.create(object), interpreter);
     }
     // string
     if (object instanceof String) {
@@ -72,6 +77,20 @@ public Object filter(Object object, JinjavaInterpreter interpreter, String... ar
     return object;
   }
 
+  private Object maybeCollectToList(
+    ReverseArrayIterator iterator,
+    JinjavaInterpreter interpreter
+  ) {
+    if (interpreter.getConfig().getLegacyOverrides().isIteratorOnlyReverseFilter()) {
+      return iterator;
+    }
+    List<Object> result = new ArrayList<>();
+    while (iterator.hasNext()) {
+      result.add(iterator.next());
+    }
+    return result;
+  }
+
   @Override
   public String getName() {
     return "reverse";

src/test/java/com/hubspot/jinjava/lib/filter/ReverseFilterTest.java

@@ -3,6 +3,8 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 import com.hubspot.jinjava.BaseJinjavaTest;
+import com.hubspot.jinjava.Jinjava;
+import com.hubspot.jinjava.LegacyOverrides;
 import java.util.HashMap;
 import java.util.Map;
 import org.junit.Test;
@@ -28,4 +30,22 @@ public void itReversesObjectArray() {
     )
       .isEqualTo("cba");
   }
+
+  @Test
+  public void itAllowsIndexingWhenLegacyOverrideIsDisabled() {
+    Jinjava legacyJinjava = new Jinjava(
+      BaseJinjavaTest
+        .newConfigBuilder()
+        .withLegacyOverrides(
+          LegacyOverrides.Builder
+            .from(LegacyOverrides.THREE_POINT_0)
+            .withIteratorOnlyReverseFilter(false)
+            .build()
+        )
+        .build()
+    );
+    Map<String, Object> context = new HashMap<>();
+    context.put("arr", new String[] { "a", "b", "c" });
+    assertThat(legacyJinjava.render("{{ (arr|reverse)[0] }}", context)).isEqualTo("c");
+  }
 }