(todo) Add block region

Author: glennsarti

src/features/Folding.ts

@@ -12,32 +12,43 @@ import { IFeature } from "../feature";
 
 const rangeLimit = 5000;
 
-// https://github.com/Microsoft/vscode/issues/46281
 const tm = getCoreNodeModule("vscode-textmate");
-/**
- * Returns a node module installed with VSCode, or null if it fails.
- */
+
+// Returns a node module installed with VSCode, or null if it fails.
+// https://github.com/Microsoft/vscode/issues/46281
 function getCoreNodeModule(moduleName: string) {
     try {
         return require(`${vscode.env.appRoot}/node_modules.asar/${moduleName}`);
+    // tslint:disable-next-line:no-empty
     } catch (err) { }
 
     try {
         return require(`${vscode.env.appRoot}/node_modules/${moduleName}`);
+    // tslint:disable-next-line:no-empty
     } catch (err) { }
 
     return null;
 }
 
 interface IExtensionGrammar {
-    language?: string; scopeName?: string; path?: string; embeddedLanguages?: { [scopeName: string]: string }; injectTo?: string[];
+    language?: string;
+    scopeName?: string;
+    path?: string;
+    embeddedLanguages?: {
+        [scopeName: string]: string,
+    }; injectTo?: string[];
+}
+
+interface IExtensionLanguage {
+    id: string;
+    configuration: string;
 }
 
 interface IExtensionPackage {
     contributes?: {
-        languages?: { id: string; configuration: string }[],
+        languages?: IExtensionLanguage[],
         grammars?: IExtensionGrammar[],
-    }
+    };
 }
 
 // Need to reproduce the IToken interface from vscode-textmate due to
@@ -141,7 +152,11 @@ export class FoldingProvider implements vscode.FoldingRangeProvider {
         return foldingRanges;
     }
 
-    private matchScopeElements(tokens, startScopeName: string, endScopeName: string, matchType: MatchType, document: vscode.TextDocument): IMatchedTokenList {
+    private matchScopeElements(tokens,
+                               startScopeName: string,
+                               endScopeName: string,
+                               matchType: MatchType,
+                               document: vscode.TextDocument): IMatchedTokenList {
         const result = [];
         const tokenStack = [];
 
@@ -157,7 +172,10 @@ export class FoldingProvider implements vscode.FoldingRangeProvider {
         return result.reverse();
     }
 
-    private matchContiguousScopeElements(tokens, scopeName: string, matchType: MatchType, document) {
+    private matchContiguousScopeElements(tokens,
+                                         scopeName: string,
+                                         matchType: MatchType,
+                                         document: vscode.TextDocument) {
         const result = [];
         let startToken;
 
@@ -178,19 +196,22 @@ export class FoldingProvider implements vscode.FoldingRangeProvider {
     }
 
     // Given a zero based offset, find the line text preceeding it
-    private preceedingText(offset: number, document: vscode.TextDocument) {
+    private preceedingText(offset: number,
+                           document: vscode.TextDocument): string {
         const endPos = document.positionAt(offset);
         const startPos = endPos.translate(0, -endPos.character);
 
         return document.getText(new vscode.Range(startPos, endPos));
     }
 
     // Given a zero based offset, return the line number
-    private lineAtOffest(offset, document): number {
+    private lineAtOffest(offset: number,
+                         document: vscode.TextDocument): number {
         return document.positionAt(offset).line;
     }
 
-    private matchBlockCommentScopeElements(tokens, document: vscode.TextDocument) {
+    private matchBlockCommentScopeElements(tokens,
+                                           document: vscode.TextDocument) {
         const result = [];
 
         const emptyLine = new RegExp("^[\\s]+$");
@@ -214,7 +235,12 @@ export class FoldingProvider implements vscode.FoldingRangeProvider {
                         if (lineNum === nextLine) {
                             nextLine = lineNum + 1;
                         } else {
-                            result.push(new MatchedToken(null, null, startLine, nextLine - 1, MatchType.Comment, document));
+                            result.push(new MatchedToken(null,
+                                                         null,
+                                                         startLine,
+                                                         nextLine - 1,
+                                                         MatchType.Comment,
+                                                         document));
                             startLine = lineNum;
                             nextLine = lineNum + 1;
                         }
@@ -230,23 +256,90 @@ export class FoldingProvider implements vscode.FoldingRangeProvider {
         return result;
     }
 
+    // Given a zero based offset, find the line text after it
+    private subsequentText(offset: number,
+                           document: vscode.TextDocument): string {
+        const startPos = document.positionAt(offset);
+        // We don't know how long the line is so just return a really long one.
+        const endPos = startPos.translate(0, 1000);
+        return document.getText(new vscode.Range(startPos, endPos));
+    }
+
+    // Create a new token object with an appended scopeName
+    private addTokenScope(token,
+                          scopeName: string) {
+        // Only a shallow clone is required
+        const tokenClone = Object.assign({}, token);
+        tokenClone.scopes.push(scopeName);
+        return tokenClone;
+    }
+
+    private extractRegionScopeElements(tokens,
+                                       document: vscode.TextDocument) {
+        const result = [];
+
+        const emptyLine = new RegExp("^[\\s]+$");
+        const startRegionText = new RegExp("^#\\s*region\\b");
+        const endRegionText = new RegExp("^#\\s*endregion\\b");
+
+        tokens.forEach( (token, index) => {
+          if (token.scopes.includes("punctuation.definition.comment.powershell")) {
+            if (emptyLine.test(this.preceedingText(token.startIndex, document))) {
+              const commentText = this.subsequentText(token.startIndex, document);
+
+              if (startRegionText.test(commentText)) { result.push(this.addTokenScope(token, "custom.start.region")); }
+              if (endRegionText.test(commentText)) { result.push(this.addTokenScope(token, "custom.end.region")); }
+            }
+          }
+        });
+        return result;
+      }
+
     private matchGrammarTokens(tokens, document: vscode.TextDocument): IMatchedTokenList {
         const matchedTokens = [];
 
         // Find matching Braces   { -> }
-        this.matchScopeElements(tokens, "punctuation.section.braces.begin.powershell", "punctuation.section.braces.end.powershell", MatchType.Region, document).forEach((x) => { matchedTokens.push(x); });
-        // Find matching brackets   ( -> )
-        this.matchScopeElements(tokens, "punctuation.section.group.begin.powershell", "punctuation.section.group.end.powershell", MatchType.Region, document).forEach((x) => { matchedTokens.push(x); });
-
-        // Find contiguous here strings   @' -> '@   and   @" -> "@
-        this.matchContiguousScopeElements(tokens, "string.quoted.single.heredoc.powershell", MatchType.Region, document).forEach((x) => { matchedTokens.push(x); });
-        this.matchContiguousScopeElements(tokens, "string.quoted.double.heredoc.powershell", MatchType.Region, document).forEach((x) => { matchedTokens.push(x); });
+        this.matchScopeElements(tokens,
+                                "punctuation.section.braces.begin.powershell",
+                                "punctuation.section.braces.end.powershell",
+                                MatchType.Region, document)
+            .forEach((x) => { matchedTokens.push(x); });
 
-        // Find blocks of line comments   # foo
+        // Find matching brackets   ( -> )
+        this.matchScopeElements(tokens,
+                                "punctuation.section.group.begin.powershell",
+                                "punctuation.section.group.end.powershell",
+                                MatchType.Region, document)
+            .forEach((x) => { matchedTokens.push(x); });
+
+        // Find contiguous here strings   @' -> '@
+        this.matchContiguousScopeElements(tokens,
+                                          "string.quoted.single.heredoc.powershell",
+                                          MatchType.Region, document)
+            .forEach((x) => { matchedTokens.push(x); });
+
+        // Find contiguous here strings   @" -> "@
+        this.matchContiguousScopeElements(tokens,
+                                          "string.quoted.double.heredoc.powershell",
+                                          MatchType.Region, document)
+            .forEach((x) => { matchedTokens.push(x); });
+
+        // Find matching Braces   #region -> #endregion
+        this.matchScopeElements(this.extractRegionScopeElements(tokens, document),
+                                "custom.start.region",
+                                "custom.end.region",
+                                MatchType.Region, document)
+            .forEach( (x) => { matchedTokens.push(x); });
+
+        // Find blocks of line comments   # comment1\n# comment2\n...
         this.matchBlockCommentScopeElements(tokens, document).forEach((x) => { matchedTokens.push(x); });
 
         // Find matching function definitions   <# -> #>
-        this.matchScopeElements(tokens, "punctuation.definition.comment.block.begin.powershell", "punctuation.definition.comment.block.end.powershell",  MatchType.Comment, document).forEach( (x) => { matchedTokens.push(x); });
+        this.matchScopeElements(tokens,
+                                "punctuation.definition.comment.block.begin.powershell",
+                                "punctuation.definition.comment.block.end.powershell",
+                                MatchType.Comment, document)
+            .forEach( (x) => { matchedTokens.push(x); });
 
         return matchedTokens;
     }
@@ -286,12 +379,9 @@ export class FoldingFeature implements IFeature {
             this.foldingProvider);
     }
 
-    public dispose(): any {
-        // Should be empty
-    }
+    // tslint:disable-next-line:no-empty
+    public dispose(): any { }
 
-    public setLanguageClient(languageclient: LanguageClient): void {
-        this.languageClient = languageclient;
-        // this.foldingProvider.setLanguageClient(languageclient);
-    }
+    // tslint:disable-next-line:no-empty
+    public setLanguageClient(languageclient: LanguageClient): void { }
 }