Merge pull request #236 from casid/226-syntax-proposal-for-else

226 syntax proposal for else

jte-kotlin/src/main/java/gg/jte/compiler/kotlin/KotlinCodeGenerator.java

@@ -4,15 +4,14 @@
 import gg.jte.TemplateConfig;
 import gg.jte.TemplateException;
 import gg.jte.compiler.*;
+import gg.jte.compiler.CodeBuilder.CodeMarker;
 import gg.jte.runtime.ClassInfo;
 import gg.jte.runtime.Constants;
 import gg.jte.runtime.DebugInfo;
 import gg.jte.compiler.TemplateType;
 
 import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
 import static gg.jte.runtime.Constants.TEXT_PART_BINARY;
@@ -29,9 +28,11 @@ public class KotlinCodeGenerator implements CodeGenerator {
     private final List<ParamInfo> parameters = new ArrayList<>();
     private final List<String> imports = new ArrayList<>();
     private final List<byte[]> binaryTextParts = new ArrayList<>();
+    private final Deque<ForLoopStart> forLoopStack = new ArrayDeque<>();
 
     private boolean hasWrittenPackage;
     private boolean hasWrittenClass;
+    private CodeMarker fieldsMarker;
 
     public KotlinCodeGenerator(TemplateCompiler compiler, TemplateConfig config, ConcurrentHashMap<String, List<ParamInfo>> paramOrder, ClassInfo classInfo, LinkedHashSet<ClassDefinition> classDefinitions, LinkedHashSet<TemplateDependency> templateDependencies) {
         this.compiler = compiler;
@@ -78,7 +79,7 @@ private void writeClass() {
         kotlinCode.append("@Suppress(\"UNCHECKED_CAST\", \"UNUSED_PARAMETER\")").append('\n');
         kotlinCode.append("class ").append(classInfo.className).append(" {\n");
         kotlinCode.append("companion object {\n");
-        kotlinCode.markFieldsIndex();
+        fieldsMarker = kotlinCode.getMarkerOfCurrentPosition();
         kotlinCode.append("\t@JvmStatic fun render(");
         writeTemplateOutputParam();
         kotlinCode.append(", jteHtmlInterceptor:gg.jte.html.HtmlInterceptor?");
@@ -121,18 +122,19 @@ public void onLineFinished() {
 
     @Override
     public void onComplete() {
+        // Line information must be updated before insert, otherwise the line info field is not up-to-date
         int lineCount = 2;
         if (!binaryTextParts.isEmpty()) {
             lineCount += binaryTextParts.size() + 1;
         }
-        kotlinCode.insertFieldLines(lineCount);
+        kotlinCode.fillLines(fieldsMarker, lineCount);
 
-        StringBuilder fields = new StringBuilder(64 + 32 * lineCount);
+        StringBuilder fields = new StringBuilder();
         addNameField(fields, classInfo.name);
         addLineInfoField(fields);
         writeBinaryTextParts(fields);
 
-        kotlinCode.insertFields(fields);
+        kotlinCode.insert(fieldsMarker, fields, false);
 
         kotlinCode.append("\t}\n");
 
@@ -378,12 +380,45 @@ public void onConditionEnd(int depth) {
 
     @Override
     public void onForLoopStart(int depth, String codePart) {
+        CodeMarker beforeLoop = kotlinCode.getMarkerOfCurrentPosition();
+
         writeIndentation(depth);
         kotlinCode.append("for (").append(codePart).append(") {\n");
+
+        CodeMarker inLoop = kotlinCode.getMarkerOfCurrentPosition();
+
+        forLoopStack.push(new ForLoopStart(beforeLoop, inLoop, depth));
+    }
+
+    @Override
+    public void onForLoopElse(int depth) {
+        ForLoopStart forLoopStart = forLoopStack.peek();
+
+        if (forLoopStart != null) {
+            String variableName = "__jte_for_loop_entered_" + forLoopStack.size();
+
+            StringBuilder variableDeclaration = new StringBuilder();
+            writeIndentation(variableDeclaration, forLoopStart.indentation);
+            variableDeclaration.append("var ").append(variableName).append(" = false\n");
+            kotlinCode.insert(forLoopStart.beforeLoop, variableDeclaration);
+
+            StringBuilder variableAssignment = new StringBuilder();
+            writeIndentation(variableAssignment, forLoopStart.indentation + 1);
+            variableAssignment.append(variableName).append(" = true\n");
+            kotlinCode.insert(forLoopStart.inLoop, variableAssignment);
+
+            writeIndentation(depth);
+            kotlinCode.append("}\n");
+
+            writeIndentation(depth);
+            kotlinCode.append("if (!").append(variableName).append(") {\n");
+        }
     }
 
     @Override
     public void onForLoopEnd(int depth) {
+        forLoopStack.pop();
+
         writeIndentation(depth);
         kotlinCode.append("}\n");
     }
@@ -521,6 +556,13 @@ private void writeIndentation(int depth) {
         }
     }
 
+    @SuppressWarnings("StringRepeatCanBeUsed")
+    private void writeIndentation(StringBuilder code, int depth) {
+        for (int i = 0; i < depth + 2; ++i) {
+            code.append('\t');
+        }
+    }
+
     @Override
     public String getCode() {
         return kotlinCode.getCode();
@@ -602,4 +644,6 @@ public ParamCallInfo(String param) {
             }
         }
     }
+
+    private record ForLoopStart(CodeMarker beforeLoop, CodeMarker inLoop, int indentation) {}
 }

jte-kotlin/src/test/java/gg/jte/kotlin/TemplateEngineTest.java

@@ -253,6 +253,99 @@ void loopInContentBlock() {
         thenOutputIs("123");
     }
 
+
+    @Test
+    void loopElse_empty() {
+        model.array = new int[]{};
+        givenTemplate("@for (i in model.array)" +
+                "${i}" +
+                "@else" +
+                "Empty" +
+                "@endfor");
+        thenOutputIs("Empty");
+    }
+
+    @Test
+    void loopElse_notEmpty() {
+        model.array = new int[]{1};
+        givenTemplate("@for (i in model.array)" +
+                "${i}" +
+                "@else" +
+                "Empty" +
+                "@endfor");
+        thenOutputIs("1");
+    }
+
+    @Test
+    void loopElseNested_innerEmpty() {
+        templateEngine.setTrimControlStructures(true);
+        model.array = new int[]{1};
+        model.doubleArray = new double[]{};
+        givenTemplate("""
+                @for (i in model.array)
+                  @for (d in model.doubleArray)
+                    ${d}
+                  @else
+                    Inner empty
+                  @endfor
+                @else
+                  Outer empty
+                @endfor""");
+        thenOutputIs("Inner empty\n");
+    }
+
+    @Test
+    void loopElseNestedContentBlock_innerEmpty() {
+        templateEngine.setTrimControlStructures(true);
+        model.array = new int[]{1};
+        model.doubleArray = new double[]{};
+        givenTemplate("""
+                !{var content = @`@for (i in model.array)
+                  @for (d in model.doubleArray)
+                    ${d}
+                  @else
+                    Inner empty
+                  @endfor
+                @else
+                  Outer empty
+                @endfor`;}
+                Result: ${content}""");
+        thenOutputIs("\nResult: Inner empty\n");
+    }
+
+    @Test
+    void loopElse_if() {
+        model.array = new int[]{};
+        givenTemplate("@for (i in model.array)" +
+                "@if(i > 0)${i}@else@endif" +
+                "@else" +
+                "Empty" +
+                "@endfor");
+        thenOutputIs("Empty");
+    }
+
+    @Test
+    void loopElseNested_innerEmptyThrowsException() {
+        templateEngine.setTrimControlStructures(true);
+        model.array = new int[]{1};
+        model.doubleArray = new double[]{};
+        givenTemplate("""
+                @for (i in model.array)
+                  @for (d in model.doubleArray)
+                    ${d}
+                  @else
+                    Inner empty
+                    ${model.getThatThrows()}
+                  @endfor
+                @else
+                  Outer empty
+                @endfor""");
+
+        thenRenderingFailsWithException()
+                .hasCauseInstanceOf(NullPointerException.class)
+                .hasMessage("Failed to render test/template.kte, error at test/template.kte:7");
+    }
+
     @Test
     void unsafeInContentBlock() {
         model.array = new int[]{1, 2, 3};

jte/src/main/java/gg/jte/compiler/CodeBuilder.java

@@ -2,7 +2,9 @@
 
 import gg.jte.runtime.StringUtils;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 
 @SuppressWarnings("UnusedReturnValue")
 public final class CodeBuilder {
@@ -13,10 +15,8 @@ public final class CodeBuilder {
     private final StringBuilder code = new StringBuilder(1024);
     private int currentCodeLine;
     private int currentTemplateLine;
-    private int fieldsIndex;
-    private int fieldsCodeLine;
-    private int fieldsTemplateLine;
     private int[] lineInfo = new int[INITIAL_CAPACITY];
+    private final List<CodeMarker> codeMarkers = new ArrayList<>();
 
     public CodeBuilder(CodeType codeType) {
         this.codeType = codeType;
@@ -86,11 +86,39 @@ public CodeBuilder finishTemplateLine() {
         return this;
     }
 
-    public CodeBuilder insertFieldLines(int count) {
-        fillLines(fieldsCodeLine, fieldsTemplateLine, count);
+    public CodeBuilder insert(CodeMarker position, CharSequence codeToInsert) {
+        return insert(position, codeToInsert, true);
+    }
+
+    public CodeBuilder insert(CodeMarker position, CharSequence codeToInsert, boolean fillLines) {
+        code.insert(position.codeIndex, codeToInsert);
+
+        int insertedLineCount = 0;
+        for (int i = 0; i < codeToInsert.length(); ++i) {
+            if (codeToInsert.charAt(i) == '\n') {
+                ++insertedLineCount;
+            }
+        }
+
+        if (fillLines) {
+            fillLines(position, insertedLineCount);
+        }
+
+        // Adjust any created markers that point to code after this marker.
+        for (CodeMarker codeMarker : codeMarkers) {
+            if (codeMarker.codeIndex > position.codeIndex) {
+                codeMarker.codeIndex += codeToInsert.length();
+                codeMarker.codeLine += insertedLineCount;
+            }
+        }
+
         return this;
     }
 
+    public void fillLines(CodeMarker position, int insertedLineCount) {
+        fillLines(position.codeLine, position.templateLine, insertedLineCount);
+    }
+
     public int getCurrentTemplateLine() {
         return currentTemplateLine;
     }
@@ -99,14 +127,10 @@ public String getCode() {
         return code.toString();
     }
 
-    public void markFieldsIndex() {
-        fieldsIndex = code.length();
-        fieldsCodeLine = currentCodeLine;
-        fieldsTemplateLine = currentTemplateLine;
-    }
-
-    public void insertFields(StringBuilder fields) {
-        code.insert(fieldsIndex, fields);
+    public CodeMarker getMarkerOfCurrentPosition() {
+        CodeMarker codeMarker = new CodeMarker(code.length(), currentCodeLine, currentTemplateLine);
+        codeMarkers.add(codeMarker);
+        return codeMarker;
     }
 
     private void addLine(int templateLine) {
@@ -152,4 +176,16 @@ public int getLineInfo(int index) {
     public void setCurrentTemplateLine(int templateLine) {
         currentTemplateLine = templateLine;
     }
+
+    public static class CodeMarker {
+        private int codeIndex;
+        private int codeLine;
+        private final int templateLine;
+
+        private CodeMarker(int codeIndex, int codeLine, int templateLine) {
+            this.codeIndex = codeIndex;
+            this.codeLine = codeLine;
+            this.templateLine = templateLine;
+        }
+    }
 }

jte/src/main/java/gg/jte/compiler/TemplateParser.java

@@ -279,7 +279,11 @@ private void doParse(int startingDepth) {
 
                 pop();
 
-                visitor.onConditionElse(depth);
+                if (currentMode == Mode.ForLoop) {
+                    visitor.onForLoopElse(depth);
+                } else {
+                    visitor.onConditionElse(depth);
+                }
                 push(Mode.Text);
             } else if (currentMode == Mode.Text && regionMatches("@elseif")) {
                 extractTextPart(i - 6, Mode.ConditionElse);

jte/src/main/java/gg/jte/compiler/TemplateParserVisitor.java

@@ -31,6 +31,8 @@ public interface TemplateParserVisitor {
 
     void onForLoopStart(int depth, String codePart);
 
+    void onForLoopElse(int depth);
+
     void onForLoopEnd(int depth);
 
     default void onRawStart(int depth) {}

jte/src/main/java/gg/jte/compiler/TemplateParserVisitorAdapter.java

@@ -73,6 +73,11 @@ public void onForLoopStart(int depth, String codePart) {
 
     }
 
+    @Override
+    public void onForLoopElse(int depth) {
+
+    }
+
     @Override
     public void onForLoopEnd(int depth) {
 

jte/src/main/java/gg/jte/compiler/TemplateSingleControlStructureVisitor.java

@@ -55,6 +55,11 @@ public void onForLoopStart(int depth, String codePart) {
         incrementAmount();
     }
 
+    @Override
+    public void onForLoopElse(int depth) {
+        incrementAmount();
+    }
+
     @Override
     public void onForLoopEnd(int depth) {
         incrementAmount();