Merge bb40fb5 into db1b3ca

wurstscript · Jan 1, 2020 · 02cbd6d · 02cbd6d
2 parents db1b3ca + bb40fb5
commit 02cbd6d
Show file tree

Hide file tree

Showing 4 changed files with 278 additions and 0 deletions.
diff --git a/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/WurstLanguageServer.java b/de.peeeq.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/WurstLanguageServer.java
@@ -59,6 +59,7 @@ public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
         capabilities.setWorkspaceSymbolProvider(true);
         capabilities.setColorProvider(true);
         capabilities.setCodeLensProvider(new CodeLensOptions(true));
+        capabilities.setFoldingRangeProvider(true);
 
 
         InitializeResult res = new InitializeResult(capabilities);

diff --git a/...q.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/WurstTextDocumentService.java b/...q.wurstscript/src/main/java/de/peeeq/wurstio/languageserver/WurstTextDocumentService.java
@@ -151,4 +151,9 @@ public CompletableFuture<List<ColorInformation>> documentColor(DocumentColorPara
     public CompletableFuture<List<ColorPresentation>> colorPresentation(ColorPresentationParams params) {
         return worker.handle(new Colors.ColorPresentationRequest(params));
     }
+
+    @Override
+    public CompletableFuture<List<FoldingRange>> foldingRange(FoldingRangeRequestParams params) {
+        return worker.handle(new FoldingRangeRequest(params));
+    }
 }
diff --git a/...rstscript/src/main/java/de/peeeq/wurstio/languageserver/requests/FoldingRangeRequest.java b/...rstscript/src/main/java/de/peeeq/wurstio/languageserver/requests/FoldingRangeRequest.java
@@ -0,0 +1,178 @@
+package de.peeeq.wurstio.languageserver.requests;
+
+import de.peeeq.wurstio.languageserver.Convert;
+import de.peeeq.wurstio.languageserver.ModelManager;
+import de.peeeq.wurstio.languageserver.WFile;
+import de.peeeq.wurstscript.ast.*;
+import de.peeeq.wurstscript.utils.Utils;
+import org.apache.commons.lang.StringUtils;
+import org.eclipse.lsp4j.*;
+import org.jetbrains.annotations.NotNull;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ *
+ */
+public class FoldingRangeRequest extends UserRequest<List<FoldingRange>> {
+
+    private final TextDocumentIdentifier textDocument;
+
+    public FoldingRangeRequest(FoldingRangeRequestParams params) {
+        textDocument = params.getTextDocument();
+    }
+
+    @Override
+    public List<FoldingRange> execute(ModelManager modelManager) {
+        CompilationUnit cu = modelManager.getCompilationUnit(WFile.create(textDocument));
+        if (cu == null) {
+            return Collections.emptyList();
+        }
+
+        return calculateFoldingRanges(cu);
+    }
+
+    @NotNull
+    public static List<FoldingRange> calculateFoldingRanges(CompilationUnit cu) {
+        List<FoldingRange> result = new ArrayList<>();
+        cu.accept(new Element.DefaultVisitor() {
+            private void addFoldingRange(Element element) {
+                addFoldingRange(element, 0, 0);
+            }
+
+            private void addFoldingRange(Element element, int startOffset, int endOffset) {
+                addFoldingRange(element, startOffset, endOffset, "");
+            }
+
+            private void addFoldingRange(Element element, int startOffset, int endOffset, String kind) {
+                Range range = Convert.range(element);
+                range.getStart().setLine(range.getStart().getLine() + startOffset);
+                if (range.getEnd().getCharacter() == 0) {
+                    range.getEnd().setLine(range.getEnd().getLine() - 1);
+                } else {
+                    range.getEnd().setLine(range.getEnd().getLine() + endOffset);
+                }
+                if (range.getStart().getLine() < range.getEnd().getLine()) {
+                    FoldingRange foldingRange = new FoldingRange(range.getStart().getLine(), range.getEnd().getLine());
+                    foldingRange.setKind(kind);
+                    result.add(foldingRange);
+                }
+            }
+
+            @Override
+            public void visit(WImports imports) {
+                addFoldingRange(imports, 0, -1, FoldingRangeKind.Imports);
+            }
+
+            @Override
+            public void visit(ClassDef classDef) {
+                addFoldingRange(classDef, StringUtils.isEmpty(classDef.attrComment()) ? 0 : 1, 0);
+                super.visit(classDef);
+            }
+
+            @Override
+            public void visit(FuncDef funcDef) {
+                addFoldingRange(funcDef.getBody(), -1, 0);
+                super.visit(funcDef);
+            }
+
+            @Override
+            public void visit(ExtensionFuncDef extensionFuncDef) {
+                addFoldingRange(extensionFuncDef.getBody(), -1, 0);
+                super.visit(extensionFuncDef);
+            }
+
+            @Override
+            public void visit(StmtIf ifStmt) {
+                addFoldingRange(ifStmt, 0, -1);
+                super.visit(ifStmt);
+            }
+
+            @Override
+            public void visit(InterfaceDef interfaceDef) {
+                addFoldingRange(interfaceDef, StringUtils.isEmpty(interfaceDef.attrComment()) ? 0 : 1, 0);
+                super.visit(interfaceDef);
+            }
+
+            @Override
+            public void visit(StmtLoop stmtLoop) {
+                addFoldingRange(stmtLoop, 0, -1);
+                super.visit(stmtLoop);
+            }
+
+            @Override
+            public void visit(StmtWhile stmtWhile) {
+                addFoldingRange(stmtWhile);
+                super.visit(stmtWhile);
+            }
+
+            @Override
+            public void visit(StmtForIn stmtForIn) {
+                addFoldingRange(stmtForIn);
+                super.visit(stmtForIn);
+            }
+
+            @Override
+            public void visit(StmtForFrom stmtForFrom) {
+                addFoldingRange(stmtForFrom);
+                super.visit(stmtForFrom);
+            }
+
+            @Override
+            public void visit(StmtForRangeDown stmtForRangeDown) {
+                addFoldingRange(stmtForRangeDown);
+                super.visit(stmtForRangeDown);
+            }
+
+            @Override
+            public void visit(StmtForRangeUp stmtForRangeUp) {
+                addFoldingRange(stmtForRangeUp);
+                super.visit(stmtForRangeUp);
+            }
+
+            @Override
+            public void visit(InitBlock initBlock) {
+                addFoldingRange(initBlock);
+                super.visit(initBlock);
+            }
+
+            @Override
+            public void visit(EnumDef enumDef) {
+                addFoldingRange(enumDef);
+                super.visit(enumDef);
+            }
+
+            @Override
+            public void visit(SwitchStmt switchStmt) {
+                addFoldingRange(switchStmt);
+                super.visit(switchStmt);
+            }
+
+            @Override
+            public void visit(SwitchCase switchCase) {
+                addFoldingRange(switchCase);
+                super.visit(switchCase);
+            }
+
+            @Override
+            public void visit(OnDestroyDef onDestroyDef) {
+                addFoldingRange(onDestroyDef);
+                super.visit(onDestroyDef);
+            }
+
+            @Override
+            public void visit(ConstructorDef constructorDef) {
+                addFoldingRange(constructorDef);
+                super.visit(constructorDef);
+            }
+
+        });
+        return result;
+    }
+
+}
diff --git a/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/FoldingTests.java b/de.peeeq.wurstscript/src/test/java/tests/wurstscript/tests/FoldingTests.java
@@ -0,0 +1,94 @@
+package tests.wurstscript.tests;
+
+import de.peeeq.wurstio.languageserver.requests.Colors;
+import de.peeeq.wurstio.languageserver.requests.FoldingRangeRequest;
+import de.peeeq.wurstscript.ast.CompilationUnit;
+import org.eclipse.lsp4j.ColorInformation;
+import org.eclipse.lsp4j.FoldingRange;
+import org.testng.Assert;
+import org.testng.annotations.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.testng.Assert.assertEquals;
+
+/**
+ *
+ */
+public class FoldingTests extends WurstScriptTest {
+
+    @Test
+    public void testRanges() {
+        CompilationResult compilationResult = test().lines("package B\n" +
+            "endpackage\n" +
+            "\n" +
+            "package C\n" +
+            "endpackage\n" +
+            "\n" +
+            "package D\n" +
+            "endpackage\n" +
+            "\n" +
+            "package A\n" +
+            "import B\n" +
+            "import C\n" +
+            "import D\n" +
+            "\n" +
+            "interface I\n" +
+            "\tfunction foo()\n" +
+            "\n" +
+            "enum E\n" +
+            "\tEEE\n" +
+            "\n" +
+            "class F\n" +
+            "\tint i\n" +
+            "\n" +
+            "\tconstruct()\n" +
+            "\t\tlet i = 0\n" +
+            "\t\tif i > 0\n" +
+            "\t\t\tskip\n" +
+            "\n" +
+            "\tfunction foo()\n" +
+            "\t\tfor i = 0 to 10\n" +
+            "\t\t\tskip\n" +
+            "\n" +
+            "\tondestroy\n" +
+            "\t\tskip\n" +
+            "\n" +
+            "init\n" +
+            "\tskip\n");
+        CompilationUnit compilationUnit = compilationResult.getModel().get(0);
+        List<FoldingRange> foldingRanges = FoldingRangeRequest.calculateFoldingRanges(compilationUnit);
+        Assert.assertEquals(foldingRanges.get(0).getStartLine(), 10);
+        Assert.assertEquals(foldingRanges.get(0).getEndLine(), 12);
+
+        Assert.assertEquals(foldingRanges.get(1).getStartLine(), 14);
+        Assert.assertEquals(foldingRanges.get(1).getEndLine(), 15);
+
+        Assert.assertEquals(foldingRanges.get(2).getStartLine(), 17);
+        Assert.assertEquals(foldingRanges.get(2).getEndLine(), 18);
+
+        Assert.assertEquals(foldingRanges.get(3).getStartLine(), 20);
+        Assert.assertEquals(foldingRanges.get(3).getEndLine(), 33);
+
+        Assert.assertEquals(foldingRanges.get(4).getStartLine(), 28);
+        Assert.assertEquals(foldingRanges.get(4).getEndLine(), 30);
+
+        Assert.assertEquals(foldingRanges.get(5).getStartLine(), 29);
+        Assert.assertEquals(foldingRanges.get(5).getEndLine(), 30);
+
+        Assert.assertEquals(foldingRanges.get(6).getStartLine(), 23);
+        Assert.assertEquals(foldingRanges.get(6).getEndLine(), 26);
+
+        Assert.assertEquals(foldingRanges.get(7).getStartLine(), 25);
+        Assert.assertEquals(foldingRanges.get(7).getEndLine(), 26);
+
+        Assert.assertEquals(foldingRanges.get(8).getStartLine(), 32);
+        Assert.assertEquals(foldingRanges.get(8).getEndLine(), 33);
+
+        Assert.assertEquals(foldingRanges.get(9).getStartLine(), 35);
+        Assert.assertEquals(foldingRanges.get(9).getEndLine(), 38);
+
+    }
+
+}