(todo) Brackets are working

Author: glennsarti

src/features/Folding.ts

@@ -40,6 +40,38 @@ interface IExtensionPackage {
     }
   }
 
+// Need to reproduce the IToken interface from vscode-textmate due to
+// the odd way it has to be required
+export interface IToken {
+    startIndex: number;
+    readonly endIndex: number;
+    readonly scopes: string[];
+}
+
+class MatchedToken {
+    public start: IToken;
+    public startline: number;
+    public end: IToken;
+    public endline: number;
+
+    constructor(start, end, document: vscode.TextDocument) {
+        this.start = start;
+        this.end = end;
+        this.startline = document.positionAt(start.startIndex).line;
+        this.endline = document.positionAt(end.startIndex).line;
+    }
+
+    public isValidRange(): boolean {
+        return (this.endline - this.startline >= 2);
+    }
+
+    public toFoldingRange(): vscode.FoldingRange {
+        return new vscode.FoldingRange(this.startline, this.endline, vscode.FoldingRangeKind.Region);
+    }
+}
+
+interface IMatchedTokenList extends Array<MatchedToken> {}
+
 export class FoldingProvider implements vscode.FoldingRangeProvider {
     private powershellGrammar;
 
@@ -54,46 +86,65 @@ export class FoldingProvider implements vscode.FoldingRangeProvider {
 
         const foldingRanges = [];
 
-        console.log(document);
-        console.log(context);
-        console.log(token);
+        // Convert the document text into a series of grammar tokens
+
+        const tokens = this.grammar().tokenizeLine(document.getText()).tokens;
+        // Parse the token list looking for matching tokens and return
+        // a list of <start, end>.  Then filter the list and only return token matches
+        // that are a valid text range e.g. Needs to span at least 3 lines
+        const foldableTokens = this.matchGrammarTokens(tokens, document)
+            .filter( (item) => item.isValidRange());
+
+        // Sort the list of matched tokens to start at the top of the document,
+        // and ensure that in the case of multiple ranges starting the same line,
+        // that the largest range (i.e. most number of lines spanned) is sorted
+        // first.  This is needed as vscode will just ignore any duplicate folding
+        // ranges
+        foldableTokens.sort( (a: MatchedToken, b: MatchedToken) => {
+            // Initially look at the start line
+            if (a.startline > b.startline) { return 1; }
+            if (a.startline < b.startline) { return -1; }
+            // They have the same start line so now consider the end line.
+            // The biggest line range is sorted first
+            if (a.endline > b.endline) { return -1; }
+            if (a.endline < b.endline) { return 1; }
+            // They're the same
+            return 0;
+        });
+
+        // Convert the matched token list into a FoldingRange[]
+        foldableTokens.forEach( (item) => { foldingRanges.push(item.toFoldingRange()); });
+
+        // console.log(foldableTokens);
 
-        const content = document.getText();
+        return foldingRanges;
+    }
+
+    private matchScopeElements(tokens, startScopeName, endScopeName, document: vscode.TextDocument): IMatchedTokenList {
+        const result = [];
+        const tokenStack = [];
 
-        let tokens = this.grammar().tokenizeLine(content).tokens;
-        for (var i = 0; i < tokens.length; i++) {
-            tokens[i]['value'] = content.substring(tokens[i]['startIndex'], tokens[i]['endIndex']);
-            tokens[i]['startLine'] = document.positionAt(tokens[i]["startIndex"]).line;
-            tokens[i]['endLine'] = document.positionAt(tokens[i]["endIndex"]).line;
+        tokens.forEach( (token) => {
+          if (token.scopes.includes(startScopeName)) {
+            tokenStack.push(token);
           }
+          if (token.scopes.includes(endScopeName)) {
+            result.push(new MatchedToken(tokenStack.pop(), token, document));
+          }
+        });
 
-        // Just force a fixed folding range to see what happens
-        foldingRanges.push(new vscode.FoldingRange(1, 3, vscode.FoldingRangeKind.Region));
-
-        console.log(tokens);
-        // const tocProvider = new TableOfContentsProvider(this.engine, document);
-        // let toc = await tocProvider.getToc();
-        // if (toc.length > rangeLimit) {
-        //     toc = toc.slice(0, rangeLimit);
-        // }
-
-        // const foldingRanges = toc.map((entry, startIndex) => {
-        //     const start = entry.line;
-        //     let end: number | undefined = undefined;
-        //     for (let i = startIndex + 1; i < toc.length; ++i) {
-        //         if (toc[i].level <= entry.level) {
-        //             end = toc[i].line - 1;
-        //             if (document.lineAt(end).isEmptyOrWhitespace && end >= start + 1) {
-        //                 end = end - 1;
-        //             }
-        //             break;
-        //         }
-        //     }
-        //     return new vscode.FoldingRange(
-        //         start,
-        //         typeof end === 'number' ? end : document.lineCount - 1);
-        // });
-        return foldingRanges;
+        return result.reverse();
+    }
+
+    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", document).forEach((x) => { matchedTokens.push(x); });
+        // Find matching brackets   ( -> )
+        this.matchScopeElements(tokens, "punctuation.section.group.begin.powershell", "punctuation.section.group.end.powershell", document).forEach( (x) => { matchedTokens.push(x); });
+
+        return matchedTokens;
     }
 
     private powerShellGrammarPath(): string {