(PowerShellGH-1514) Show the last line of folding regions as per default VSCode

Changes the default to true
Adds tests

Author: glennsarti

package.json

@@ -480,7 +480,7 @@
         },
         "powershell.codeFolding.showLastLine": {
           "type": "boolean",
-          "default": false,
+          "default": true,
           "description": "Shows the last line of a folded section similar to the default VSCode folding style. When disabled, the entire folded region is hidden."
         },
         "powershell.codeFormatting.preset": {

src/features/Folding.ts

@@ -101,13 +101,10 @@ class LineNumberRange {
      */
     public rangeKind: vscode.FoldingRangeKind;
 
-    private settings: Settings.ISettings;
-
     constructor(
         rangeKind: vscode.FoldingRangeKind,
     ) {
         this.rangeKind = rangeKind;
-        this.settings = Settings.load();
     }
 
     /**
@@ -124,9 +121,6 @@ class LineNumberRange {
     ): LineNumberRange {
         this.startline = document.positionAt(start.startIndex).line;
         this.endline = document.positionAt(end.startIndex).line;
-        if (this.settings.codeFolding && this.settings.codeFolding.showLastLine) {
-            this.endline--;
-        }
         return this;
     }
 
@@ -163,8 +157,12 @@ class LineNumberRange {
      * Creates a vscode.FoldingRange object based on this object
      * @returns A Folding Range object for use with the Folding Provider
      */
-    public toFoldingRange(): vscode.FoldingRange {
-        return new vscode.FoldingRange(this.startline, this.endline, this.rangeKind);
+    public toFoldingRange(settings: Settings.ISettings): vscode.FoldingRange {
+        if (settings.codeFolding && settings.codeFolding.showLastLine) {
+            return new vscode.FoldingRange(this.startline, this.endline - 1, this.rangeKind);
+        } else {
+            return new vscode.FoldingRange(this.startline, this.endline, this.rangeKind);
+        }
     }
 }
 
@@ -258,15 +256,21 @@ export class FoldingProvider implements vscode.FoldingRangeProvider {
             return 0;
         });
 
+        const settings = this.currentSettings();
         return foldableRegions
             // It's possible to have duplicate or overlapping ranges, that is, regions which have the same starting
             // line number as the previous region. Therefore only emit ranges which have a different starting line
             // than the previous range.
             .filter((item, index, src) => index === 0 || item.startline !== src[index - 1].startline)
             // Convert the internal representation into the VSCode expected type
-            .map((item) => item.toFoldingRange());
+            .map((item) => item.toFoldingRange(settings));
     }
 
+    /**
+     * A helper to return the current extension settings
+     */
+    public currentSettings(): Settings.ISettings { return Settings.load(); }
+
     /**
      * Given a start and end textmate scope name, find matching grammar tokens
      * and pair them together.  Uses a simple stack to take into account nested regions.

test/features/folding.test.ts

@@ -7,6 +7,7 @@ import * as path from "path";
 import * as vscode from "vscode";
 import { DocumentSelector } from "vscode-languageclient";
 import * as folding from "../../src/features/Folding";
+import * as Settings from "../../src/settings";
 import { MockLogger } from "../test_utils";
 
 const fixturePath = path.join(__dirname, "..", "..", "..", "test", "fixtures");
@@ -22,6 +23,13 @@ function assertFoldingRegions(result, expected): void {
     assert.equal(result.length, expected.length);
 }
 
+// Wrap the FoldingProvider class with our own custom settings for testing
+class CustomSettingFoldingProvider extends folding.FoldingProvider {
+    public customSettings: Settings.ISettings = Settings.load();
+    // Overridde the super currentSettings method with our own custom test settings
+    public currentSettings(): Settings.ISettings { return this.customSettings; }
+}
+
 suite("Features", () => {
 
     suite("Folding Provider", async () => {
@@ -38,21 +46,21 @@ suite("Features", () => {
 
         suite("For a single document", async () => {
             const expectedFoldingRegions = [
-                { start: 0,  end: 4,  kind: 3 },
-                { start: 1,  end: 3,  kind: 1 },
-                { start: 10, end: 15, kind: 1 },
-                { start: 16, end: 60, kind: null },
-                { start: 17, end: 22, kind: 1 },
-                { start: 23, end: 26, kind: null },
-                { start: 28, end: 31, kind: null },
-                { start: 35, end: 37, kind: 1 },
-                { start: 39, end: 49, kind: 3 },
-                { start: 41, end: 45, kind: 3 },
-                { start: 51, end: 53, kind: null },
-                { start: 56, end: 59, kind: null },
-                { start: 64, end: 66, kind: 1 },
-                { start: 67, end: 72, kind: 3 },
-                { start: 68, end: 70, kind: 1 },
+                { start: 0,  end: 3,  kind: 3 },
+                { start: 1,  end: 2,  kind: 1 },
+                { start: 10, end: 14, kind: 1 },
+                { start: 16, end: 59, kind: null },
+                { start: 17, end: 21, kind: 1 },
+                { start: 23, end: 25, kind: null },
+                { start: 28, end: 30, kind: null },
+                { start: 35, end: 36, kind: 1 },
+                { start: 39, end: 48, kind: 3 },
+                { start: 41, end: 44, kind: 3 },
+                { start: 51, end: 52, kind: null },
+                { start: 56, end: 58, kind: null },
+                { start: 64, end: 65, kind: 1 },
+                { start: 67, end: 71, kind: 3 },
+                { start: 68, end: 69, kind: 1 },
             ];
 
             test("Can detect all of the foldable regions in a document with CRLF line endings", async () => {
@@ -83,9 +91,31 @@ suite("Features", () => {
                 assertFoldingRegions(result, expectedFoldingRegions);
             });
 
+            suite("Where showLastLine setting is false", async () => {
+                const customprovider = (new CustomSettingFoldingProvider(psGrammar));
+                customprovider.customSettings.codeFolding.showLastLine = false;
+
+                test("Can detect all foldable regions in a document", async () => {
+                    // Integration test against the test fixture 'folding-lf.ps1' that contains
+                    // all of the different types of folding available
+                    const uri = vscode.Uri.file(path.join(fixturePath, "folding-lf.ps1"));
+                    const document = await vscode.workspace.openTextDocument(uri);
+                    const result = await customprovider.provideFoldingRanges(document, null, null);
+
+                    // Incrememnt the end line of the expected regions by one as we will
+                    // be hiding the last line
+                    const expectedLastLineRegions = expectedFoldingRegions.map( (item) => {
+                        item.end++;
+                        return item;
+                    });
+
+                    assertFoldingRegions(result, expectedLastLineRegions);
+                });
+            });
+
             test("Can detect all of the foldable regions in a document with mismatched regions", async () => {
                 const expectedMismatchedFoldingRegions = [
-                    { start: 2,  end: 4,  kind: 3 },
+                    { start: 2,  end: 3,  kind: 3 },
                 ];
 
                 // Integration test against the test fixture 'folding-mismatch.ps1' that contains
@@ -99,8 +129,8 @@ suite("Features", () => {
 
             test("Does not return duplicate or overlapping regions", async () => {
                 const expectedMismatchedFoldingRegions = [
-                    { start: 1,  end: 2,  kind: null },
-                    { start: 2,  end: 4,  kind: null },
+                    { start: 1,  end: 1,  kind: null },
+                    { start: 2,  end: 3,  kind: null },
                 ];
 
                 // Integration test against the test fixture 'folding-mismatch.ps1' that contains